diff --git a/sys/contrib/openzfs/.github/workflows/codeql.yml b/sys/contrib/openzfs/.github/workflows/codeql.yml
index 2656a20fea0d..e975d7dd00b9 100644
--- a/sys/contrib/openzfs/.github/workflows/codeql.yml
+++ b/sys/contrib/openzfs/.github/workflows/codeql.yml
@@ -1,45 +1,45 @@
 name: "CodeQL"
 
 on:
   push:
   pull_request:
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
   cancel-in-progress: true
 
 jobs:
   analyze:
     name: Analyze
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     permissions:
       actions: read
       contents: read
       security-events: write
 
     strategy:
       fail-fast: false
       matrix:
         language: [ 'cpp', 'python' ]
 
     steps:
     - name: Set make jobs
       run: |
         echo "MAKEFLAGS=-j$(nproc)" >> $GITHUB_ENV
 
     - name: Checkout repository
       uses: actions/checkout@v4
 
     - name: Initialize CodeQL
       uses: github/codeql-action/init@v3
       with:
         config-file: .github/codeql-${{ matrix.language }}.yml
         languages: ${{ matrix.language }}
 
     - name: Autobuild
       uses: github/codeql-action/autobuild@v3
 
     - name: Perform CodeQL Analysis
       uses: github/codeql-action/analyze@v3
       with:
         category: "/language:${{matrix.language}}"
diff --git a/sys/contrib/openzfs/.github/workflows/scripts/qemu-1-setup.sh b/sys/contrib/openzfs/.github/workflows/scripts/qemu-1-setup.sh
index ebd80a2f98c1..f838da34efff 100755
--- a/sys/contrib/openzfs/.github/workflows/scripts/qemu-1-setup.sh
+++ b/sys/contrib/openzfs/.github/workflows/scripts/qemu-1-setup.sh
@@ -1,91 +1,93 @@
 #!/usr/bin/env bash
 
 ######################################################################
 # 1) setup qemu instance on action runner
 ######################################################################
 
 set -eu
 
 # install needed packages
 export DEBIAN_FRONTEND="noninteractive"
 sudo apt-get -y update
 sudo apt-get install -y axel cloud-image-utils daemonize guestfs-tools \
   ksmtuned virt-manager linux-modules-extra-$(uname -r) zfsutils-linux
 
 # generate ssh keys
 rm -f ~/.ssh/id_ed25519
 ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519 -q -N ""
 
 # we expect RAM shortage
 cat << EOF | sudo tee /etc/ksmtuned.conf > /dev/null
+# /etc/ksmtuned.conf - Configuration file for ksmtuned
 # https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/7/html/virtualization_tuning_and_optimization_guide/chap-ksm
 KSM_MONITOR_INTERVAL=60
 
 # Millisecond sleep between ksm scans for 16Gb server.
 # Smaller servers sleep more, bigger sleep less.
-KSM_SLEEP_MSEC=10
-KSM_NPAGES_BOOST=300
-KSM_NPAGES_DECAY=-50
-KSM_NPAGES_MIN=64
-KSM_NPAGES_MAX=2048
-
-KSM_THRES_COEF=25
-KSM_THRES_CONST=2048
+KSM_SLEEP_MSEC=30
+
+KSM_NPAGES_BOOST=0
+KSM_NPAGES_DECAY=0
+KSM_NPAGES_MIN=1000
+KSM_NPAGES_MAX=25000
+
+KSM_THRES_COEF=80
+KSM_THRES_CONST=8192
 
 LOGFILE=/var/log/ksmtuned.log
 DEBUG=1
 EOF
 sudo systemctl restart ksm
 sudo systemctl restart ksmtuned
 
 # not needed
 sudo systemctl stop docker.socket
 sudo systemctl stop multipathd.socket
 
 # remove default swapfile and /mnt
 sudo swapoff -a
 sudo umount -l /mnt
 DISK="/dev/disk/cloud/azure_resource-part1"
 sudo sed -e "s|^$DISK.*||g" -i /etc/fstab
 sudo wipefs -aq $DISK
 sudo systemctl daemon-reload
 
 sudo modprobe loop
 sudo modprobe zfs
 
 # partition the disk as needed
 DISK="/dev/disk/cloud/azure_resource"
 sudo sgdisk --zap-all $DISK
 sudo sgdisk -p \
  -n 1:0:+16G -c 1:"swap" \
  -n 2:0:0    -c 2:"tests" \
 $DISK
 sync
 sleep 1
 
 # swap with same size as RAM
 sudo mkswap $DISK-part1
 sudo swapon $DISK-part1
 
 # 60GB data disk
 SSD1="$DISK-part2"
 
 # 10GB data disk on ext4
 sudo fallocate -l 10G /test.ssd1
 SSD2=$(sudo losetup -b 4096 -f /test.ssd1 --show)
 
 # adjust zfs module parameter and create pool
 exec 1>/dev/null
 ARC_MIN=$((1024*1024*256))
 ARC_MAX=$((1024*1024*512))
 echo $ARC_MIN | sudo tee /sys/module/zfs/parameters/zfs_arc_min
 echo $ARC_MAX | sudo tee /sys/module/zfs/parameters/zfs_arc_max
 echo 1 | sudo tee /sys/module/zfs/parameters/zvol_use_blk_mq
 sudo zpool create -f -o ashift=12 zpool $SSD1 $SSD2 \
   -O relatime=off -O atime=off -O xattr=sa -O compression=lz4 \
   -O mountpoint=/mnt/tests
 
 # no need for some scheduler
 for i in /sys/block/s*/queue/scheduler; do
   echo "none" | sudo tee $i > /dev/null
 done
diff --git a/sys/contrib/openzfs/.github/workflows/scripts/qemu-2-start.sh b/sys/contrib/openzfs/.github/workflows/scripts/qemu-2-start.sh
index 923c38c0f937..84e13832d10f 100755
--- a/sys/contrib/openzfs/.github/workflows/scripts/qemu-2-start.sh
+++ b/sys/contrib/openzfs/.github/workflows/scripts/qemu-2-start.sh
@@ -1,213 +1,225 @@
 #!/usr/bin/env bash
 
 ######################################################################
 # 2) start qemu with some operating system, init via cloud-init
 ######################################################################
 
 set -eu
 
 # short name used in zfs-qemu.yml
 OS="$1"
 
 # OS variant (virt-install --os-variant list)
 OSv=$OS
 
 # compressed with .zst extension
 REPO="https://github.com/mcmilk/openzfs-freebsd-images"
-FREEBSD="$REPO/releases/download/v2024-09-16"
+FREEBSD="$REPO/releases/download/v2024-10-05"
 URLzs=""
 
 # Ubuntu mirrors
 #UBMIRROR="https://cloud-images.ubuntu.com"
 #UBMIRROR="https://mirrors.cloud.tencent.com/ubuntu-cloud-images"
 UBMIRROR="https://mirror.citrahost.com/ubuntu-cloud-images"
 
 # default nic model for vm's
 NIC="virtio"
 
 case "$OS" in
   almalinux8)
     OSNAME="AlmaLinux 8"
     URL="https://repo.almalinux.org/almalinux/8/cloud/x86_64/images/AlmaLinux-8-GenericCloud-latest.x86_64.qcow2"
     ;;
   almalinux9)
     OSNAME="AlmaLinux 9"
     URL="https://repo.almalinux.org/almalinux/9/cloud/x86_64/images/AlmaLinux-9-GenericCloud-latest.x86_64.qcow2"
     ;;
   archlinux)
     OSNAME="Archlinux"
     URL="https://geo.mirror.pkgbuild.com/images/latest/Arch-Linux-x86_64-cloudimg.qcow2"
     # dns sometimes fails with that url  :/
     echo "89.187.191.12  geo.mirror.pkgbuild.com" | sudo tee /etc/hosts > /dev/null
     ;;
   centos-stream9)
     OSNAME="CentOS Stream 9"
     URL="https://cloud.centos.org/centos/9-stream/x86_64/images/CentOS-Stream-GenericCloud-9-latest.x86_64.qcow2"
     ;;
   debian11)
     OSNAME="Debian 11"
     URL="https://cloud.debian.org/images/cloud/bullseye/latest/debian-11-generic-amd64.qcow2"
     ;;
   debian12)
     OSNAME="Debian 12"
     URL="https://cloud.debian.org/images/cloud/bookworm/latest/debian-12-generic-amd64.qcow2"
     ;;
   fedora39)
     OSNAME="Fedora 39"
     OSv="fedora39"
     URL="https://download.fedoraproject.org/pub/fedora/linux/releases/39/Cloud/x86_64/images/Fedora-Cloud-Base-39-1.5.x86_64.qcow2"
     ;;
   fedora40)
     OSNAME="Fedora 40"
     OSv="fedora39"
     URL="https://download.fedoraproject.org/pub/fedora/linux/releases/40/Cloud/x86_64/images/Fedora-Cloud-Base-Generic.x86_64-40-1.14.qcow2"
     ;;
-  freebsd13r)
-    OSNAME="FreeBSD 13.4-RELEASE"
+  freebsd13-3r)
+    OSNAME="FreeBSD 13.3-RELEASE"
     OSv="freebsd13.0"
-    URLzs="$FREEBSD/amd64-freebsd-13.4-RELEASE.qcow2.zst"
+    URLzs="$FREEBSD/amd64-freebsd-13.3-RELEASE.qcow2.zst"
     BASH="/usr/local/bin/bash"
     NIC="rtl8139"
     ;;
-  freebsd13)
-    OSNAME="FreeBSD 13.4-STABLE"
+  freebsd13-4r)
+    OSNAME="FreeBSD 13.4-RELEASE"
     OSv="freebsd13.0"
-    URLzs="$FREEBSD/amd64-freebsd-13.4-STABLE.qcow2.zst"
+    URLzs="$FREEBSD/amd64-freebsd-13.4-RELEASE.qcow2.zst"
     BASH="/usr/local/bin/bash"
     NIC="rtl8139"
     ;;
-  freebsd14r)
+  freebsd14-0r)
+    OSNAME="FreeBSD 14.0-RELEASE"
+    OSv="freebsd14.0"
+    URLzs="$FREEBSD/amd64-freebsd-14.0-RELEASE.qcow2.zst"
+    BASH="/usr/local/bin/bash"
+    ;;
+  freebsd14-1r)
     OSNAME="FreeBSD 14.1-RELEASE"
     OSv="freebsd14.0"
     URLzs="$FREEBSD/amd64-freebsd-14.1-RELEASE.qcow2.zst"
     BASH="/usr/local/bin/bash"
     ;;
-  freebsd14)
+  freebsd13-4s)
+    OSNAME="FreeBSD 13.4-STABLE"
+    OSv="freebsd13.0"
+    URLzs="$FREEBSD/amd64-freebsd-13.4-STABLE.qcow2.zst"
+    BASH="/usr/local/bin/bash"
+    ;;
+  freebsd14-1s)
     OSNAME="FreeBSD 14.1-STABLE"
     OSv="freebsd14.0"
     URLzs="$FREEBSD/amd64-freebsd-14.1-STABLE.qcow2.zst"
     BASH="/usr/local/bin/bash"
     ;;
-  freebsd15)
+  freebsd15-0c)
     OSNAME="FreeBSD 15.0-CURRENT"
     OSv="freebsd14.0"
     URLzs="$FREEBSD/amd64-freebsd-15.0-CURRENT.qcow2.zst"
     BASH="/usr/local/bin/bash"
     ;;
   tumbleweed)
     OSNAME="openSUSE Tumbleweed"
     OSv="opensusetumbleweed"
     MIRROR="http://opensuse-mirror-gce-us.susecloud.net"
     URL="$MIRROR/tumbleweed/appliances/openSUSE-MicroOS.x86_64-OpenStack-Cloud.qcow2"
     ;;
   ubuntu20)
     OSNAME="Ubuntu 20.04"
     OSv="ubuntu20.04"
     URL="$UBMIRROR/focal/current/focal-server-cloudimg-amd64.img"
     ;;
   ubuntu22)
     OSNAME="Ubuntu 22.04"
     OSv="ubuntu22.04"
     URL="$UBMIRROR/jammy/current/jammy-server-cloudimg-amd64.img"
     ;;
   ubuntu24)
     OSNAME="Ubuntu 24.04"
     OSv="ubuntu24.04"
     URL="$UBMIRROR/noble/current/noble-server-cloudimg-amd64.img"
     ;;
   *)
     echo "Wrong value for OS variable!"
     exit 111
     ;;
 esac
 
 # environment file
 ENV="/var/tmp/env.txt"
 echo "ENV=$ENV" >> $ENV
 
 # result path
 echo 'RESPATH="/var/tmp/test_results"' >> $ENV
 
 # FreeBSD 13 has problems with: e1000+virtio
 echo "NIC=$NIC" >> $ENV
 
 # freebsd15 -> used in zfs-qemu.yml
 echo "OS=$OS" >> $ENV
 
 # freebsd14.0 -> used for virt-install
 echo "OSv=\"$OSv\"" >> $ENV
 
 # FreeBSD 15 (Current) -> used for summary
 echo "OSNAME=\"$OSNAME\"" >> $ENV
 
 sudo mkdir -p "/mnt/tests"
 sudo chown -R $(whoami) /mnt/tests
 
 # we are downloading via axel, curl and wget are mostly slower and
 # require more return value checking
 IMG="/mnt/tests/cloudimg.qcow2"
 if [ ! -z "$URLzs" ]; then
   echo "Loading image $URLzs ..."
   time axel -q -o "$IMG.zst" "$URLzs"
   zstd -q -d --rm "$IMG.zst"
 else
   echo "Loading image $URL ..."
   time axel -q -o "$IMG" "$URL"
 fi
 
 DISK="/dev/zvol/zpool/openzfs"
 FORMAT="raw"
 sudo zfs create -ps -b 64k -V 80g zpool/openzfs
 while true; do test -b $DISK && break; sleep 1; done
 echo "Importing VM image to zvol..."
 sudo qemu-img dd -f qcow2 -O raw if=$IMG of=$DISK bs=4M
 rm -f $IMG
 
 PUBKEY=$(cat ~/.ssh/id_ed25519.pub)
 cat <<EOF > /tmp/user-data
 #cloud-config
 
 fqdn: $OS
 
 users:
 - name: root
   shell: $BASH
 - name: zfs
   sudo: ALL=(ALL) NOPASSWD:ALL
   shell: $BASH
   ssh_authorized_keys:
     - $PUBKEY
 
 growpart:
   mode: auto
   devices: ['/']
   ignore_growroot_disabled: false
 EOF
 
 sudo virsh net-update default add ip-dhcp-host \
   "<host mac='52:54:00:83:79:00' ip='192.168.122.10'/>" --live --config
 
 sudo virt-install \
   --os-variant $OSv \
   --name "openzfs" \
   --cpu host-passthrough \
   --virt-type=kvm --hvm \
   --vcpus=4,sockets=1 \
   --memory $((1024*12)) \
   --memballoon model=virtio \
   --graphics none \
   --network bridge=virbr0,model=$NIC,mac='52:54:00:83:79:00' \
   --cloud-init user-data=/tmp/user-data \
   --disk $DISK,bus=virtio,cache=none,format=$FORMAT,driver.discard=unmap \
   --import --noautoconsole >/dev/null
 
 # in case the directory isn't there already
 mkdir -p $HOME/.ssh
 
 cat <<EOF >> $HOME/.ssh/config
 # no questions please
 StrictHostKeyChecking no
 
 # small timeout, used in while loops later
 ConnectTimeout 1
 EOF
diff --git a/sys/contrib/openzfs/.github/workflows/scripts/qemu-5-setup.sh b/sys/contrib/openzfs/.github/workflows/scripts/qemu-5-setup.sh
index 7acb67a27920..bc40e8894b22 100755
--- a/sys/contrib/openzfs/.github/workflows/scripts/qemu-5-setup.sh
+++ b/sys/contrib/openzfs/.github/workflows/scripts/qemu-5-setup.sh
@@ -1,121 +1,126 @@
 #!/usr/bin/env bash
 
 ######################################################################
 # 5) start test machines and load openzfs module
 ######################################################################
 
 set -eu
 
 # read our defined variables
 source /var/tmp/env.txt
 
 # wait for poweroff to succeed
 PID=$(pidof /usr/bin/qemu-system-x86_64)
 tail --pid=$PID -f /dev/null
 sudo virsh undefine openzfs
 
-# definitions of per operating system
+# default values per test vm:
+VMs=2
+CPU=2
+
+# cpu pinning
+CPUSET=("0,1" "2,3")
+
 case "$OS" in
   freebsd*)
-    VMs=2
-    CPU=3
+    # FreeBSD can't be optimized via ksmtuned
     RAM=6
     ;;
   *)
-    VMs=2
-    CPU=3
-    RAM=7
+    # Linux can be optimized via ksmtuned
+    RAM=8
     ;;
 esac
 
 # this can be different for each distro
 echo "VMs=$VMs" >> $ENV
 
 # create snapshot we can clone later
 sudo zfs snapshot zpool/openzfs@now
 
 # setup the testing vm's
 PUBKEY=$(cat ~/.ssh/id_ed25519.pub)
 for i in $(seq 1 $VMs); do
 
   echo "Creating disk for vm$i..."
   DISK="/dev/zvol/zpool/vm$i"
   FORMAT="raw"
   sudo zfs clone zpool/openzfs@now zpool/vm$i
   sudo zfs create -ps -b 64k -V 80g zpool/vm$i-2
 
   cat <<EOF > /tmp/user-data
 #cloud-config
 
 fqdn: vm$i
 
 users:
 - name: root
   shell: $BASH
 - name: zfs
   sudo: ALL=(ALL) NOPASSWD:ALL
   shell: $BASH
   ssh_authorized_keys:
     - $PUBKEY
 
 growpart:
   mode: auto
   devices: ['/']
   ignore_growroot_disabled: false
 EOF
 
   sudo virsh net-update default add ip-dhcp-host \
     "<host mac='52:54:00:83:79:0$i' ip='192.168.122.1$i'/>" --live --config
 
   sudo virt-install \
     --os-variant $OSv \
     --name "vm$i" \
     --cpu host-passthrough \
     --virt-type=kvm --hvm \
     --vcpus=$CPU,sockets=1 \
+    --cpuset=${CPUSET[$((i-1))]} \
     --memory $((1024*RAM)) \
     --memballoon model=virtio \
     --graphics none \
     --cloud-init user-data=/tmp/user-data \
     --network bridge=virbr0,model=$NIC,mac="52:54:00:83:79:0$i" \
     --disk $DISK,bus=virtio,cache=none,format=$FORMAT,driver.discard=unmap \
     --disk $DISK-2,bus=virtio,cache=none,format=$FORMAT,driver.discard=unmap \
     --import --noautoconsole >/dev/null
 done
 
 # check the memory state from time to time
 cat <<EOF > cronjob.sh
 # $OS
 exec 1>>/var/tmp/stats.txt
 exec 2>&1
 echo "*******************************************************"
 date
 uptime
 free -m
 df -h /mnt/tests
 zfs list
 EOF
 sudo chmod +x cronjob.sh
 sudo mv -f cronjob.sh /root/cronjob.sh
 echo '*/5 * * * *  /root/cronjob.sh' > crontab.txt
 sudo crontab crontab.txt
 rm crontab.txt
 
 # check if the machines are okay
 echo "Waiting for vm's to come up...  (${VMs}x CPU=$CPU RAM=$RAM)"
 for i in $(seq 1 $VMs); do
   while true; do
     ssh 2>/dev/null zfs@192.168.122.1$i "uname -a" && break
   done
 done
 echo "All $VMs VMs are up now."
 
 # Save the VM's serial output (ttyS0) to /var/tmp/console.txt
 # - ttyS0 on the VM corresponds to a local /dev/pty/N entry
 # - use 'virsh ttyconsole' to lookup the /dev/pty/N entry
 for i in $(seq 1 $VMs); do
   mkdir -p $RESPATH/vm$i
   read "pty" <<< $(sudo virsh ttyconsole vm$i)
   sudo nohup bash -c "cat $pty > $RESPATH/vm$i/console.txt" &
 done
 echo "Console logging for ${VMs}x $OS started."
diff --git a/sys/contrib/openzfs/.github/workflows/scripts/qemu-9-summary-page.sh b/sys/contrib/openzfs/.github/workflows/scripts/qemu-9-summary-page.sh
index cae287ac1073..737dda01b565 100755
--- a/sys/contrib/openzfs/.github/workflows/scripts/qemu-9-summary-page.sh
+++ b/sys/contrib/openzfs/.github/workflows/scripts/qemu-9-summary-page.sh
@@ -1,57 +1,57 @@
 #!/usr/bin/env bash
 
 ######################################################################
 # 9) generate github summary page of all the testings
 ######################################################################
 
 set -eu
 
 function output() {
   echo -e $* >> "out-$logfile.md"
 }
 
 function outfile() {
-  test -s "$1" || return
   cat "$1" >> "out-$logfile.md"
 }
 
 function outfile_plain() {
-  test -s "$1" || return
   output "<pre>"
   cat "$1" >> "out-$logfile.md"
   output "</pre>"
 }
 
 function send2github() {
   test -f "$1" || exit 0
   dd if="$1" bs=1023k count=1 >> $GITHUB_STEP_SUMMARY
 }
 
 # https://docs.github.com/en/enterprise-server@3.6/actions/using-workflows/workflow-commands-for-github-actions#step-isolation-and-limits
 # Job summaries are isolated between steps and each step is restricted to a maximum size of 1MiB.
 # [ ] can not show all error findings here
 # [x] split files into smaller ones and create additional steps
 
 # first call, generate all summaries
 if [ ! -f out-1.md ]; then
   logfile="1"
   for tarfile in Logs-functional-*/qemu-*.tar; do
     rm -rf vm* *.txt
     if [ ! -s "$tarfile" ]; then
       output "\n## Functional Tests: unknown\n"
       output ":exclamation: Tarfile $tarfile is empty :exclamation:"
       continue
     fi
     tar xf "$tarfile"
     test -s env.txt || continue
     source env.txt
+    # when uname.txt is there, the other files are also ok
+    test -s uname.txt || continue
     output "\n## Functional Tests: $OSNAME\n"
     outfile_plain uname.txt
     outfile_plain summary.txt
     outfile failed.txt
     logfile=$((logfile+1))
   done
   send2github out-1.md
 else
   send2github out-$1.md
 fi
diff --git a/sys/contrib/openzfs/.github/workflows/zfs-qemu.yml b/sys/contrib/openzfs/.github/workflows/zfs-qemu.yml
index 8922701f9899..f819e9938e31 100644
--- a/sys/contrib/openzfs/.github/workflows/zfs-qemu.yml
+++ b/sys/contrib/openzfs/.github/workflows/zfs-qemu.yml
@@ -1,175 +1,177 @@
 name: zfs-qemu
 
 on:
   push:
   pull_request:
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
   cancel-in-progress: true
 
 jobs:
   test-config:
     name: Setup
     runs-on: ubuntu-24.04
     outputs:
       test_os: ${{ steps.os.outputs.os }}
       ci_type: ${{ steps.os.outputs.ci_type }}
     steps:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Generate OS config and CI type
         id: os
         run: |
-          FULL_OS='["almalinux8", "almalinux9", "centos-stream9", "debian11", "debian12", "fedora39", "fedora40", "freebsd13", "freebsd13r", "freebsd14", "freebsd14r", "ubuntu20", "ubuntu22", "ubuntu24"]'
-          QUICK_OS='["almalinux8", "almalinux9", "debian12", "fedora40", "freebsd13", "freebsd14", "ubuntu24"]'
+          FULL_OS='["almalinux8", "almalinux9", "centos-stream9", "debian11", "debian12", "fedora39", "fedora40", "freebsd13-4r", "freebsd14-0r", "freebsd14-1s", "ubuntu20", "ubuntu22", "ubuntu24"]'
+          QUICK_OS='["almalinux8", "almalinux9", "debian12", "fedora40", "freebsd13-3r", "freebsd14-1r", "ubuntu24"]'
           # determine CI type when running on PR
           ci_type="full"
           if ${{ github.event_name == 'pull_request' }}; then
             head=${{ github.event.pull_request.head.sha }}
             base=${{ github.event.pull_request.base.sha }}
             ci_type=$(python3 .github/workflows/scripts/generate-ci-type.py $head $base)
           fi
           if [ "$ci_type" == "quick" ]; then
             os_selection="$QUICK_OS"
           else
             os_selection="$FULL_OS"
           fi
           os_json=$(echo ${os_selection} | jq -c)
           echo "os=$os_json" >> $GITHUB_OUTPUT
           echo "ci_type=$ci_type" >> $GITHUB_OUTPUT
 
   qemu-vm:
     name: qemu-x86
     needs: [ test-config ]
     strategy:
       fail-fast: false
       matrix:
-        # all:
-        # os:  [almalinux8, almalinux9, archlinux, centos-stream9, fedora39, fedora40, debian11, debian12, freebsd13, freebsd13r, freebsd14, freebsd14r, freebsd15, ubuntu20, ubuntu22, ubuntu24]
-        # openzfs:
-        # os: [almalinux8, almalinux9, centos-stream9, debian11, debian12, fedora39, fedora40, freebsd13, freebsd13r, freebsd14, freebsd14r, ubuntu20, ubuntu22, ubuntu24]
+        # rhl:     almalinux8, almalinux9, centos-stream9, fedora39, fedora40
+        # debian:  debian11, debian12, ubuntu20, ubuntu22, ubuntu24
+        # misc:    archlinux, tumbleweed
+        # FreeBSD Release: freebsd13-3r, freebsd13-4r, freebsd14-0r, freebsd14-1r
+        # FreeBSD Stable:  freebsd13-4s, freebsd14-1s
+        # FreeBSD Current: freebsd15-0c
         os: ${{ fromJson(needs.test-config.outputs.test_os) }}
     runs-on: ubuntu-24.04
     steps:
     - uses: actions/checkout@v4
       with:
         ref: ${{ github.event.pull_request.head.sha }}
 
     - name: Setup QEMU
       timeout-minutes: 10
       run: .github/workflows/scripts/qemu-1-setup.sh
 
     - name: Start build machine
       timeout-minutes: 10
       run: .github/workflows/scripts/qemu-2-start.sh ${{ matrix.os }}
 
     - name: Install dependencies
       timeout-minutes: 20
       run: |
         echo "Install dependencies in QEMU machine"
         IP=192.168.122.10
         while pidof /usr/bin/qemu-system-x86_64 >/dev/null; do
           ssh 2>/dev/null zfs@$IP "uname -a" && break
         done
         scp .github/workflows/scripts/qemu-3-deps.sh zfs@$IP:qemu-3-deps.sh
         PID=`pidof /usr/bin/qemu-system-x86_64`
         ssh zfs@$IP '$HOME/qemu-3-deps.sh' ${{ matrix.os }}
         # wait for poweroff to succeed
         tail --pid=$PID -f /dev/null
         sleep 5 # avoid this: "error: Domain is already active"
         rm -f $HOME/.ssh/known_hosts
 
     - name: Build modules
       timeout-minutes: 30
       run: |
         echo "Build modules in QEMU machine"
         sudo virsh start openzfs
         IP=192.168.122.10
         while pidof /usr/bin/qemu-system-x86_64 >/dev/null; do
           ssh 2>/dev/null zfs@$IP "uname -a" && break
         done
         rsync -ar $HOME/work/zfs/zfs zfs@$IP:./
         ssh zfs@$IP '$HOME/zfs/.github/workflows/scripts/qemu-4-build.sh' ${{ matrix.os }}
 
     - name: Setup testing machines
       timeout-minutes: 5
       run: .github/workflows/scripts/qemu-5-setup.sh
 
     - name: Run tests
       timeout-minutes: 270
       run: .github/workflows/scripts/qemu-6-tests.sh
       env:
         CI_TYPE: ${{ needs.test-config.outputs.ci_type }}
 
     - name: Prepare artifacts
       if: always()
       timeout-minutes: 10
       run: .github/workflows/scripts/qemu-7-prepare.sh
 
     - uses: actions/upload-artifact@v4
       id: artifact-upload
       if: always()
       with:
         name: Logs-functional-${{ matrix.os }}
         path: /tmp/qemu-${{ matrix.os }}.tar
         if-no-files-found: ignore
 
     - name: Test Summary
       if: always()
       run: .github/workflows/scripts/qemu-8-summary.sh '${{ steps.artifact-upload.outputs.artifact-url }}'
 
   cleanup:
     if: always()
     name: Cleanup
     runs-on: ubuntu-latest
     needs: [ qemu-vm ]
 
     steps:
     - uses: actions/checkout@v4
       with:
         ref: ${{ github.event.pull_request.head.sha }}
     - uses: actions/download-artifact@v4
     - name: Generating summary
       run: .github/workflows/scripts/qemu-9-summary-page.sh
     - name: Generating summary...
       run: .github/workflows/scripts/qemu-9-summary-page.sh 2
     - name: Generating summary...
       run: .github/workflows/scripts/qemu-9-summary-page.sh 3
     - name: Generating summary...
       run: .github/workflows/scripts/qemu-9-summary-page.sh 4
     - name: Generating summary...
       run: .github/workflows/scripts/qemu-9-summary-page.sh 5
     - name: Generating summary...
       run: .github/workflows/scripts/qemu-9-summary-page.sh 6
     - name: Generating summary...
       run: .github/workflows/scripts/qemu-9-summary-page.sh 7
     - name: Generating summary...
       run: .github/workflows/scripts/qemu-9-summary-page.sh 8
     - name: Generating summary...
       run: .github/workflows/scripts/qemu-9-summary-page.sh 9
     - name: Generating summary...
       run: .github/workflows/scripts/qemu-9-summary-page.sh 10
     - name: Generating summary...
       run: .github/workflows/scripts/qemu-9-summary-page.sh 11
     - name: Generating summary...
       run: .github/workflows/scripts/qemu-9-summary-page.sh 12
     - name: Generating summary...
       run: .github/workflows/scripts/qemu-9-summary-page.sh 13
     - name: Generating summary...
       run: .github/workflows/scripts/qemu-9-summary-page.sh 14
     - name: Generating summary...
       run: .github/workflows/scripts/qemu-9-summary-page.sh 15
     - name: Generating summary...
       run: .github/workflows/scripts/qemu-9-summary-page.sh 16
     - name: Generating summary...
       run: .github/workflows/scripts/qemu-9-summary-page.sh 17
     - name: Generating summary...
       run: .github/workflows/scripts/qemu-9-summary-page.sh 18
     - name: Generating summary...
       run: .github/workflows/scripts/qemu-9-summary-page.sh 19
     - uses: actions/upload-artifact@v4
       with:
         name: Summary Files
         path: out-*
diff --git a/sys/contrib/openzfs/META b/sys/contrib/openzfs/META
index c2eff4ba0bbd..185cca4a44d4 100644
--- a/sys/contrib/openzfs/META
+++ b/sys/contrib/openzfs/META
@@ -1,10 +1,10 @@
 Meta:          1
 Name:          zfs
 Branch:        1.0
-Version:       2.3.0
-Release:       rc1
+Version:       2.3.99
+Release:       1
 Release-Tags:  relext
 License:       CDDL
 Author:        OpenZFS
 Linux-Maximum: 6.11
 Linux-Minimum: 4.18
diff --git a/sys/contrib/openzfs/cmd/zdb/zdb.c b/sys/contrib/openzfs/cmd/zdb/zdb.c
index a72b80a93732..2121f70b2b9a 100644
--- a/sys/contrib/openzfs/cmd/zdb/zdb.c
+++ b/sys/contrib/openzfs/cmd/zdb/zdb.c
@@ -1,9825 +1,9829 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 
 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * 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
  * Copyright (c) 2021 Toomas Soome <tsoome@me.com>
  * Copyright (c) 2023, 2024, Klara Inc.
  * Copyright (c) 2023, Rob Norris <robn@despairlabs.com>
  */
 
 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <ctype.h>
 #include <getopt.h>
 #include <openssl/evp.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/zap_impl.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/ddt_impl.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 <sys/brt.h>
 #include <sys/brt_impl.h>
 #include <zfs_comutil.h>
 #include <sys/zstd/zstd.h>
 #include <sys/backtrace.h>
 
 #include <libnvpair.h>
 #include <libzutil.h>
 #include <libzfs_core.h>
 
 #include <libzdb.h>
 
 #include "zdb.h"
 
 
 extern int reference_tracking_enable;
 extern int zfs_recover;
 extern uint_t zfs_vdev_async_read_max_active;
 extern boolean_t spa_load_verify_dryrun;
 extern boolean_t spa_mode_readable_spacemaps;
 extern uint_t zfs_reconstruct_indirect_combinations_max;
 extern uint_t 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);
 
 static uint64_t *zopt_metaslab = NULL;
 static unsigned zopt_metaslab_args = 0;
 
 
 static zopt_object_range_t *zopt_object_ranges = NULL;
 static unsigned zopt_object_args = 0;
 
 static int flagbits[256];
 
 
 static uint64_t max_inflight_bytes = 256 * 1024 * 1024; /* 256MB */
 static int leaked_objects = 0;
 static range_tree_t *mos_refd_objs;
 static spa_t *spa;
 static objset_t *os;
 static boolean_t kernel_init_done;
 
 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);
 
 
 
 static void zdb_print_blkptr(const blkptr_t *bp, int flags);
 static void zdb_exit(int reason);
 
 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_GET_LOGICAL_BIRTH(bp)
 				};
 
 				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, NULL,
 	    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
  */
 static int
 sublivelist_verify_lightweight(void *args, dsl_deadlist_entry_t *dle)
 {
 	(void) args;
 	sublivelist_verify_t sv;
 	zfs_btree_create(&sv.sv_leftover, livelist_block_compare, NULL,
 	    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 = {{{0}}};
 	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, NULL,
 	    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, NULL,
 			    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[-K <key>]\n"
 	    "\t\t[<poolname>[/<dataset | objset id>] [<object | range> ...]]\n"
 	    "\t%s [-AdiPv] [-e [-V] [-p <path> ...]] [-U <cache>] [-K <key>]\n"
 	    "\t\t[<poolname>[/<dataset | objset id>] [<object | range> ...]\n"
 	    "\t%s -B [-e [-V] [-p <path> ...]] [-I <inflight I/Os>]\n"
 	    "\t\t[-o <var>=<value>]... [-t <txg>] [-U <cache>] [-x <dumpdir>]\n"
 	    "\t\t[-K <key>] <poolname>/<objset id> [<backupflags>]\n"
 	    "\t%s [-v] <bookmark>\n"
 	    "\t%s -C [-A] [-U <cache>] [<poolname>]\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 [-K <key>] <dataset> <path>\n"
 	    "\t%s -r [-K <key>] <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, 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-stats             "
 	    "block statistics\n");
 	(void) fprintf(stderr, "        -B --backup                  "
 	    "backup stream\n");
 	(void) fprintf(stderr, "        -c --checksum                "
 	    "checksum all metadata (twice for all data) blocks\n");
 	(void) fprintf(stderr, "        -C --config                  "
 	    "config (or cachefile if alone)\n");
 	(void) fprintf(stderr, "        -d --datasets                "
 	    "dataset(s)\n");
 	(void) fprintf(stderr, "        -D --dedup-stats             "
 	    "dedup statistics\n");
 	(void) fprintf(stderr, "        -E --embedded-block-pointer=INTEGER\n"
 	    "                                     decode and display block "
 	    "from an embedded block pointer\n");
 	(void) fprintf(stderr, "        -h --history                 "
 	    "pool history\n");
 	(void) fprintf(stderr, "        -i --intent-logs             "
 	    "intent logs\n");
 	(void) fprintf(stderr, "        -l --label                   "
 	    "read label contents\n");
 	(void) fprintf(stderr, "        -k --checkpointed-state      "
 	    "examine the checkpointed state of the pool\n");
 	(void) fprintf(stderr, "        -L --disable-leak-tracking   "
 	    "disable leak tracking (do not load spacemaps)\n");
 	(void) fprintf(stderr, "        -m --metaslabs               "
 	    "metaslabs\n");
 	(void) fprintf(stderr, "        -M --metaslab-groups         "
 	    "metaslab groups\n");
 	(void) fprintf(stderr, "        -O --object-lookups          "
 	    "perform object lookups by path\n");
 	(void) fprintf(stderr, "        -r --copy-object             "
 	    "copy an object by path to file\n");
 	(void) fprintf(stderr, "        -R --read-block              "
 	    "read and display block from a device\n");
 	(void) fprintf(stderr, "        -s --io-stats                "
 	    "report stats on zdb's I/O\n");
 	(void) fprintf(stderr, "        -S --simulate-dedup          "
 	    "simulate dedup to measure effect\n");
 	(void) fprintf(stderr, "        -v --verbose                 "
 	    "verbose (applies to all others)\n");
 	(void) fprintf(stderr, "        -y --livelist                "
 	    "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       "
 	    "ignore assertions (-A), enable panic recovery (-AA) or both "
 	    "(-AAA)\n");
 	(void) fprintf(stderr, "        -e --exported                "
 	    "pool is exported/destroyed/has altroot/not in a cachefile\n");
 	(void) fprintf(stderr, "        -F --automatic-rewind        "
 	    "attempt automatic rewind within safe range of transaction "
 	    "groups\n");
 	(void) fprintf(stderr, "        -G --dump-debug-msg          "
 	    "dump zfs_dbgmsg buffer before exiting\n");
 	(void) fprintf(stderr, "        -I --inflight=INTEGER        "
 	    "specify the maximum number of checksumming I/Os "
 	    "[default is 200]\n");
 	(void) fprintf(stderr, "        -K --key=KEY                 "
 	    "decryption key for encrypted dataset\n");
 	(void) fprintf(stderr, "        -o --option=\"OPTION=INTEGER\" "
 	    "set global variable to an unsigned 32-bit integer\n");
 	(void) fprintf(stderr, "        -p --path==PATH              "
 	    "use one or more with -e to specify path to vdev dir\n");
 	(void) fprintf(stderr, "        -P --parseable               "
 	    "print numbers in parseable form\n");
 	(void) fprintf(stderr, "        -q --skip-label              "
 	    "don't print label contents\n");
 	(void) fprintf(stderr, "        -t --txg=INTEGER             "
 	    "highest txg to use when searching for uberblocks\n");
 	(void) fprintf(stderr, "        -T --brt-stats               "
 	    "BRT statistics\n");
 	(void) fprintf(stderr, "        -u --uberblock               "
 	    "uberblock\n");
 	(void) fprintf(stderr, "        -U --cachefile=PATH          "
 	    "use alternate cachefile\n");
 	(void) fprintf(stderr, "        -V --verbatim                "
 	    "do verbatim import\n");
 	(void) fprintf(stderr, "        -x --dump-blocks=PATH        "
 	    "dump all read blocks into specified directory\n");
 	(void) fprintf(stderr, "        -X --extreme-rewind          "
 	    "attempt extreme rewind (does not work with dataset)\n");
 	(void) fprintf(stderr, "        -Y --all-reconstruction      "
 	    "attempt all reconstruction combinations for split blocks\n");
 	(void) fprintf(stderr, "        -Z --zstd-headers            "
 	    "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");
 	zdb_exit(1);
 }
 
 static void
 dump_debug_buffer(void)
 {
 	ssize_t ret __attribute__((unused));
 
 	if (!dump_opt['G'])
 		return;
 	/*
 	 * We use write() instead of printf() so that this function
 	 * is safe to call from a signal handler.
 	 */
 	ret = write(STDERR_FILENO, "\n", 1);
 	zfs_dbgmsg_print(STDERR_FILENO, "zdb");
 }
 
 static void sig_handler(int signo)
 {
 	struct sigaction action;
 
 	libspl_backtrace(STDERR_FILENO);
 	dump_debug_buffer();
 
 	/*
 	 * Restore default action and re-raise signal so SIGSEGV and
 	 * SIGABRT can trigger a core dump.
 	 */
 	action.sa_handler = SIG_DFL;
 	sigemptyset(&action.sa_mask);
 	action.sa_flags = 0;
 	(void) sigaction(signo, &action, NULL);
 	raise(signo);
 }
 
 /*
  * 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();
 
 	zdb_exit(1);
 }
 
 static void
 dump_packed_nvlist(objset_t *os, uint64_t object, void *data, size_t size)
 {
 	(void) 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);
 }
 
 static void
 dump_history_offsets(objset_t *os, uint64_t object, void *data, size_t size)
 {
 	(void) os, (void) object, (void) 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, buflen);
 }
 
 static void
 zdb_nicebytes(uint64_t bytes, char *buf, size_t buflen)
 {
 	if (dump_opt['P'])
 		(void) snprintf(buf, buflen, "%llu", (longlong_t)bytes);
 	else
 		zfs_nicebytes(bytes, buf, buflen);
 }
 
 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] == 0)
 			continue;
 		if (histo[i] > max)
 			max = histo[i];
 		if (i > maxidx)
 			maxidx = i;
 		if (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);
 }
 
 static void
 dump_none(objset_t *os, uint64_t object, void *data, size_t size)
 {
 	(void) os, (void) object, (void) data, (void) size;
 }
 
 static void
 dump_unknown(objset_t *os, uint64_t object, void *data, size_t size)
 {
 	(void) os, (void) object, (void) data, (void) size;
 	(void) printf("\tUNKNOWN OBJECT TYPE\n");
 }
 
 static void
 dump_uint8(objset_t *os, uint64_t object, void *data, size_t size)
 {
 	(void) os, (void) object, (void) data, (void) size;
 }
 
 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) {
 		if (data == NULL)
 			kmem_free(arr, oursize);
 		(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);
 }
 
 static void
 dump_zap(objset_t *os, uint64_t object, void *data, size_t size)
 {
 	(void) data, (void) size;
 	zap_cursor_t zc;
 	zap_attribute_t *attrp = zap_attribute_long_alloc();
 	void *prop;
 	unsigned i;
 
 	dump_zap_stats(os, object);
 	(void) printf("\n");
 
 	for (zap_cursor_init(&zc, os, object);
 	    zap_cursor_retrieve(&zc, attrp) == 0;
 	    zap_cursor_advance(&zc)) {
 		boolean_t key64 =
 		    !!(zap_getflags(zc.zc_zap) & ZAP_FLAG_UINT64_KEY);
 
 		if (key64)
 			(void) printf("\t\t0x%010" PRIu64 "x = ",
 			    *(uint64_t *)attrp->za_name);
 		else
 			(void) printf("\t\t%s = ", attrp->za_name);
 
 		if (attrp->za_num_integers == 0) {
 			(void) printf("\n");
 			continue;
 		}
 		prop = umem_zalloc(attrp->za_num_integers *
 		    attrp->za_integer_length, UMEM_NOFAIL);
 
 		if (key64)
 			(void) zap_lookup_uint64(os, object,
 			    (const uint64_t *)attrp->za_name, 1,
 			    attrp->za_integer_length, attrp->za_num_integers,
 			    prop);
 		else
 			(void) zap_lookup(os, object, attrp->za_name,
 			    attrp->za_integer_length, attrp->za_num_integers,
 			    prop);
 
 		if (attrp->za_integer_length == 1 && !key64) {
 			if (strcmp(attrp->za_name,
 			    DSL_CRYPTO_KEY_MASTER_KEY) == 0 ||
 			    strcmp(attrp->za_name,
 			    DSL_CRYPTO_KEY_HMAC_KEY) == 0 ||
 			    strcmp(attrp->za_name, DSL_CRYPTO_KEY_IV) == 0 ||
 			    strcmp(attrp->za_name, DSL_CRYPTO_KEY_MAC) == 0 ||
 			    strcmp(attrp->za_name,
 			    DMU_POOL_CHECKSUM_SALT) == 0) {
 				uint8_t *u8 = prop;
 
 				for (i = 0; i < attrp->za_num_integers; i++) {
 					(void) printf("%02x", u8[i]);
 				}
 			} else {
 				(void) printf("%s", (char *)prop);
 			}
 		} else {
 			for (i = 0; i < attrp->za_num_integers; i++) {
 				switch (attrp->za_integer_length) {
 				case 1:
 					(void) printf("%u ",
 					    ((uint8_t *)prop)[i]);
 					break;
 				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,
 		    attrp->za_num_integers * attrp->za_integer_length);
 	}
 	zap_cursor_fini(&zc);
 	zap_attribute_free(attrp);
 }
 
 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 */
 	_Static_assert(sizeof (bytes) >= NN_NUMBUF_SZ, "bytes truncated");
 	_Static_assert(sizeof (comp) >= NN_NUMBUF_SZ, "comp truncated");
 	_Static_assert(sizeof (uncomp) >= NN_NUMBUF_SZ, "uncomp truncated");
 
 	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);
 	}
 }
 
 static void
 dump_bpobj_subobjs(objset_t *os, uint64_t object, void *data, size_t size)
 {
 	(void) data, (void) 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);
 }
 
 static void
 dump_ddt_zap(objset_t *os, uint64_t object, void *data, size_t size)
 {
 	(void) data, (void) size;
 	dump_zap_stats(os, object);
 	/* contents are printed elsewhere, properly decoded */
 }
 
 static void
 dump_sa_attrs(objset_t *os, uint64_t object, void *data, size_t size)
 {
 	(void) data, (void) size;
 	zap_cursor_t zc;
 	zap_attribute_t *attrp = zap_attribute_alloc();
 
 	dump_zap_stats(os, object);
 	(void) printf("\n");
 
 	for (zap_cursor_init(&zc, os, object);
 	    zap_cursor_retrieve(&zc, attrp) == 0;
 	    zap_cursor_advance(&zc)) {
 		(void) printf("\t\t%s = ", attrp->za_name);
 		if (attrp->za_num_integers == 0) {
 			(void) printf("\n");
 			continue;
 		}
 		(void) printf(" %llx : [%d:%d:%d]\n",
 		    (u_longlong_t)attrp->za_first_integer,
 		    (int)ATTR_LENGTH(attrp->za_first_integer),
 		    (int)ATTR_BSWAP(attrp->za_first_integer),
 		    (int)ATTR_NUM(attrp->za_first_integer));
 	}
 	zap_cursor_fini(&zc);
 	zap_attribute_free(attrp);
 }
 
 static void
 dump_sa_layouts(objset_t *os, uint64_t object, void *data, size_t size)
 {
 	(void) data, (void) size;
 	zap_cursor_t zc;
 	zap_attribute_t *attrp = zap_attribute_alloc();
 	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, attrp) == 0;
 	    zap_cursor_advance(&zc)) {
 		(void) printf("\t\t%s = [", attrp->za_name);
 		if (attrp->za_num_integers == 0) {
 			(void) printf("\n");
 			continue;
 		}
 
 		VERIFY(attrp->za_integer_length == 2);
 		layout_attrs = umem_zalloc(attrp->za_num_integers *
 		    attrp->za_integer_length, UMEM_NOFAIL);
 
 		VERIFY(zap_lookup(os, object, attrp->za_name,
 		    attrp->za_integer_length,
 		    attrp->za_num_integers, layout_attrs) == 0);
 
 		for (i = 0; i != attrp->za_num_integers; i++)
 			(void) printf(" %d ", (int)layout_attrs[i]);
 		(void) printf("]\n");
 		umem_free(layout_attrs,
 		    attrp->za_num_integers * attrp->za_integer_length);
 	}
 	zap_cursor_fini(&zc);
 	zap_attribute_free(attrp);
 }
 
 static void
 dump_zpldir(objset_t *os, uint64_t object, void *data, size_t size)
 {
 	(void) data, (void) size;
 	zap_cursor_t zc;
 	zap_attribute_t *attrp = zap_attribute_long_alloc();
 	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, attrp) == 0;
 	    zap_cursor_advance(&zc)) {
 		(void) printf("\t\t%s = %lld (type: %s)\n",
 		    attrp->za_name, ZFS_DIRENT_OBJ(attrp->za_first_integer),
 		    typenames[ZFS_DIRENT_TYPE(attrp->za_first_integer)]);
 	}
 	zap_cursor_fini(&zc);
 	zap_attribute_free(attrp);
 }
 
 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 */
 	_Static_assert(sizeof (maxbuf) >= NN_NUMBUF_SZ, "maxbuf truncated");
 
 	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, boolean_t show_special)
 {
 	vdev_t *rvd = spa->spa_root_vdev;
 	metaslab_class_t *mc = spa_normal_class(spa);
 	metaslab_class_t *smc = spa_special_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 &&
 		    (!show_special || mg->mg_class != smc)))
 			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_ddt_entry(const ddt_t *ddt, const ddt_lightweight_entry_t *ddlwe,
     uint64_t index)
 {
 	const ddt_key_t *ddk = &ddlwe->ddlwe_key;
 	char blkbuf[BP_SPRINTF_LEN];
 	blkptr_t blk;
 	int p;
 
 	for (p = 0; p < DDT_NPHYS(ddt); p++) {
 		const ddt_univ_phys_t *ddp = &ddlwe->ddlwe_phys;
 		ddt_phys_variant_t v = DDT_PHYS_VARIANT(ddt, p);
 
 		if (ddt_phys_birth(ddp, v) == 0)
 			continue;
 		ddt_bp_create(ddt->ddt_checksum, ddk, ddp, v, &blk);
 		snprintf_blkptr(blkbuf, sizeof (blkbuf), &blk);
 		(void) printf("index %llx refcnt %llu phys %d %s\n",
 		    (u_longlong_t)index, (u_longlong_t)ddt_phys_refcnt(ddp, v),
 		    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_log(ddt_t *ddt)
 {
 	for (int n = 0; n < 2; n++) {
 		ddt_log_t *ddl = &ddt->ddt_log[n];
 
 		uint64_t count = avl_numnodes(&ddl->ddl_tree);
 		if (count == 0)
 			continue;
 
 		printf(DMU_POOL_DDT_LOG ": %" PRIu64 " log entries\n",
 		    zio_checksum_table[ddt->ddt_checksum].ci_name, n, count);
 
 		if (dump_opt['D'] < 4)
 			continue;
 
 		ddt_lightweight_entry_t ddlwe;
 		uint64_t index = 0;
 		for (ddt_log_entry_t *ddle = avl_first(&ddl->ddl_tree);
 		    ddle; ddle = AVL_NEXT(&ddl->ddl_tree, ddle)) {
 			DDT_LOG_ENTRY_TO_LIGHTWEIGHT(ddt, ddle, &ddlwe);
 			dump_ddt_entry(ddt, &ddlwe, index++);
 		}
 	}
 }
 
 static void
 dump_ddt(ddt_t *ddt, ddt_type_t type, ddt_class_t class)
 {
 	char name[DDT_NAMELEN];
 	ddt_lightweight_entry_t ddlwe;
 	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,
 	    (u_longlong_t)mspace);
 
 	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, &ddlwe)) == 0)
 		dump_ddt_entry(ddt, &ddlwe, walk);
 
 	ASSERT3U(error, ==, ENOENT);
 
 	(void) printf("\n");
 }
 
 static void
 dump_all_ddts(spa_t *spa)
 {
 	ddt_histogram_t ddh_total = {{{0}}};
 	ddt_stat_t dds_total = {0};
 
 	for (enum zio_checksum c = 0; c < ZIO_CHECKSUM_FUNCTIONS; c++) {
 		ddt_t *ddt = spa->spa_ddt[c];
 		if (!ddt || ddt->ddt_version == DDT_VERSION_UNCONFIGURED)
 			continue;
 		for (ddt_type_t type = 0; type < DDT_TYPES; type++) {
 			for (ddt_class_t class = 0; class < DDT_CLASSES;
 			    class++) {
 				dump_ddt(ddt, type, class);
 			}
 		}
 		dump_ddt_log(ddt);
 	}
 
 	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);
 
 	/*
 	 * Dump a histogram of unique class entry age
 	 */
 	if (dump_opt['D'] == 3 && getenv("ZDB_DDT_UNIQUE_AGE_HIST") != NULL) {
 		ddt_age_histo_t histogram;
 
 		(void) printf("DDT walk unique, building age histogram...\n");
 		ddt_prune_walk(spa, 0, &histogram);
 
 		/*
 		 * print out histogram for unique entry class birth
 		 */
 		if (histogram.dah_entries > 0) {
 			(void) printf("%5s  %9s  %4s\n",
 			    "age", "blocks", "amnt");
 			(void) printf("%5s  %9s  %4s\n",
 			    "-----", "---------", "----");
 			for (int i = 0; i < HIST_BINS; i++) {
 				(void) printf("%5d  %9d %4d%%\n", 1 << i,
 				    (int)histogram.dah_age_histo[i],
 				    (int)((histogram.dah_age_histo[i] * 100) /
 				    histogram.dah_entries));
 			}
 		}
 	}
 }
 
 static void
 dump_brt(spa_t *spa)
 {
 	if (!spa_feature_is_enabled(spa, SPA_FEATURE_BLOCK_CLONING)) {
 		printf("BRT: unsupported on this pool\n");
 		return;
 	}
 
 	if (!spa_feature_is_active(spa, SPA_FEATURE_BLOCK_CLONING)) {
 		printf("BRT: empty\n");
 		return;
 	}
 
 	brt_t *brt = spa->spa_brt;
 	VERIFY(brt);
 
 	char count[32], used[32], saved[32];
 	zdb_nicebytes(brt_get_used(spa), used, sizeof (used));
 	zdb_nicebytes(brt_get_saved(spa), saved, sizeof (saved));
 	uint64_t ratio = brt_get_ratio(spa);
 	printf("BRT: used %s; saved %s; ratio %llu.%02llux\n", used, saved,
 	    (u_longlong_t)(ratio / 100), (u_longlong_t)(ratio % 100));
 
 	if (dump_opt['T'] < 2)
 		return;
 
 	for (uint64_t vdevid = 0; vdevid < brt->brt_nvdevs; vdevid++) {
 		brt_vdev_t *brtvd = &brt->brt_vdevs[vdevid];
 		if (brtvd == NULL)
 			continue;
 
 		if (!brtvd->bv_initiated) {
 			printf("BRT: vdev %" PRIu64 ": empty\n", vdevid);
 			continue;
 		}
 
 		zdb_nicenum(brtvd->bv_totalcount, count, sizeof (count));
 		zdb_nicebytes(brtvd->bv_usedspace, used, sizeof (used));
 		zdb_nicebytes(brtvd->bv_savedspace, saved, sizeof (saved));
 		printf("BRT: vdev %" PRIu64 ": refcnt %s; used %s; saved %s\n",
 		    vdevid, count, used, saved);
 	}
 
 	if (dump_opt['T'] < 3)
 		return;
 
 	char dva[64];
 	printf("\n%-16s %-10s\n", "DVA", "REFCNT");
 
 	for (uint64_t vdevid = 0; vdevid < brt->brt_nvdevs; vdevid++) {
 		brt_vdev_t *brtvd = &brt->brt_vdevs[vdevid];
 		if (brtvd == NULL || !brtvd->bv_initiated)
 			continue;
 
 		zap_cursor_t zc;
 		zap_attribute_t *za = zap_attribute_alloc();
 		for (zap_cursor_init(&zc, brt->brt_mos, brtvd->bv_mos_entries);
 		    zap_cursor_retrieve(&zc, za) == 0;
 		    zap_cursor_advance(&zc)) {
 			uint64_t refcnt;
 			VERIFY0(zap_lookup_uint64(brt->brt_mos,
 			    brtvd->bv_mos_entries,
 			    (const uint64_t *)za->za_name, 1,
 			    za->za_integer_length, za->za_num_integers,
 			    &refcnt));
 
 			uint64_t offset = *(const uint64_t *)za->za_name;
 
 			snprintf(dva, sizeof (dva), "%" PRIu64 ":%llx", vdevid,
 			    (u_longlong_t)offset);
 			printf("%-16s %-10llu\n", dva, (u_longlong_t)refcnt);
 		}
 		zap_cursor_fini(&zc);
 		zap_attribute_free(za);
 	}
 }
 
 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;
 	char tbuf[30];
 
 	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++) {
 		boolean_t printed = B_FALSE;
 
 		if (nvlist_exists(events[i], ZPOOL_HIST_TIME)) {
 			time_t tsec;
 			struct tm t;
 
 			tsec = fnvlist_lookup_uint64(events[i],
 			    ZPOOL_HIST_TIME);
 			(void) localtime_r(&tsec, &t);
 			(void) strftime(tbuf, sizeof (tbuf), "%F.%T", &t);
 		} else {
 			tbuf[0] = '\0';
 		}
 
 		if (nvlist_exists(events[i], ZPOOL_HIST_CMD)) {
 			(void) printf("%s %s\n", tbuf,
 			    fnvlist_lookup_string(events[i], ZPOOL_HIST_CMD));
 		} else if (nvlist_exists(events[i], ZPOOL_HIST_INT_EVENT)) {
 			uint64_t ievent;
 
 			ievent = fnvlist_lookup_uint64(events[i],
 			    ZPOOL_HIST_INT_EVENT);
 			if (ievent >= ZFS_NUM_LEGACY_HISTORY_EVENTS)
 				goto next;
 
 			(void) printf(" %s [internal %s txg:%ju] %s\n",
 			    tbuf,
 			    zfs_history_event_names[ievent],
 			    fnvlist_lookup_uint64(events[i],
 			    ZPOOL_HIST_TXG),
 			    fnvlist_lookup_string(events[i],
 			    ZPOOL_HIST_INT_STR));
 		} else if (nvlist_exists(events[i], ZPOOL_HIST_INT_NAME)) {
 			(void) printf("%s [txg:%ju] %s", tbuf,
 			    fnvlist_lookup_uint64(events[i],
 			    ZPOOL_HIST_TXG),
 			    fnvlist_lookup_string(events[i],
 			    ZPOOL_HIST_INT_NAME));
 
 			if (nvlist_exists(events[i], ZPOOL_HIST_DSNAME)) {
 				(void) printf(" %s (%llu)",
 				    fnvlist_lookup_string(events[i],
 				    ZPOOL_HIST_DSNAME),
 				    (u_longlong_t)fnvlist_lookup_uint64(
 				    events[i],
 				    ZPOOL_HIST_DSID));
 			}
 
 			(void) printf(" %s\n", fnvlist_lookup_string(events[i],
 			    ZPOOL_HIST_INT_STR));
 		} else if (nvlist_exists(events[i], ZPOOL_HIST_IOCTL)) {
 			(void) printf("%s ioctl %s\n", tbuf,
 			    fnvlist_lookup_string(events[i],
 			    ZPOOL_HIST_IOCTL));
 
 			if (nvlist_exists(events[i], ZPOOL_HIST_INPUT_NVL)) {
 				(void) printf("    input:\n");
 				dump_nvlist(fnvlist_lookup_nvlist(events[i],
 				    ZPOOL_HIST_INPUT_NVL), 8);
 			}
 			if (nvlist_exists(events[i], ZPOOL_HIST_OUTPUT_NVL)) {
 				(void) printf("    output:\n");
 				dump_nvlist(fnvlist_lookup_nvlist(events[i],
 				    ZPOOL_HIST_OUTPUT_NVL), 8);
 			}
 			if (nvlist_exists(events[i], ZPOOL_HIST_ERRNO)) {
 				(void) printf("    errno: %lld\n",
 				    (longlong_t)fnvlist_lookup_int64(events[i],
 				    ZPOOL_HIST_ERRNO));
 			}
 		} else {
 			goto next;
 		}
 
 		printed = B_TRUE;
 next:
 		if (dump_opt['h'] > 1) {
 			if (!printed)
 				(void) printf("unrecognized record:\n");
 			dump_nvlist(events[i], 2);
 		}
 	}
 	free(buf);
 }
 
 static void
 dump_dnode(objset_t *os, uint64_t object, void *data, size_t size)
 {
 	(void) os, (void) object, (void) data, (void) 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)
 {
 	static abd_t *pabd = NULL;
 	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");
 			zdb_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;
 	}
 
 	if (!pabd)
 		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_GET_LOGICAL_BIRTH(bp));
 		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_GET_LOGICAL_BIRTH(bp));
 	} 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_GET_LOGICAL_BIRTH(bp),
 		    (u_longlong_t)BP_GET_BIRTH(bp));
 		if (bp_freed)
 			(void) snprintf(blkbuf + strlen(blkbuf),
 			    buflen - strlen(blkbuf), " %s", "FREE");
 		(void) snprintf(blkbuf + strlen(blkbuf),
 		    buflen - strlen(blkbuf),
 		    " cksum=%016llx:%016llx:%016llx:%016llx",
 		    (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_GET_LOGICAL_BIRTH(bp) == 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);
 }
 
 static void
 dump_indirect(dnode_t *dn)
 {
 	dnode_phys_t *dnp = dn->dn_phys;
 	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 (int 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");
 }
 
 static void
 dump_dsl_dir(objset_t *os, uint64_t object, void *data, size_t size)
 {
 	(void) os, (void) object;
 	dsl_dir_phys_t *dd = data;
 	time_t crtime;
 	char nice[32];
 
 	/* make sure nicenum has enough space */
 	_Static_assert(sizeof (nice) >= NN_NUMBUF_SZ, "nice truncated");
 
 	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);
 }
 
 static void
 dump_dsl_dataset(objset_t *os, uint64_t object, void *data, size_t size)
 {
 	(void) os, (void) object;
 	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 */
 	_Static_assert(sizeof (used) >= NN_NUMBUF_SZ, "used truncated");
 	_Static_assert(sizeof (compressed) >= NN_NUMBUF_SZ,
 	    "compressed truncated");
 	_Static_assert(sizeof (uncompressed) >= NN_NUMBUF_SZ,
 	    "uncompressed truncated");
 	_Static_assert(sizeof (unique) >= NN_NUMBUF_SZ, "unique truncated");
 
 	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);
 }
 
 static int
 dump_bptree_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
 {
 	(void) arg, (void) tx;
 	char blkbuf[BP_SPRINTF_LEN];
 
 	if (BP_GET_LOGICAL_BIRTH(bp) != 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 */
 	_Static_assert(sizeof (bytes) >= NN_NUMBUF_SZ, "bytes truncated");
 
 	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);
 }
 
 static int
 dump_bpobj_cb(void *arg, const blkptr_t *bp, boolean_t bp_freed, dmu_tx_t *tx)
 {
 	(void) arg, (void) tx;
 	char blkbuf[BP_SPRINTF_LEN];
 
 	ASSERT(BP_GET_LOGICAL_BIRTH(bp) != 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 */
 	_Static_assert(sizeof (bytes) >= NN_NUMBUF_SZ, "bytes truncated");
 	_Static_assert(sizeof (comp) >= NN_NUMBUF_SZ, "comp truncated");
 	_Static_assert(sizeof (uncomp) >= NN_NUMBUF_SZ, "uncomp truncated");
 
 	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 *attrp;
 	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;
 	attrp = zap_attribute_alloc();
 	dsl_pool_config_enter(dp, FTAG);
 
 	for (zap_cursor_init(&zc, mos, ds->ds_bookmarks_obj);
 	    zap_cursor_retrieve(&zc, attrp) == 0;
 	    zap_cursor_advance(&zc)) {
 		char osname[ZFS_MAX_DATASET_NAME_LEN];
 		char buf[ZFS_MAX_DATASET_NAME_LEN];
 		int len;
 		dmu_objset_name(os, osname);
 		len = snprintf(buf, sizeof (buf), "%s#%s", osname,
 		    attrp->za_name);
 		VERIFY3S(len, <, ZFS_MAX_DATASET_NAME_LEN);
 		(void) dump_bookmark(dp, buf, verbosity >= 5, verbosity >= 6);
 	}
 	zap_cursor_fini(&zc);
 	dsl_pool_config_exit(dp, FTAG);
 	zap_attribute_free(attrp);
 }
 
 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, const 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 */
 	_Static_assert(sizeof (bytes) >= NN_NUMBUF_SZ, "bytes truncated");
 	_Static_assert(sizeof (comp) >= NN_NUMBUF_SZ, "comp truncated");
 	_Static_assert(sizeof (uncomp) >= NN_NUMBUF_SZ, "uncomp truncated");
 	_Static_assert(sizeof (entries) >= NN_NUMBUF_SZ, "entries truncated");
 
 	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) putchar('\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 char *key_material = NULL;
 
 static boolean_t
 zdb_derive_key(dsl_dir_t *dd, uint8_t *key_out)
 {
 	uint64_t keyformat, salt, iters;
 	int i;
 	unsigned char c;
 
 	VERIFY0(zap_lookup(dd->dd_pool->dp_meta_objset, dd->dd_crypto_obj,
 	    zfs_prop_to_name(ZFS_PROP_KEYFORMAT), sizeof (uint64_t),
 	    1, &keyformat));
 
 	switch (keyformat) {
 	case ZFS_KEYFORMAT_HEX:
 		for (i = 0; i < WRAPPING_KEY_LEN * 2; i += 2) {
 			if (!isxdigit(key_material[i]) ||
 			    !isxdigit(key_material[i+1]))
 				return (B_FALSE);
 			if (sscanf(&key_material[i], "%02hhx", &c) != 1)
 				return (B_FALSE);
 			key_out[i / 2] = c;
 		}
 		break;
 
 	case ZFS_KEYFORMAT_PASSPHRASE:
 		VERIFY0(zap_lookup(dd->dd_pool->dp_meta_objset,
 		    dd->dd_crypto_obj, zfs_prop_to_name(ZFS_PROP_PBKDF2_SALT),
 		    sizeof (uint64_t), 1, &salt));
 		VERIFY0(zap_lookup(dd->dd_pool->dp_meta_objset,
 		    dd->dd_crypto_obj, zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS),
 		    sizeof (uint64_t), 1, &iters));
 
 		if (PKCS5_PBKDF2_HMAC_SHA1(key_material, strlen(key_material),
 		    ((uint8_t *)&salt), sizeof (uint64_t), iters,
 		    WRAPPING_KEY_LEN, key_out) != 1)
 			return (B_FALSE);
 
 		break;
 
 	default:
 		fatal("no support for key format %u\n",
 		    (unsigned int) keyformat);
 	}
 
 	return (B_TRUE);
 }
 
 static char encroot[ZFS_MAX_DATASET_NAME_LEN];
 static boolean_t key_loaded = B_FALSE;
 
 static void
 zdb_load_key(objset_t *os)
 {
 	dsl_pool_t *dp;
 	dsl_dir_t *dd, *rdd;
 	uint8_t key[WRAPPING_KEY_LEN];
 	uint64_t rddobj;
 	int err;
 
 	dp = spa_get_dsl(os->os_spa);
 	dd = os->os_dsl_dataset->ds_dir;
 
 	dsl_pool_config_enter(dp, FTAG);
 	VERIFY0(zap_lookup(dd->dd_pool->dp_meta_objset, dd->dd_crypto_obj,
 	    DSL_CRYPTO_KEY_ROOT_DDOBJ, sizeof (uint64_t), 1, &rddobj));
 	VERIFY0(dsl_dir_hold_obj(dd->dd_pool, rddobj, NULL, FTAG, &rdd));
 	dsl_dir_name(rdd, encroot);
 	dsl_dir_rele(rdd, FTAG);
 
 	if (!zdb_derive_key(dd, key))
 		fatal("couldn't derive encryption key");
 
 	dsl_pool_config_exit(dp, FTAG);
 
 	ASSERT3U(dsl_dataset_get_keystatus(dd), ==, ZFS_KEYSTATUS_UNAVAILABLE);
 
 	dsl_crypto_params_t *dcp;
 	nvlist_t *crypto_args;
 
 	crypto_args = fnvlist_alloc();
 	fnvlist_add_uint8_array(crypto_args, "wkeydata",
 	    (uint8_t *)key, WRAPPING_KEY_LEN);
 	VERIFY0(dsl_crypto_params_create_nvlist(DCP_CMD_NONE,
 	    NULL, crypto_args, &dcp));
 	err = spa_keystore_load_wkey(encroot, dcp, B_FALSE);
 
 	dsl_crypto_params_free(dcp, (err != 0));
 	fnvlist_free(crypto_args);
 
 	if (err != 0)
 		fatal(
 		    "couldn't load encryption key for %s: %s",
 		    encroot, err == ZFS_ERR_CRYPTO_NOTSUP ?
 		    "crypto params not supported" : strerror(err));
 
 	ASSERT3U(dsl_dataset_get_keystatus(dd), ==, ZFS_KEYSTATUS_AVAILABLE);
 
 	printf("Unlocked encryption root: %s\n", encroot);
 	key_loaded = B_TRUE;
 }
 
 static void
 zdb_unload_key(void)
 {
 	if (!key_loaded)
 		return;
 
 	VERIFY0(spa_keystore_unload_wkey(encroot));
 	key_loaded = B_FALSE;
 }
 
 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, const 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).
 	 */
 
 	if (dump_opt['K']) {
 		/* decryption requested, try to load keys */
 		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);
 
 		/* succeeds or dies */
 		zdb_load_key(*osp);
 
 		/* release it all */
 		dsl_dataset_long_rele(dmu_objset_ds(*osp), tag);
 		dsl_dataset_rele(dmu_objset_ds(*osp), tag);
 	}
 
 	int ds_hold_flags = key_loaded ? DS_HOLD_FLAG_DECRYPT : 0;
 
 	err = dmu_objset_hold_flags(path, ds_hold_flags, 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 &&
 	    (key_loaded || !(*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_flags(dmu_objset_ds(*osp),
 			    ds_hold_flags, tag);
 			*osp = NULL;
 		}
 	}
 	sa_os = *osp;
 
 	return (err);
 }
 
 static void
 close_objset(objset_t *os, const 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_flags(dmu_objset_ds(os),
 	    key_loaded ? DS_HOLD_FLAG_DECRYPT : 0, tag);
 	sa_attr_table = NULL;
 	sa_os = NULL;
 
 	zdb_unload_key();
 }
 
 static void
 fuid_table_destroy(void)
 {
 	if (fuid_table_loaded) {
 		zfs_fuid_table_destroy(&idx_tree, &domain_tree);
 		fuid_table_loaded = B_FALSE;
 	}
 }
 
 /*
  * Clean up DDT internal state. ddt_lookup() adds entries to ddt_tree, which on
  * a live pool are normally cleaned up during ddt_sync(). We can't do that (and
  * wouldn't want to anyway), but if we don't clean up the presence of stuff on
  * ddt_tree will trip asserts in ddt_table_free(). So, we clean up ourselves.
  *
  * Note that this is not a particularly efficient way to do this, but
  * ddt_remove() is the only public method that can do the work we need, and it
  * requires the right locks and etc to do the job. This is only ever called
  * during zdb shutdown so efficiency is not especially important.
  */
 static void
 zdb_ddt_cleanup(spa_t *spa)
 {
 	for (enum zio_checksum c = 0; c < ZIO_CHECKSUM_FUNCTIONS; c++) {
 		ddt_t *ddt = spa->spa_ddt[c];
 		if (!ddt)
 			continue;
 
 		spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
 		ddt_enter(ddt);
 		ddt_entry_t *dde = avl_first(&ddt->ddt_tree), *next;
 		while (dde) {
 			next = AVL_NEXT(&ddt->ddt_tree, dde);
 			dde->dde_io = NULL;
 			ddt_remove(ddt, dde);
 			dde = next;
 		}
 		ddt_exit(ddt);
 		spa_config_exit(spa, SCL_CONFIG, FTAG);
 	}
 }
 
 static void
 zdb_exit(int reason)
 {
 	if (spa != NULL)
 		zdb_ddt_cleanup(spa);
 
 	if (os != NULL) {
 		close_objset(os, FTAG);
 	} else if (spa != NULL) {
 		spa_close(spa, FTAG);
 	}
 
 	fuid_table_destroy();
 
 	if (kernel_init_done)
 		kernel_fini();
 
 	exit(reason);
 }
 
 /*
  * 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)) {
 		const char *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) {
 		boolean_t can_print = !dump_opt['P'];
 		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])) {
 				can_print = B_FALSE;
 				break;
 			}
 		}
 
 		for (idx = 0; idx < cnt; ++idx) {
 			if (can_print)
 				(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];
 	int error;
 
 	error = sa_size(hdl, sa_attr_table[ZPL_SYMLINK], &sa_symlink_size);
 	if (error || sa_symlink_size == 0) {
 		return;
 	}
 	if (sa_symlink_size >= sizeof (linktarget)) {
 		(void) printf("symlink size %d is too large\n",
 		    sa_symlink_size);
 		return;
 	}
 	linktarget[sa_symlink_size] = '\0';
 	if (sa_lookup(hdl, sa_attr_table[ZPL_SYMLINK],
 	    &linktarget, sa_symlink_size) == 0)
 		(void) printf("\ttarget	%s\n", linktarget);
 }
 
 static void
 dump_znode(objset_t *os, uint64_t object, void *data, size_t size)
 {
 	(void) data, (void) 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);
 }
 
 static void
 dump_acl(objset_t *os, uint64_t object, void *data, size_t size)
 {
 	(void) os, (void) object, (void) data, (void) size;
 }
 
 static void
 dump_dmu_objset(objset_t *os, uint64_t object, void *data, size_t size)
 {
 	(void) os, (void) object, (void) data, (void) 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 */
 	_Static_assert(sizeof (iblk) >= NN_NUMBUF_SZ, "iblk truncated");
 	_Static_assert(sizeof (dblk) >= NN_NUMBUF_SZ, "dblk truncated");
 	_Static_assert(sizeof (lsize) >= NN_NUMBUF_SZ, "lsize truncated");
 	_Static_assert(sizeof (asize) >= NN_NUMBUF_SZ, "asize truncated");
 	_Static_assert(sizeof (bonus_size) >= NN_NUMBUF_SZ,
 	    "bonus_size truncated");
 
 	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 (!key_loaded && 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) snprintf(fill, sizeof (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 (key_loaded ||
 		    (!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) {
 		if (dn->dn_phys->dn_flags & DNODE_FLAG_SPILL_BLKPTR) {
 			char blkbuf[BP_SPRINTF_LEN];
 			snprintf_blkptr_compact(blkbuf, sizeof (blkbuf),
 			    DN_SPILL_BLKPTR(dn->dn_phys), B_FALSE);
 			(void) printf("\nSpill block: %s\n", blkbuf);
 		}
 		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 */
 			_Static_assert(sizeof (segsize) >= NN_NUMBUF_SZ,
 			    "segsize truncated");
 			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 *const 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, const char **msg)
 {
 	uint64_t flags = 0;
 	char *p, *s, *dup, *flagstr, *tmp = NULL;
 	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_start = ZDB_MAP_OBJECT_ID(zor->zor_obj_start);
 		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_r(dup, ":", &tmp);
 	zor->zor_obj_start = strtoull(s, &p, 0);
 
 	if (*p != '\0') {
 		*msg = "Invalid characters in start object ID";
 		rc = 1;
 		goto out;
 	}
 
 	s = strtok_r(NULL, ":", &tmp);
 	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_r(NULL, ":", &tmp);
 	if (s == NULL) {
 		zor->zor_flags = ZOR_FLAG_ALL_TYPES;
 		goto out;
 	} else if (strtok_r(NULL, ":", &tmp) != 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;
 
 	zor->zor_obj_start = ZDB_MAP_OBJECT_ID(zor->zor_obj_start);
 	zor->zor_obj_end = ZDB_MAP_OBJECT_ID(zor->zor_obj_end);
 
 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 */
 	_Static_assert(sizeof (numbuf) >= NN_NUMBUF_SZ, "numbuf truncated");
 
 	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, ctime(&timestamp));
 
+	char blkbuf[BP_SPRINTF_LEN];
+	snprintf_blkptr(blkbuf, sizeof (blkbuf), &ub->ub_rootbp);
+	(void) printf("\tbp = %s\n", blkbuf);
+
 	(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("\traidz_reflow state=%u off=%llu\n",
 	    (int)RRSS_GET_STATE(ub),
 	    (u_longlong_t)RRSS_GET_OFFSET(ub));
 
 	(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));
 		zdb_exit(1);
 	}
 
 	if (fstat64(fd, &statbuf) != 0) {
 		(void) printf("failed to stat '%s': %s\n", cachefile,
 		    strerror(errno));
 		zdb_exit(1);
 	}
 
 	if ((buf = malloc(statbuf.st_size)) == NULL) {
 		(void) fprintf(stderr, "failed to allocate %llu bytes\n",
 		    (u_longlong_t)statbuf.st_size);
 		zdb_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);
 		zdb_exit(1);
 	}
 
 	(void) close(fd);
 
 	if (nvlist_unpack(buf, statbuf.st_size, &config, 0) != 0) {
 		(void) fprintf(stderr, "failed to unpack nvlist\n");
 		zdb_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;
 	const 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 = 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(const char *prefix, const cksum_record_t *rec)
 {
 	fputs(prefix, stdout);
 	for (int i = 0; i < VDEV_LABELS; i++)
 		if (rec->labels[i] == B_TRUE)
 			printf("%d ", i);
 	putchar('\n');
 }
 
 #define	MAX_UBERBLOCK_COUNT (VDEV_UBERBLOCK_RING >> UBERBLOCK_SHIFT)
 
 typedef struct zdb_label {
 	vdev_label_t label;
 	uint64_t label_offset;
 	nvlist_t *config_nv;
 	cksum_record_t *config;
 	cksum_record_t *uberblocks[MAX_UBERBLOCK_COUNT];
 	boolean_t header_printed;
 	boolean_t read_failed;
 	boolean_t cksum_valid;
 } 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 %s\n", l,
 	    label->cksum_valid ? "" : "(Bad label cksum)");
 	(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(const 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, const 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];
 	zio_cksum_t cksum;
 	int failed = 0;
 	l2arc_dev_t dev;
 
 	if (!dump_opt['q'])
 		print_l2arc_log_blocks();
 	memcpy(lbps, l2dhdr->dh_start_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_t *abd = abd_alloc_linear(asize, B_TRUE);
 			abd_copy_from_buf_off(abd, &this_lb, 0, asize);
 			abd_t dabd;
 			abd_get_from_buf_struct(&dabd, &this_lb,
 			    sizeof (this_lb));
 			int err = zio_decompress_data(L2BLK_GET_COMPRESS(
 			    (&lbps[0])->lbp_prop), abd, &dabd,
 			    asize, sizeof (this_lb), NULL);
 			abd_free(&dabd);
 			abd_free(abd);
 			if (err != 0) {
 				(void) printf("L2ARC block decompression "
 				    "failed\n");
 				goto out;
 			}
 			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;
 	}
 out:
 	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 = {0}, rebuild = {0};
 	int error = B_FALSE;
 
 	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));
 		zfs_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
 dump_backup_bytes(objset_t *os, void *buf, int len, void *arg)
 {
 	const char *p = (const char *)buf;
 	ssize_t nwritten;
 
 	(void) os;
 	(void) arg;
 
 	/* Write the data out, handling short writes and signals. */
 	while ((nwritten = write(STDOUT_FILENO, p, len)) < len) {
 		if (nwritten < 0) {
 			if (errno == EINTR)
 				continue;
 			return (errno);
 		}
 		p += nwritten;
 		len -= nwritten;
 	}
 
 	return (0);
 }
 
 static void
 dump_backup(const char *pool, uint64_t objset_id, const char *flagstr)
 {
 	boolean_t embed = B_FALSE;
 	boolean_t large_block = B_FALSE;
 	boolean_t compress = B_FALSE;
 	boolean_t raw = B_FALSE;
 
 	const char *c;
 	for (c = flagstr; c != NULL && *c != '\0'; c++) {
 		switch (*c) {
 			case 'e':
 				embed = B_TRUE;
 				break;
 			case 'L':
 				large_block = B_TRUE;
 				break;
 			case 'c':
 				compress = B_TRUE;
 				break;
 			case 'w':
 				raw = B_TRUE;
 				break;
 			default:
 				fprintf(stderr, "dump_backup: invalid flag "
 				    "'%c'\n", *c);
 				return;
 		}
 	}
 
 	if (isatty(STDOUT_FILENO)) {
 		fprintf(stderr, "dump_backup: stream cannot be written "
 		    "to a terminal\n");
 		return;
 	}
 
 	offset_t off = 0;
 	dmu_send_outparams_t out = {
 	    .dso_outfunc = dump_backup_bytes,
 	    .dso_dryrun  = B_FALSE,
 	};
 
 	int err = dmu_send_obj(pool, objset_id, /* fromsnap */0, embed,
 	    large_block, compress, raw, /* saved */ B_FALSE, STDOUT_FILENO,
 	    &off, &out);
 	if (err != 0) {
 		fprintf(stderr, "dump_backup: dmu_send_obj: %s\n",
 		    strerror(err));
 		return;
 	}
 }
 
 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);
 	if (fd == -1)
 		return (errno);
 	/*
 	 * 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) {
 		(void) close(fd);
 		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);
 			(void) close(fd);
 			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 boolean_t
 label_cksum_valid(vdev_label_t *label, uint64_t offset)
 {
 	zio_checksum_info_t *ci = &zio_checksum_table[ZIO_CHECKSUM_LABEL];
 	zio_cksum_t expected_cksum;
 	zio_cksum_t actual_cksum;
 	zio_cksum_t verifier;
 	zio_eck_t *eck;
 	int byteswap;
 
 	void *data = (char *)label + offsetof(vdev_label_t, vl_vdev_phys);
 	eck = (zio_eck_t *)((char *)(data) + VDEV_PHYS_SIZE) - 1;
 
 	offset += offsetof(vdev_label_t, vl_vdev_phys);
 	ZIO_SET_CHECKSUM(&verifier, offset, 0, 0, 0);
 
 	byteswap = (eck->zec_magic == BSWAP_64(ZEC_MAGIC));
 	if (byteswap)
 		byteswap_uint64_array(&verifier, sizeof (zio_cksum_t));
 
 	expected_cksum = eck->zec_cksum;
 	eck->zec_cksum = verifier;
 
 	abd_t *abd = abd_get_from_buf(data, VDEV_PHYS_SIZE);
 	ci->ci_func[byteswap](abd, VDEV_PHYS_SIZE, NULL, &actual_cksum);
 	abd_free(abd);
 
 	if (byteswap)
 		byteswap_uint64_array(&expected_cksum, sizeof (zio_cksum_t));
 
 	if (ZIO_CHECKSUM_EQUAL(actual_cksum, expected_cksum))
 		return (B_TRUE);
 
 	return (B_FALSE);
 }
 
 static int
 dump_label(const char *dev)
 {
 	char path[MAXPATHLEN];
 	zdb_label_t labels[VDEV_LABELS] = {{{{0}}}};
 	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;
 
 	/*
 	 * 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));
 		zdb_exit(1);
 	}
 
 	if (fstat64_blk(fd, &statbuf) != 0) {
 		(void) printf("failed to stat '%s': %s\n", path,
 		    strerror(errno));
 		(void) close(fd);
 		zdb_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_TYPED(psize, sizeof (vdev_label_t), uint64_t);
 	ashift = SPA_MINBLOCKSHIFT;
 
 	/*
 	 * 1. Read the label from disk
 	 * 2. Verify label cksum
 	 * 3. Unpack the configuration and insert in config tree.
 	 * 4. 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;
 
 		label->label_offset = vdev_label_offset(psize, l, 0);
 
 		if (pread64(fd, &label->label, sizeof (label->label),
 		    label->label_offset) != 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;
 		label->cksum_valid = label_cksum_valid(&label->label,
 		    label->label_offset);
 
 		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 read 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;
 
 static int
 dump_one_objset(const char *dsname, void *arg)
 {
 	(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]++;
 			objset_t *mos = os->os_spa->spa_meta_objset;
 			dnode_t *rl;
 			VERIFY0(dnode_hold(mos,
 			    dbn->dbn_phys.zbm_redaction_obj, FTAG, &rl));
 			if (rl->dn_have_spill) {
 				global_feature_count[
 				    SPA_FEATURE_REDACTION_LIST_SPILL]++;
 			}
 		}
 		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_brt_entry {
 	dva_t		zbre_dva;
 	uint64_t	zbre_refcount;
 	avl_node_t	zbre_node;
 } zdb_brt_entry_t;
 
 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_clone_asize;
 	uint64_t	zcb_clone_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;
 	avl_tree_t	zcb_brt;
 	boolean_t	zcb_brt_is_active;
 } 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 {
 	const 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)
 {
 	int i;
 
 	ASSERT(type < ZDB_OT_TOTAL);
 
 	if (zilog && zil_bp_tree_add(zilog, bp) != 0)
 		return;
 
 	/*
 	 * This flag controls if we will issue a claim for the block while
 	 * counting it, to ensure that all blocks are referenced in space maps.
 	 * We don't issue claims if we're not doing leak tracking, because it's
 	 * expensive if the user isn't interested. We also don't claim the
 	 * second or later occurences of cloned or dedup'd blocks, because we
 	 * already claimed them the first time.
 	 */
 	boolean_t do_claim = !dump_opt['L'];
 
 	spa_config_enter(zcb->zcb_spa, SCL_CONFIG, FTAG, RW_READER);
 
 	blkptr_t tempbp;
 	if (BP_GET_DEDUP(bp)) {
 		/*
 		 * Dedup'd blocks are special. We need to count them, so we can
 		 * later uncount them when reporting leaked space, and we must
 		 * only claim them once.
 		 *
 		 * We use the existing dedup system to track what we've seen.
 		 * The first time we see a block, we do a ddt_lookup() to see
 		 * if it exists in the DDT. If we're doing leak tracking, we
 		 * claim the block at this time.
 		 *
 		 * Each time we see a block, we reduce the refcount in the
 		 * entry by one, and add to the size and count of dedup'd
 		 * blocks to report at the end.
 		 */
 
 		ddt_t *ddt = ddt_select(zcb->zcb_spa, bp);
 
 		ddt_enter(ddt);
 
 		/*
 		 * Find the block. This will create the entry in memory, but
 		 * we'll know if that happened by its refcount.
 		 */
 		ddt_entry_t *dde = ddt_lookup(ddt, bp);
 
 		/*
 		 * ddt_lookup() can return NULL if this block didn't exist
 		 * in the DDT and creating it would take the DDT over its
 		 * quota. Since we got the block from disk, it must exist in
 		 * the DDT, so this can't happen. However, when unique entries
 		 * are pruned, the dedup bit can be set with no corresponding
 		 * entry in the DDT.
 		 */
 		if (dde == NULL) {
 			ddt_exit(ddt);
 			goto skipped;
 		}
 
 		/* Get the phys for this variant */
 		ddt_phys_variant_t v = ddt_phys_select(ddt, dde, bp);
 
 		/*
 		 * This entry may have multiple sets of DVAs. We must claim
 		 * each set the first time we see them in a real block on disk,
 		 * or count them on subsequent occurences. We don't have a
 		 * convenient way to track the first time we see each variant,
 		 * so we repurpose dde_io as a set of "seen" flag bits. We can
 		 * do this safely in zdb because it never writes, so it will
 		 * never have a writing zio for this block in that pointer.
 		 */
 		boolean_t seen = !!(((uintptr_t)dde->dde_io) & (1 << v));
 		if (!seen)
 			dde->dde_io =
 			    (void *)(((uintptr_t)dde->dde_io) | (1 << v));
 
 		/* Consume a reference for this block. */
 		if (ddt_phys_total_refcnt(ddt, dde->dde_phys) > 0)
 			ddt_phys_decref(dde->dde_phys, v);
 
 		/*
 		 * If this entry has a single flat phys, it may have been
 		 * extended with additional DVAs at some time in its life.
 		 * This block might be from before it was fully extended, and
 		 * so have fewer DVAs.
 		 *
 		 * If this is the first time we've seen this block, and we
 		 * claimed it as-is, then we would miss the claim on some
 		 * number of DVAs, which would then be seen as leaked.
 		 *
 		 * In all cases, if we've had fewer DVAs, then the asize would
 		 * be too small, and would lead to the pool apparently using
 		 * more space than allocated.
 		 *
 		 * To handle this, we copy the canonical set of DVAs from the
 		 * entry back to the block pointer before we claim it.
 		 */
 		if (v == DDT_PHYS_FLAT) {
 			ASSERT3U(BP_GET_BIRTH(bp), ==,
 			    ddt_phys_birth(dde->dde_phys, v));
 			tempbp = *bp;
 			ddt_bp_fill(dde->dde_phys, v, &tempbp,
 			    BP_GET_BIRTH(bp));
 			bp = &tempbp;
 		}
 
 		if (seen) {
 			/*
 			 * The second or later time we see this block,
 			 * it's a duplicate and we count it.
 			 */
 			zcb->zcb_dedup_asize += BP_GET_ASIZE(bp);
 			zcb->zcb_dedup_blocks++;
 
 			/* Already claimed, don't do it again. */
 			do_claim = B_FALSE;
 		}
 
 		ddt_exit(ddt);
 	} else if (zcb->zcb_brt_is_active &&
 	    brt_maybe_exists(zcb->zcb_spa, bp)) {
 		/*
 		 * Cloned blocks are special. We need to count them, so we can
 		 * later uncount them when reporting leaked space, and we must
 		 * only claim them once.
 		 *
 		 * To do this, we keep our own in-memory BRT. For each block
 		 * we haven't seen before, we look it up in the real BRT and
 		 * if its there, we note it and its refcount then proceed as
 		 * normal. If we see the block again, we count it as a clone
 		 * and then give it no further consideration.
 		 */
 		zdb_brt_entry_t zbre_search, *zbre;
 		avl_index_t where;
 
 		zbre_search.zbre_dva = bp->blk_dva[0];
 		zbre = avl_find(&zcb->zcb_brt, &zbre_search, &where);
 		if (zbre == NULL) {
 			/* Not seen before; track it */
 			uint64_t refcnt =
 			    brt_entry_get_refcount(zcb->zcb_spa, bp);
 			if (refcnt > 0) {
 				zbre = umem_zalloc(sizeof (zdb_brt_entry_t),
 				    UMEM_NOFAIL);
 				zbre->zbre_dva = bp->blk_dva[0];
 				zbre->zbre_refcount = refcnt;
 				avl_insert(&zcb->zcb_brt, zbre, where);
 			}
 		} else  {
 			/*
 			 * Second or later occurrence, count it and take a
 			 * refcount.
 			 */
 			zcb->zcb_clone_asize += BP_GET_ASIZE(bp);
 			zcb->zcb_clone_blocks++;
 
 			zbre->zbre_refcount--;
 			if (zbre->zbre_refcount == 0) {
 				avl_remove(&zcb->zcb_brt, zbre);
 				umem_free(zbre, sizeof (zdb_brt_entry_t));
 			}
 
 			/* Already claimed, don't do it again. */
 			do_claim = B_FALSE;
 		}
 	}
 
 skipped:
 	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 (!do_claim)
 		return;
 
 	VERIFY0(zio_wait(zio_claim(NULL, zcb->zcb_spa,
 	    spa_min_claim_txg(zcb->zcb_spa), bp, NULL, NULL,
 	    ZIO_FLAG_CANFAIL)));
 }
 
 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_GET_LOGICAL_BIRTH(bp) > 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;
 		uint64_t kb_per_sec =
 		    1 + bytes / (1 + ((now - zcb->zcb_start) / 1000 / 1000));
 		uint64_t sec_remaining =
 		    (zcb->zcb_totalasize - bytes) / 1024 / kb_per_sec;
 
 		/* make sure nicenum has enough space */
 		_Static_assert(sizeof (buf) >= NN_NUMBUF_SZ, "buf truncated");
 
 		zfs_nicebytes(bytes, buf, sizeof (buf));
 		(void) fprintf(stderr,
 		    "\r%5s completed (%4"PRIu64"MB/s) "
 		    "estimated time remaining: "
 		    "%"PRIu64"hr %02"PRIu64"min %02"PRIu64"sec        ",
 		    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 */
 };
 
 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);
 }
 
 static void
 claim_segment_impl_cb(uint64_t inner_offset, vdev_t *vd, uint64_t offset,
     uint64_t size, void *arg)
 {
 	(void) inner_offset, (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);
 }
 
 static int
 increment_indirect_mapping_cb(void *arg, const blkptr_t *bp, boolean_t bp_freed,
     dmu_tx_t *tx)
 {
 	(void) 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);
 }
 
 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);
 	}
 }
 
 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 += 1ULL << vd->vdev_ashift) {
 			if (range_tree_contains(msp->ms_allocatable,
 			    offset + inner_offset, 1ULL << vd->vdev_ashift)) {
 				obsolete_bytes += 1ULL << 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);
 }
 
 static int
 count_block_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
 {
 	(void) 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 *attrp = zap_attribute_alloc();
 	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, attrp) == 0;
 	    (void) zap_cursor_advance(&zc)) {
 		dsl_deadlist_open(&ll, mos, attrp->za_first_integer);
 		func(&ll, arg);
 		dsl_deadlist_close(&ll);
 	}
 	zap_cursor_fini(&zc);
 	zap_attribute_free(attrp);
 }
 
 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
 zdb_brt_entry_compare(const void *zcn1, const void *zcn2)
 {
 	const dva_t *dva1 = &((const zdb_brt_entry_t *)zcn1)->zbre_dva;
 	const dva_t *dva2 = &((const zdb_brt_entry_t *)zcn2)->zbre_dva;
 	int cmp;
 
 	cmp = TREE_CMP(DVA_GET_VDEV(dva1), DVA_GET_VDEV(dva2));
 	if (cmp == 0)
 		cmp = TREE_CMP(DVA_GET_OFFSET(dva1), DVA_GET_OFFSET(dva2));
 
 	return (cmp);
 }
 
 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;
 
 	ddt_prefetch_all(spa);
 
 	zcb = umem_zalloc(sizeof (zdb_cb_t), UMEM_NOFAIL);
 
 	if (spa_feature_is_active(spa, SPA_FEATURE_BLOCK_CLONING)) {
 		avl_create(&zcb->zcb_brt, zdb_brt_entry_compare,
 		    sizeof (zdb_brt_entry_t),
 		    offsetof(zdb_brt_entry_t, zbre_node));
 		zcb->zcb_brt_is_active = B_TRUE;
 	}
 
 	(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.
 	 */
 	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_clone_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));
 	}
 
 	if (tzb->zb_count == 0) {
 		umem_free(zcb, sizeof (zdb_cb_t));
 		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    count: %6llu\n",
 	    "bp cloned:", (u_longlong_t)zcb->zcb_clone_asize,
 	    (u_longlong_t)zcb->zcb_clone_blocks);
 	(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;
 		char csize[32], lsize[32], psize[32], asize[32];
 		char avg[32], gang[32];
 		(void) printf("\nBlocks\tLSIZE\tPSIZE\tASIZE"
 		    "\t  avg\t comp\t%%Total\tType\n");
 
 		zfs_blkstat_t *mdstats = umem_zalloc(sizeof (zfs_blkstat_t),
 		    UMEM_NOFAIL);
 
 		for (t = 0; t <= ZDB_OT_TOTAL; t++) {
 			const char *typename;
 
 			/* make sure nicenum has enough space */
 			_Static_assert(sizeof (csize) >= NN_NUMBUF_SZ,
 			    "csize truncated");
 			_Static_assert(sizeof (lsize) >= NN_NUMBUF_SZ,
 			    "lsize truncated");
 			_Static_assert(sizeof (psize) >= NN_NUMBUF_SZ,
 			    "psize truncated");
 			_Static_assert(sizeof (asize) >= NN_NUMBUF_SZ,
 			    "asize truncated");
 			_Static_assert(sizeof (avg) >= NN_NUMBUF_SZ,
 			    "avg truncated");
 			_Static_assert(sizeof (gang) >= NN_NUMBUF_SZ,
 			    "gang truncated");
 
 			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 (level != ZB_TOTAL && t < DMU_OT_NUMTYPES &&
 				    (level > 0 || DMU_OT_IS_METADATA(t))) {
 					mdstats->zb_count += zb->zb_count;
 					mdstats->zb_lsize += zb->zb_lsize;
 					mdstats->zb_psize += zb->zb_psize;
 					mdstats->zb_asize += zb->zb_asize;
 					mdstats->zb_gangs += zb->zb_gangs;
 				}
 
 				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);
 				}
 			}
 		}
 		zdb_nicenum(mdstats->zb_count, csize,
 		    sizeof (csize));
 		zdb_nicenum(mdstats->zb_lsize, lsize,
 		    sizeof (lsize));
 		zdb_nicenum(mdstats->zb_psize, psize,
 		    sizeof (psize));
 		zdb_nicenum(mdstats->zb_asize, asize,
 		    sizeof (asize));
 		zdb_nicenum(mdstats->zb_asize / mdstats->zb_count, avg,
 		    sizeof (avg));
 		zdb_nicenum(mdstats->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)mdstats->zb_lsize / mdstats->zb_psize,
 		    100.0 * mdstats->zb_asize / tzb->zb_asize);
 		(void) printf("%s\n", "Metadata Total");
 
 		/* Output a table summarizing block sizes in the pool */
 		if (dump_opt['b'] >= 2) {
 			dump_size_histograms(zcb);
 		}
 
 		umem_free(mdstats, sizeof (zfs_blkstat_t));
 	}
 
 	(void) printf("\n");
 
 	if (leaks) {
 		umem_free(zcb, sizeof (zdb_cb_t));
 		return (2);
 	}
 
 	if (zcb->zcb_haderrors) {
 		umem_free(zcb, sizeof (zdb_cb_t));
 		return (3);
 	}
 
 	umem_free(zcb, sizeof (zdb_cb_t));
 	return (0);
 }
 
 typedef struct zdb_ddt_entry {
 	/* key must be first for ddt_key_compare */
 	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;
 
 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)
 {
 	(void) zilog, (void) dnp;
 	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 = {{{0}}};
 	ddt_stat_t dds_total = {0};
 
 	avl_create(&t, ddt_key_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) {
 		uint64_t refcnt = zdde->zdde_ref_blocks;
 		ASSERT(refcnt != 0);
 
 		ddt_stat_t *dds = &ddh_total.ddh_stat[highbit64(refcnt) - 1];
 
 		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;
 
 		umem_free(zdde, sizeof (*zdde));
 	}
 
 	avl_destroy(&t);
 
 	ddt_histogram_total(&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) {
 		if (target != poolname)
 			free(poolname);
 		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) {
 			free(bogus_name);
 			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);
 }
 
 static void
 mos_leaks_cb(void *arg, uint64_t start, uint64_t size)
 {
 	(void) arg;
 	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_root_zap != 0)
 		mos_obj_refd(vd->vdev_root_zap);
 
 	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 void
 errorlog_count_refd(objset_t *mos, uint64_t errlog)
 {
 	zap_cursor_t zc;
 	zap_attribute_t *za = zap_attribute_alloc();
 	for (zap_cursor_init(&zc, mos, errlog);
 	    zap_cursor_retrieve(&zc, za) == 0;
 	    zap_cursor_advance(&zc)) {
 		mos_obj_refd(za->za_first_integer);
 	}
 	zap_cursor_fini(&zc);
 	zap_attribute_free(za);
 }
 
 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);
 
 	if (spa_feature_is_enabled(spa, SPA_FEATURE_HEAD_ERRLOG)) {
 		errorlog_count_refd(mos, spa->spa_errlog_last);
 		errorlog_count_refd(mos, 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 c = 0; c < ZIO_CHECKSUM_FUNCTIONS; c++) {
 		ddt_t *ddt = spa->spa_ddt[c];
 		if (!ddt || ddt->ddt_version == DDT_VERSION_UNCONFIGURED)
 			continue;
 
 		/* DDT store objects */
 		for (ddt_type_t type = 0; type < DDT_TYPES; type++) {
 			for (ddt_class_t class = 0; class < DDT_CLASSES;
 			    class++) {
 				mos_obj_refd(ddt->ddt_object[type][class]);
 			}
 		}
 
 		/* FDT container */
 		if (ddt->ddt_version == DDT_VERSION_FDT)
 			mos_obj_refd(ddt->ddt_dir_object);
 
 		/* FDT log objects */
 		if (ddt->ddt_flags & DDT_FLAG_LOG) {
 			mos_obj_refd(ddt->ddt_log[0].ddl_object);
 			mos_obj_refd(ddt->ddt_log[1].ddl_object);
 		}
 	}
 
 	if (spa->spa_brt != NULL) {
 		brt_t *brt = spa->spa_brt;
 		for (uint64_t vdevid = 0; vdevid < brt->brt_nvdevs; vdevid++) {
 			brt_vdev_t *brtvd = &brt->brt_vdevs[vdevid];
 			if (brtvd != NULL && brtvd->bv_initiated) {
 				mos_obj_refd(brtvd->bv_mos_brtvdev);
 				mos_obj_refd(brtvd->bv_mos_entries);
 			}
 		}
 	}
 
 	/*
 	 * 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;
 			VERIFY0(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 = {0};
 
 	(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['T'])
 		dump_brt(spa);
 
 	if (dump_opt['d'] > 2 || dump_opt['m'])
 		dump_metaslabs(spa);
 	if (dump_opt['M'])
 		dump_metaslab_groups(spa, dump_opt['M'] > 1);
 	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_REDACTION_LIST_SPILL] = 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();
 		zdb_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 _ZFS_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, *tmp = NULL;
 
 	if (sizes == NULL)
 		return (B_FALSE);
 
 	s0 = strtok_r(sizes, "/", &tmp);
 	if (s0 == NULL)
 		return (B_FALSE);
 	s1 = strtok_r(NULL, "/", &tmp);
 	*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
 try_decompress_block(abd_t *pabd, uint64_t lsize, uint64_t psize,
     int flags, int cfunc, void *lbuf, void *lbuf2)
 {
 	if (flags & ZDB_FLAG_VERBOSE) {
 		(void) fprintf(stderr,
 		    "Trying %05llx -> %05llx (%s)\n",
 		    (u_longlong_t)psize,
 		    (u_longlong_t)lsize,
 		    zio_compress_table[cfunc].ci_name);
 	}
 
 	/*
 	 * We set lbuf to all zeros and lbuf2 to all
 	 * ones, then decompress to both buffers and
 	 * compare their contents. This way we can
 	 * know if decompression filled exactly to
 	 * lsize or if it left some bytes unwritten.
 	 */
 
 	memset(lbuf, 0x00, lsize);
 	memset(lbuf2, 0xff, lsize);
 
 	abd_t labd, labd2;
 	abd_get_from_buf_struct(&labd, lbuf, lsize);
 	abd_get_from_buf_struct(&labd2, lbuf2, lsize);
 
 	boolean_t ret = B_FALSE;
 	if (zio_decompress_data(cfunc, pabd,
 	    &labd, psize, lsize, NULL) == 0 &&
 	    zio_decompress_data(cfunc, pabd,
 	    &labd2, psize, lsize, NULL) == 0 &&
 	    memcmp(lbuf, lbuf2, lsize) == 0)
 		ret = B_TRUE;
 
 	abd_free(&labd2);
 	abd_free(&labd);
 
 	return (ret);
 }
 
 static uint64_t
 zdb_decompress_block(abd_t *pabd, void *buf, void *lbuf, uint64_t lsize,
     uint64_t psize, int flags)
 {
 	(void) buf;
 	uint64_t orig_lsize = lsize;
 	boolean_t tryzle = ((getenv("ZDB_NO_ZLE") == NULL));
 	boolean_t found = 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) |
 	    ZIO_COMPRESS_MASK(ZLE);
 	*cfuncp++ = ZIO_COMPRESS_LZ4;
 	*cfuncp++ = ZIO_COMPRESS_LZJB;
 	mask |= ZIO_COMPRESS_MASK(LZ4) | ZIO_COMPRESS_MASK(LZJB);
 	/*
 	 * Every gzip level has the same decompressor, no need to
 	 * run it 9 times per bruteforce attempt.
 	 */
 	mask |= ZIO_COMPRESS_MASK(GZIP_2) | ZIO_COMPRESS_MASK(GZIP_3);
 	mask |= ZIO_COMPRESS_MASK(GZIP_4) | ZIO_COMPRESS_MASK(GZIP_5);
 	mask |= ZIO_COMPRESS_MASK(GZIP_6) | ZIO_COMPRESS_MASK(GZIP_7);
 	mask |= ZIO_COMPRESS_MASK(GZIP_8) | ZIO_COMPRESS_MASK(GZIP_9);
 	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 (try_decompress_block(pabd, lsize, psize, flags,
 			    *cfuncp, lbuf, lbuf2)) {
 				found = B_TRUE;
 				break;
 			}
 		}
 		if (*cfuncp != 0)
 			break;
 	}
 	if (!found && tryzle) {
 		for (lsize = orig_lsize; lsize <= maxlsize;
 		    lsize += SPA_MINBLOCKSIZE) {
 			if (try_decompress_block(pabd, lsize, psize, flags,
 			    ZIO_COMPRESS_ZLE, lbuf, lbuf2)) {
 				*cfuncp = ZIO_COMPRESS_ZLE;
 				found = B_TRUE;
 				break;
 			}
 		}
 	}
 	umem_free(lbuf2, SPA_MAXBLOCKSIZE);
 
 	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 (lsize > maxlsize ? -1 : lsize);
 }
 
 /*
  * 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, *flagstr, *sizes, *tmp = NULL;
 	const char *vdev, *errmsg = NULL;
 	int i, len, error;
 	boolean_t borrowed = B_FALSE, found = B_FALSE;
 
 	dup = strdup(thing);
 	s = strtok_r(dup, ":", &tmp);
 	vdev = s ?: "";
 	s = strtok_r(NULL, ":", &tmp);
 	offset = strtoull(s ? s : "", NULL, 16);
 	sizes = strtok_r(NULL, ":", &tmp);
 	s = strtok_r(NULL, ":", &tmp);
 	flagstr = strdup(s ?: "");
 
 	if (!zdb_parse_block_sizes(sizes, &lsize, &psize))
 		errmsg = "invalid size(s)";
 	if (!IS_P2ALIGNED(psize, DEV_BSIZE) || !IS_P2ALIGNED(lsize, DEV_BSIZE))
 		errmsg = "size must be a multiple of sector size";
 	if (!IS_P2ALIGNED(offset, DEV_BSIZE))
 		errmsg = "offset must be a multiple of sector size";
 	if (errmsg) {
 		(void) printf("Invalid block specifier: %s  - %s\n",
 		    thing, errmsg);
 		goto done;
 	}
 
 	tmp = NULL;
 	for (s = strtok_r(flagstr, ":", &tmp);
 	    s != NULL;
 	    s = strtok_r(NULL, ":", &tmp)) {
 		len = strlen(flagstr);
 		for (i = 0; i < len; 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);
 		goto done;
 	} 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_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) {
 		lsize = zdb_decompress_block(pabd, buf, lbuf,
 		    lsize, psize, flags);
 		if (lsize == -1) {
 			(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,
 		    BLK_CONFIG_NEEDED, BLK_VERIFY_ONLY) == B_FALSE) {
 			abd_return_buf_copy(pabd, buf, lsize);
 			borrowed = B_FALSE;
 			buf = lbuf;
 			lsize = zdb_decompress_block(pabd, buf,
 			    lbuf, lsize, psize, flags);
 			b = (const blkptr_t *)(void *)
 			    ((uintptr_t)buf + (uintptr_t)blkptr_offset);
 			if (lsize == -1 || zfs_blkptr_verify(spa, b,
 			    BLK_CONFIG_NEEDED, 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);
 			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_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_null(NULL, spa, NULL,
 				    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\t"
 				    "cksum=%016llx:%016llx:%016llx:%016llx\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 = {{{{0}}}};
 	unsigned long long *words = (void *)&bp;
 	char *buf;
 	int err;
 
 	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");
 		zdb_exit(1);
 	}
 	ASSERT3U(BPE_GET_LSIZE(&bp), <=, SPA_MAXBLOCKSIZE);
 	buf = malloc(SPA_MAXBLOCKSIZE);
 	if (buf == NULL) {
 		(void) fprintf(stderr, "out of memory\n");
 		zdb_exit(1);
 	}
 	err = decode_embedded_bp(&bp, buf, BPE_GET_LSIZE(&bp));
 	if (err != 0) {
 		(void) fprintf(stderr, "decode failed: %u\n", err);
 		zdb_exit(1);
 	}
 	zdb_dump_block_raw(buf, BPE_GET_LSIZE(&bp), 0);
 	free(buf);
 }
 
 /* check for valid hex or decimal numeric string */
 static boolean_t
 zdb_numeric(char *str)
 {
 	int i = 0, len;
 
 	len = strlen(str);
 	if (len == 0)
 		return (B_FALSE);
 	if (strncmp(str, "0x", 2) == 0 || strncmp(str, "0X", 2) == 0)
 		i = 2;
 	for (; i < len; i++) {
 		if (!isxdigit(str[i]))
 			return (B_FALSE);
 	}
 	return (B_TRUE);
 }
 
 static int
 dummy_get_file_info(dmu_object_type_t bonustype, const void *data,
     zfs_file_info_t *zoi)
 {
 	(void) data, (void) zoi;
 
 	if (bonustype != DMU_OT_ZNODE && bonustype != DMU_OT_SA)
 		return (ENOENT);
 
 	(void) fprintf(stderr, "dummy_get_file_info: not implemented");
 	abort();
 }
 
 int
 main(int argc, char **argv)
 {
 	int c;
 	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;
 	struct sigaction action;
 	boolean_t force_import = B_FALSE;
 	boolean_t config_path_console = B_FALSE;
 	char pbuf[MAXPATHLEN];
 
 	dprintf_setup(&argc, argv);
 
 	/*
 	 * Set up signal handlers, so if we crash due to bad on-disk data we
 	 * can get more info. Unlike ztest, we don't bail out if we can't set
 	 * up signal handlers, because zdb is very useful without them.
 	 */
 	action.sa_handler = sig_handler;
 	sigemptyset(&action.sa_mask);
 	action.sa_flags = 0;
 	if (sigaction(SIGSEGV, &action, NULL) < 0) {
 		(void) fprintf(stderr, "zdb: cannot catch SIGSEGV: %s\n",
 		    strerror(errno));
 	}
 	if (sigaction(SIGABRT, &action, NULL) < 0) {
 		(void) fprintf(stderr, "zdb: cannot catch SIGABRT: %s\n",
 		    strerror(errno));
 	}
 
 	/*
 	 * 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;
 
 	struct option long_options[] = {
 		{"ignore-assertions",	no_argument,		NULL, 'A'},
 		{"block-stats",		no_argument,		NULL, 'b'},
 		{"backup",		no_argument,		NULL, 'B'},
 		{"checksum",		no_argument,		NULL, 'c'},
 		{"config",		no_argument,		NULL, 'C'},
 		{"datasets",		no_argument,		NULL, 'd'},
 		{"dedup-stats",		no_argument,		NULL, 'D'},
 		{"exported",		no_argument,		NULL, 'e'},
 		{"embedded-block-pointer",	no_argument,	NULL, 'E'},
 		{"automatic-rewind",	no_argument,		NULL, 'F'},
 		{"dump-debug-msg",	no_argument,		NULL, 'G'},
 		{"history",		no_argument,		NULL, 'h'},
 		{"intent-logs",		no_argument,		NULL, 'i'},
 		{"inflight",		required_argument,	NULL, 'I'},
 		{"checkpointed-state",	no_argument,		NULL, 'k'},
 		{"key",			required_argument,	NULL, 'K'},
 		{"label",		no_argument,		NULL, 'l'},
 		{"disable-leak-tracking",	no_argument,	NULL, 'L'},
 		{"metaslabs",		no_argument,		NULL, 'm'},
 		{"metaslab-groups",	no_argument,		NULL, 'M'},
 		{"numeric",		no_argument,		NULL, 'N'},
 		{"option",		required_argument,	NULL, 'o'},
 		{"object-lookups",	no_argument,		NULL, 'O'},
 		{"path",		required_argument,	NULL, 'p'},
 		{"parseable",		no_argument,		NULL, 'P'},
 		{"skip-label",		no_argument,		NULL, 'q'},
 		{"copy-object",		no_argument,		NULL, 'r'},
 		{"read-block",		no_argument,		NULL, 'R'},
 		{"io-stats",		no_argument,		NULL, 's'},
 		{"simulate-dedup",	no_argument,		NULL, 'S'},
 		{"txg",			required_argument,	NULL, 't'},
 		{"brt-stats",		no_argument,		NULL, 'T'},
 		{"uberblock",		no_argument,		NULL, 'u'},
 		{"cachefile",		required_argument,	NULL, 'U'},
 		{"verbose",		no_argument,		NULL, 'v'},
 		{"verbatim",		no_argument,		NULL, 'V'},
 		{"dump-blocks",		required_argument,	NULL, 'x'},
 		{"extreme-rewind",	no_argument,		NULL, 'X'},
 		{"all-reconstruction",	no_argument,		NULL, 'Y'},
 		{"livelist",		no_argument,		NULL, 'y'},
 		{"zstd-headers",	no_argument,		NULL, 'Z'},
 		{0, 0, 0, 0}
 	};
 
 	while ((c = getopt_long(argc, argv,
 	    "AbBcCdDeEFGhiI:kK:lLmMNo:Op:PqrRsSt:TuU:vVx:XYyZ",
 	    long_options, NULL)) != -1) {
 		switch (c) {
 		case 'b':
 		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 'N':
 		case 'O':
 		case 'r':
 		case 'R':
 		case 's':
 		case 'S':
 		case 'T':
 		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 'K':
 			dump_opt[c]++;
 			key_material = strdup(optarg);
 			/* redact key material in process table */
 			while (*optarg != '\0') { *optarg++ = '*'; }
 			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);
 				memcpy(tmp, searchdirs, 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':
 			config_path_console = B_TRUE;
 			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 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 = 2ULL << SPA_MAXBLOCKSHIFT;
 	zfs_arc_max = 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;
 
 	/*
 	 * ZDB should have ability to read spacemaps.
 	 */
 	spa_mode_readable_spacemaps = B_TRUE;
 
 	if (dump_all)
 		verbose = MAX(verbose, 1);
 
 	for (c = 0; c < 256; c++) {
 		if (dump_all && strchr("ABeEFkKlLNOPrRSXy", c) == NULL)
 			dump_opt[c] = 1;
 		if (dump_opt[c])
 			dump_opt[c] += verbose;
 	}
 
 	libspl_set_assert_ok((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();
 
 	target = argv[0];
 
 	/*
 	 * Automate cachefile
 	 */
 	if (!spa_config_path_env && !config_path_console && target &&
 	    libzfs_core_init() == 0) {
 		char *pname = strdup(target);
 		const char *value;
 		nvlist_t *pnvl = NULL;
 		nvlist_t *vnvl = NULL;
 
 		if (strpbrk(pname, "/@") != NULL)
 			*strpbrk(pname, "/@") = '\0';
 
 		if (pname && lzc_get_props(pname, &pnvl) == 0) {
 			if (nvlist_lookup_nvlist(pnvl, "cachefile",
 			    &vnvl) == 0) {
 				value = fnvlist_lookup_string(vnvl,
 				    ZPROP_VALUE);
 			} else {
 				value = "-";
 			}
 			strlcpy(pbuf, value, sizeof (pbuf));
 			if (pbuf[0] != '\0') {
 				if (pbuf[0] == '/') {
 					if (access(pbuf, F_OK) == 0)
 						spa_config_path = pbuf;
 					else
 						force_import = B_TRUE;
 				} else if ((strcmp(pbuf, "-") == 0 &&
 				    access(ZPOOL_CACHE, F_OK) != 0) ||
 				    strcmp(pbuf, "none") == 0) {
 					force_import = B_TRUE;
 				}
 			}
 			nvlist_free(vnvl);
 		}
 
 		free(pname);
 		nvlist_free(pnvl);
 		libzfs_core_fini();
 	}
 
 	dmu_objset_register_type(DMU_OST_ZFS, dummy_get_file_info);
 	kernel_init(SPA_MODE_READ);
 	kernel_init_done = B_TRUE;
 
 	if (dump_opt['E']) {
 		if (argc != 1)
 			usage();
 		zdb_embedded_block(argv[0]);
 		error = 0;
 		goto fini;
 	}
 
 	if (argc < 1) {
 		if (!dump_opt['e'] && dump_opt['C']) {
 			dump_cachefile(spa_config_path);
 			error = 0;
 			goto fini;
 		}
 		usage();
 	}
 
 	if (dump_opt['l']) {
 		error = dump_label(argv[0]);
 		goto fini;
 	}
 
 	if (dump_opt['X'] || dump_opt['F'])
 		rewind = ZPOOL_DO_REWIND |
 		    (dump_opt['X'] ? ZPOOL_EXTREME_REWIND : 0);
 
 	/* -N implies -d */
 	if (dump_opt['N'] && dump_opt['d'] == 0)
 		dump_opt['d'] = dump_opt['N'];
 
 	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;
 
 	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';
 
 		/*
 		 * See if an objset ID was supplied (-d <pool>/<objset ID>).
 		 * To disambiguate tank/100, consider the 100 as objsetID
 		 * if -N was given, otherwise 100 is an objsetID iff
 		 * tank/100 as a named dataset fails on lookup.
 		 */
 		objset_str = strchr(target, '/');
 		if (objset_str && strlen(objset_str) > 1 &&
 		    zdb_numeric(objset_str + 1)) {
 			char *endptr;
 			errno = 0;
 			objset_str++;
 			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) {
 				if (dump_opt['N'])
 					dataset_lookup = B_TRUE;
 			}
 			/* normal dataset name not an objset ID */
 			if (endptr == objset_str) {
 				objset_id = -1;
 			}
 		} else if (objset_str && !zdb_numeric(objset_str + 1) &&
 		    dump_opt['N']) {
 			printf("Supply a numeric objset ID with -N\n");
 			error = 1;
 			goto fini;
 		}
 	} else {
 		target_pool = target;
 	}
 
 	if (dump_opt['e'] || force_import) {
 		importargs_t args = { 0 };
 
 		/*
 		 * If path is not provided, search in /dev
 		 */
 		if (searchdirs == NULL) {
 			searchdirs = umem_alloc(sizeof (char *), UMEM_NOFAIL);
 			searchdirs[nsearch++] = (char *)ZFS_DEVDIR;
 		}
 
 		args.paths = nsearch;
 		args.path = searchdirs;
 		args.can_be_active = B_TRUE;
 
 		libpc_handle_t lpch = {
 			.lpc_lib_handle = NULL,
 			.lpc_ops = &libzpool_config_ops,
 			.lpc_printerr = B_TRUE
 		};
 		error = zpool_find_config(&lpch, target_pool, &cfg, &args);
 
 		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;
 	}
 
 	/*
 	 * We need to make sure to process -O option or call
 	 * dump_path after the -e option has been processed,
 	 * which imports the pool to the namespace if it's
 	 * not in the cachefile.
 	 */
 	if (dump_opt['O']) {
 		if (argc != 2)
 			usage();
 		dump_opt['v'] = verbose + 3;
 		error = dump_path(argv[0], argv[1], NULL);
 		goto fini;
 	}
 
 	if (dump_opt['r']) {
 		target_is_spa = B_FALSE;
 		if (argc != 3)
 			usage();
 		dump_opt['v'] = verbose;
 		error = dump_path(argv[0], argv[1], &object);
 		if (error != 0)
 			fatal("internal error: %s", strerror(error));
 	}
 
 	/*
 	 * 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'] || dump_opt['B'] ||
 		    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));
 			}
 			goto fini;
 		} else {
 			target_pool = strdup(target);
 			if (strpbrk(target, "/@") != NULL)
 				*strpbrk(target_pool, "/@") = '\0';
 
 			zdb_set_skip_mmp(target);
 			/*
 			 * If -N was supplied, the user has indicated that
 			 * zdb -d <pool>/<objsetID> is in effect.  Otherwise
 			 * we first assume that the dataset string is the
 			 * dataset name.  If dmu_objset_hold fails with the
 			 * dataset string, and we have an objset_id, retry the
 			 * lookup with the objsetID.
 			 */
 			boolean_t retry = B_TRUE;
 retry_lookup:
 			if (dataset_lookup == B_TRUE) {
 				/*
 				 * Use the supplied id to get the name
 				 * for open_objset.
 				 */
 				error = spa_open(target_pool, &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) {
 				if (objset_id > 0 && retry) {
 					int err = dmu_objset_hold(target, FTAG,
 					    &os);
 					if (err) {
 						dataset_lookup = B_TRUE;
 						retry = B_FALSE;
 						goto retry_lookup;
 					} else {
 						dmu_objset_rele(os, FTAG);
 					}
 				}
 				error = open_objset(target, FTAG, &os);
 			}
 			if (error == 0)
 				spa = dmu_objset_spa(os);
 			free(target_pool);
 		}
 	}
 	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;
 				const 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 ?: "");
 			}
 		} 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 (dump_opt['B']) {
 			dump_backup(target, objset_id,
 			    argc > 0 ? argv[0] : NULL);
 		} else 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);
 	}
 
 fini:
 	if (spa != NULL)
 		zdb_ddt_cleanup(spa);
 
 	if (os != NULL) {
 		close_objset(os, FTAG);
 	} else if (spa != NULL) {
 		spa_close(spa, FTAG);
 	}
 
 	fuid_table_destroy();
 
 	dump_debug_buffer();
 
 	if (kernel_init_done)
 		kernel_fini();
 
 	return (error);
 }
diff --git a/sys/contrib/openzfs/cmd/zfs/zfs_main.c b/sys/contrib/openzfs/cmd/zfs/zfs_main.c
index 34c693fbcb0f..4116cdb51852 100644
--- a/sys/contrib/openzfs/cmd/zfs/zfs_main.c
+++ b/sys/contrib/openzfs/cmd/zfs/zfs_main.c
@@ -1,9360 +1,9380 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 
 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * 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 <string.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <zone.h>
 #include <grp.h>
 #include <pwd.h>
 #include <umem.h>
 #include <pthread.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 "zfs_projectutil.h"
 
 libzfs_handle_t *g_zfs;
 
 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
 
 #ifdef __linux__
 static int zfs_do_zone(int argc, char **argv);
 static int zfs_do_unzone(int argc, char **argv);
 #endif
 
 static int zfs_do_help(int argc, char **argv);
 
 enum zfs_options {
 	ZFS_OPTION_JSON_NUMS_AS_INT = 1024
 };
 
 /*
  * 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,
 	HELP_ZONE,
 	HELP_UNZONE,
 } 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
 
 #ifdef __linux__
 	{ "zone",	zfs_do_zone,		HELP_ZONE		},
 	{ "unzone",	zfs_do_unzone,		HELP_UNZONE		},
 #endif
 };
 
 #define	NCOMMAND	(sizeof (command_table) / sizeof (command_table[0]))
 
 #define	MAX_CMD_LEN	256
 
 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] [-j [--json-int]] [-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] [-j [--json-int]] [-r|-d max] "
 		    "[-o property[,...]] [-s property]...\n\t    "
 		    "[-S property]... [-t type[,...]] "
 		    "[filesystem|volume|snapshot] ...\n"));
 	case HELP_MOUNT:
 		return (gettext("\tmount [-j]\n"
 		    "\tmount [-flvO] [-o opts] <-a|-R filesystem|"
 		    "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 [-DLPbcehnpsVvw] "
 		    "[-i|-I snapshot]\n"
 		    "\t     [-R [-X dataset[,dataset]...]]     <snapshot>\n"
 		    "\tsend [-DnVvPLecw] [-i snapshot|bookmark] "
 		    "<filesystem|volume|snapshot>\n"
 		    "\tsend [-DnPpVvLec] [-i bookmark|snapshot] "
 		    "--redact <bookmark> <snapshot>\n"
 		    "\tsend [-nVvPe] -t <receive_resume_token>\n"
 		    "\tsend [-PnVv] --saved filesystem\n"));
 	case HELP_SET:
 		return (gettext("\tset [-u] <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 [-rHp] <snapshot> ...\n"));
 	case HELP_RELEASE:
 		return (gettext("\trelease [-r] <tag> <snapshot> ...\n"));
 	case HELP_DIFF:
 		return (gettext("\tdiff [-FHth] <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 [-j]\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"));
 	case HELP_ZONE:
 		return (gettext("\tzone <nsfile> <filesystem>\n"));
 	case HELP_UNZONE:
 		return (gettext("\tunzone <nsfile> <filesystem>\n"));
 	default:
 		__builtin_unreachable();
 	}
 }
 
 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(const 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   ");
 
 	(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 __attribute__((noreturn)) 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, "%s",
 		    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, "%s", 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");
 		(void) fprintf(fp,
 		    gettext("\nFor further help on a command or topic, "
 		    "run: %s\n"), "zfs help [<topic>]");
 	}
 
 	/*
 	 * 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 const 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(const 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(const 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(const char *done)
 {
 	if (pt_shown) {
 		(void) puts(done);
 		(void) fflush(stdout);
 	}
 	free(pt_header);
 	pt_header = NULL;
 }
 
 static int
 zfs_mount_and_share(libzfs_handle_t *hdl, const char *dataset, zfs_type_t type)
 {
 	zfs_handle_t *zhp = NULL;
 	int ret = 0;
 
 	zhp = zfs_open(hdl, dataset, type);
 	if (zhp == NULL)
 		return (1);
 
 	/*
 	 * Volumes may neither be mounted or shared.  Potentially in the
 	 * future filesystems detected on these volumes could be mounted.
 	 */
 	if (zfs_get_type(zhp) == ZFS_TYPE_VOLUME) {
 		zfs_close(zhp);
 		return (0);
 	}
 
 	/*
 	 * Mount and/or share the new filesystem as appropriate.  We provide a
 	 * verbose error message to let the user know that their filesystem was
 	 * in fact created, even if we failed to mount or share it.
 	 *
 	 * If the user doesn't want the dataset automatically mounted, then
 	 * skip the mount/share step
 	 */
 	if (zfs_prop_valid_for_type(ZFS_PROP_CANMOUNT, type, B_FALSE) &&
 	    zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) == ZFS_CANMOUNT_ON) {
 		if (zfs_mount_delegation_check()) {
 			(void) fprintf(stderr, gettext("filesystem "
 			    "successfully created, but it may only be "
 			    "mounted by root\n"));
 			ret = 1;
 		} else if (zfs_mount(zhp, NULL, 0) != 0) {
 			(void) fprintf(stderr, gettext("filesystem "
 			    "successfully created, but not mounted\n"));
 			ret = 1;
 		} else if (zfs_share(zhp, NULL) != 0) {
 			(void) fprintf(stderr, gettext("filesystem "
 			    "successfully created, but not shared\n"));
 			ret = 1;
 		}
 		zfs_commit_shares(NULL);
 	}
 
 	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;
 	const 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) {
 			char *tmp;
 			if (asprintf(&tmp, "%llu",
 			    (u_longlong_t)volblocksize) == -1)
 				nomem();
 			nvlist_add_string(props, prop, tmp);
 			free(tmp);
 		}
 
 		/*
 		 * 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;
 			const 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);
 			if (error != 0) {
 				zfs_close(zhp);
 				return (-1);
 			}
 		}
 	} 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_v2(fs_zhp, 0, 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_v2(zhp, 0, 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_v2(zhp, 0, 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_v2(zhp, 0, 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_v2(zhp, 0, 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_v2(zhp, 0, 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_v2(zhp, 0, 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);
 }
 
 /*
  * Generates an nvlist with output version for every command based on params.
  * Purpose of this is to add a version of JSON output, considering the schema
  * format might be updated for each command in future.
  *
  * Schema:
  *
  * "output_version": {
  *    "command": string,
  *    "vers_major": integer,
  *    "vers_minor": integer,
  *  }
  */
 static nvlist_t *
 zfs_json_schema(int maj_v, int min_v)
 {
 	nvlist_t *sch = NULL;
 	nvlist_t *ov = NULL;
 	char cmd[MAX_CMD_LEN];
 	snprintf(cmd, MAX_CMD_LEN, "zfs %s", current_command->name);
 
 	sch = fnvlist_alloc();
 	ov = fnvlist_alloc();
 	fnvlist_add_string(ov, "command", cmd);
 	fnvlist_add_uint32(ov, "vers_major", maj_v);
 	fnvlist_add_uint32(ov, "vers_minor", min_v);
 	fnvlist_add_nvlist(sch, "output_version", ov);
 	fnvlist_free(ov);
 	return (sch);
 }
 
 static void
 fill_dataset_info(nvlist_t *list, zfs_handle_t *zhp, boolean_t as_int)
 {
 	char createtxg[ZFS_MAXPROPLEN];
 	zfs_type_t type = zfs_get_type(zhp);
 	nvlist_add_string(list, "name", zfs_get_name(zhp));
 
 	switch (type) {
 	case ZFS_TYPE_FILESYSTEM:
 		fnvlist_add_string(list, "type", "FILESYSTEM");
 		break;
 	case ZFS_TYPE_VOLUME:
 		fnvlist_add_string(list, "type", "VOLUME");
 		break;
 	case ZFS_TYPE_SNAPSHOT:
 		fnvlist_add_string(list, "type", "SNAPSHOT");
 		break;
 	case ZFS_TYPE_POOL:
 		fnvlist_add_string(list, "type", "POOL");
 		break;
 	case ZFS_TYPE_BOOKMARK:
 		fnvlist_add_string(list, "type", "BOOKMARK");
 		break;
 	default:
 		fnvlist_add_string(list, "type", "UNKNOWN");
 		break;
 	}
 
 	if (type != ZFS_TYPE_POOL)
 		fnvlist_add_string(list, "pool", zfs_get_pool_name(zhp));
 
 	if (as_int) {
 		fnvlist_add_uint64(list, "createtxg", zfs_prop_get_int(zhp,
 		    ZFS_PROP_CREATETXG));
 	} else {
 		if (zfs_prop_get(zhp, ZFS_PROP_CREATETXG, createtxg,
 		    sizeof (createtxg), NULL, NULL, 0, B_TRUE) == 0)
 			fnvlist_add_string(list, "createtxg", createtxg);
 	}
 
 	if (type == ZFS_TYPE_SNAPSHOT) {
 		char *ds, *snap;
 		ds = snap = strdup(zfs_get_name(zhp));
 		ds = strsep(&snap, "@");
 		fnvlist_add_string(list, "dataset", ds);
 		fnvlist_add_string(list, "snapshot_name", snap);
 		free(ds);
 	}
 }
 
 /*
  * zfs get [-rHp] [-j [--json-int]] [-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.
  *	-j	Display output in JSON format.
  *	--json-int	Display numbers as integers instead of strings.
  *
  *  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;
 	nvlist_t *item, *d, *props;
 	item = d = props = NULL;
 	const char *strval;
 	const char *sourceval;
 	boolean_t received = is_recvd_column(cbp);
 	int err = 0;
 
 	if (cbp->cb_json) {
 		d = fnvlist_lookup_nvlist(cbp->cb_jsobj, "datasets");
 		if (d == NULL) {
 			fprintf(stderr, "datasets obj not found.\n");
 			exit(1);
 		}
 		props = fnvlist_alloc();
 	}
 
 	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_USERPROP) {
 			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;
 
 			err = zprop_collect_property(zfs_get_name(zhp), cbp,
 			    zfs_prop_to_name(pl->pl_prop),
 			    buf, sourcetype, source, recvdval, props);
 		} 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));
 			}
 
 			err = zprop_collect_property(zfs_get_name(zhp), cbp,
 			    pl->pl_user_prop, buf, sourcetype, source, NULL,
 			    props);
 		} 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));
 			}
 
 			err = zprop_collect_property(zfs_get_name(zhp), cbp,
 			    pl->pl_user_prop, buf, sourcetype, source, NULL,
 			    props);
 		} else {
 			if (nvlist_lookup_nvlist(user_props,
 			    pl->pl_user_prop, &propval) != 0) {
 				if (pl->pl_all)
 					continue;
 				sourcetype = ZPROP_SRC_NONE;
 				strval = "-";
 			} else {
 				strval = fnvlist_lookup_string(propval,
 				    ZPROP_VALUE);
 				sourceval = fnvlist_lookup_string(propval,
 				    ZPROP_SOURCE);
 
 				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;
 
 			err = zprop_collect_property(zfs_get_name(zhp), cbp,
 			    pl->pl_user_prop, strval, sourcetype,
 			    source, recvdval, props);
 		}
 		if (err != 0)
 			return (err);
 	}
 
 	if (cbp->cb_json) {
 		if (!nvlist_empty(props)) {
 			item = fnvlist_alloc();
 			fill_dataset_info(item, zhp, cbp->cb_json_as_int);
 			fnvlist_add_nvlist(item, "properties", props);
 			fnvlist_add_nvlist(d, zfs_get_name(zhp), item);
 			fnvlist_free(props);
 			fnvlist_free(item);
 		} else {
 			fnvlist_free(props);
 		}
 	}
 
 	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 *fields;
 	int ret = 0;
 	int limit = 0;
 	zprop_list_t fake_name = { 0 };
 	nvlist_t *data;
 
 	/*
 	 * 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;
 
 	struct option long_options[] = {
+		{"json", no_argument, NULL, 'j'},
 		{"json-int", no_argument, NULL, ZFS_OPTION_JSON_NUMS_AS_INT},
 		{0, 0, 0, 0}
 	};
 
 	/* check options */
 	while ((c = getopt_long(argc, argv, ":d:o:s:jrt:Hp", long_options,
 	    NULL)) != -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 'j':
 			cb.cb_json = B_TRUE;
 			cb.cb_jsobj = zfs_json_schema(0, 1);
 			data = fnvlist_alloc();
 			fnvlist_add_nvlist(cb.cb_jsobj, "datasets", data);
 			fnvlist_free(data);
 			break;
 		case ZFS_OPTION_JSON_NUMS_AS_INT:
 			cb.cb_json_as_int = B_TRUE;
 			cb.cb_literal = 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.
 			 */
 			memset(&cb.cb_columns, 0, sizeof (cb.cb_columns));
 
 			i = 0;
 			for (char *tok; (tok = strsep(&optarg, ",")); ) {
 				static const char *const col_subopts[] =
 				{ "name", "property", "value",
 				    "received", "source", "all" };
 				static const zfs_get_column_t col_subopt_col[] =
 				{ GET_COL_NAME, GET_COL_PROPERTY, GET_COL_VALUE,
 				    GET_COL_RECVD, GET_COL_SOURCE };
 				static const int col_subopt_flags[] =
 				{ 0, 0, 0, ZFS_ITER_RECVD_PROPS, 0 };
 
 				if (i == ZFS_GET_NCOLS) {
 					(void) fprintf(stderr, gettext("too "
 					    "many fields given to -o "
 					    "option\n"));
 					usage(B_FALSE);
 				}
 
 				for (c = 0; c < ARRAY_SIZE(col_subopts); ++c)
 					if (strcmp(tok, col_subopts[c]) == 0)
 						goto found;
 
 				(void) fprintf(stderr,
 				    gettext("invalid column name '%s'\n"), tok);
 				usage(B_FALSE);
 
 found:
 				if (c >= 5) {
 					if (i > 0) {
 						(void) fprintf(stderr,
 						    gettext("\"all\" conflicts "
 						    "with specific fields "
 						    "given to -o option\n"));
 						usage(B_FALSE);
 					}
 
 					memcpy(cb.cb_columns, col_subopt_col,
 					    sizeof (col_subopt_col));
 					flags |= ZFS_ITER_RECVD_PROPS;
 					i = ZFS_GET_NCOLS;
 				} else {
 					cb.cb_columns[i++] = col_subopt_col[c];
 					flags |= col_subopt_flags[c];
 				}
 			}
 			break;
 
 		case 's':
 			cb.cb_sources = 0;
 
 			for (char *tok; (tok = strsep(&optarg, ",")); ) {
 				static const char *const source_opt[] = {
 					"local", "default",
 					"inherited", "received",
 					"temporary", "none" };
 				static const int source_flg[] = {
 					ZPROP_SRC_LOCAL, ZPROP_SRC_DEFAULT,
 					ZPROP_SRC_INHERITED, ZPROP_SRC_RECEIVED,
 					ZPROP_SRC_TEMPORARY, ZPROP_SRC_NONE };
 
 				for (i = 0; i < ARRAY_SIZE(source_opt); ++i)
 					if (strcmp(tok, source_opt[i]) == 0) {
 						cb.cb_sources |= source_flg[i];
 						goto found2;
 					}
 
 				(void) fprintf(stderr,
 				    gettext("invalid source '%s'\n"), tok);
 				usage(B_FALSE);
 found2:;
 			}
 			break;
 
 		case 't':
 			types = 0;
 			flags &= ~ZFS_ITER_PROP_LISTSNAPS;
 
 			for (char *tok; (tok = strsep(&optarg, ",")); ) {
 				static const char *const type_opts[] = {
 					"filesystem",
 					"fs",
 					"volume",
 					"vol",
 					"snapshot",
 					"snap",
 					"bookmark",
 					"all"
 				};
 				static const int type_types[] = {
 					ZFS_TYPE_FILESYSTEM,
 					ZFS_TYPE_FILESYSTEM,
 					ZFS_TYPE_VOLUME,
 					ZFS_TYPE_VOLUME,
 					ZFS_TYPE_SNAPSHOT,
 					ZFS_TYPE_SNAPSHOT,
 					ZFS_TYPE_BOOKMARK,
 					ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK
 				};
 
 				for (i = 0; i < ARRAY_SIZE(type_opts); ++i)
 					if (strcmp(tok, type_opts[i]) == 0) {
 						types |= type_types[i];
 						goto found3;
 					}
 
 				(void) fprintf(stderr,
 				    gettext("invalid type '%s'\n"), tok);
 				usage(B_FALSE);
 found3:;
 			}
 			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 (!cb.cb_json && cb.cb_json_as_int) {
 		(void) fprintf(stderr, gettext("'--json-int' only works with"
 		    " '-j' option\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 (ret == 0 && cb.cb_json)
 		zcmd_print_json(cb.cb_jsobj);
 	else if (ret != 0 && cb.cb_json)
 		nvlist_free(cb.cb_jsobj);
 
 	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_USERPROP) {
 		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[24];
 		(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) strlcpy(cb->cb_lastfs, zfs_get_name(zhp),
 		    sizeof (cb->cb_lastfs));
 	} 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 const char *const us_field_hdr[] = { "TYPE", "NAME", "USED", "QUOTA",
 				    "OBJUSED", "OBJQUOTA" };
 static const char *const 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 const char *const 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(const char *field)
 {
 	for (int 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) {
 		const char *lvstr = "";
 		const 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;
 	const 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 = -1;
 		uint64_t val64 = -1;
 		const 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:
 			val32 = fnvpair_value_uint32(nvp);
 			break;
 		case DATA_TYPE_UINT64:
 			val64 = fnvpair_value_uint64(nvp);
 			break;
 		case DATA_TYPE_STRING:
 			strval = fnvpair_value_string(nvp);
 			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 = 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) putchar('\t');
 			else
 				(void) fputs("  ", stdout);
 		}
 		if (scripted)
 			(void) fputs(strval, stdout);
 		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) putchar('\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 (zfs_get_underlying_type(zhp) != 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;
 	boolean_t	cb_json;
 	nvlist_t	*cb_jsobj;
 	boolean_t	cb_json_as_int;
 } 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;
 
 	color_start(ANSI_BOLD);
 
 	for (; pl != NULL; pl = pl->pl_next) {
 		if (!first) {
 			(void) printf("  ");
 		} else {
 			first = B_FALSE;
 		}
 
 		right_justify = B_FALSE;
 		if (pl->pl_prop != ZPROP_USERPROP) {
 			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);
 	}
 
 	color_end();
 
 	(void) printf("\n");
 }
 
 /*
  * Decides on the color that the avail value should be printed in.
  * > 80% used = yellow
  * > 90% used = red
  */
 static const char *
 zfs_list_avail_color(zfs_handle_t *zhp)
 {
 	uint64_t used = zfs_prop_get_int(zhp, ZFS_PROP_USED);
 	uint64_t avail = zfs_prop_get_int(zhp, ZFS_PROP_AVAILABLE);
 	int percentage = (int)((double)avail / MAX(avail + used, 1) * 100);
 
 	if (percentage > 20)
 		return (NULL);
 	else if (percentage > 10)
 		return (ANSI_YELLOW);
 	else
 		return (ANSI_RED);
 }
 
 /*
  * Given a dataset and a list of fields, print out all the properties according
  * to the described layout, or return an nvlist containing all the fields, later
  * to be printed out as JSON object.
  */
 static void
 collect_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;
 	const char *propstr;
 	boolean_t right_justify;
 	nvlist_t *item, *d, *props;
 	item = d = props = NULL;
 	zprop_source_t sourcetype = ZPROP_SRC_NONE;
 	char source[ZFS_MAX_DATASET_NAME_LEN];
 	if (cb->cb_json) {
 		d = fnvlist_lookup_nvlist(cb->cb_jsobj, "datasets");
 		if (d == NULL) {
 			fprintf(stderr, "datasets obj not found.\n");
 			exit(1);
 		}
 		item = fnvlist_alloc();
 		props = fnvlist_alloc();
 		fill_dataset_info(item, zhp, cb->cb_json_as_int);
 	}
 
 	for (; pl != NULL; pl = pl->pl_next) {
 		if (!cb->cb_json && !first) {
 			if (cb->cb_scripted)
 				(void) putchar('\t');
 			else
 				(void) fputs("  ", stdout);
 		} 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_USERPROP) {
 			if (zfs_prop_get(zhp, pl->pl_prop, property,
 			    sizeof (property), &sourcetype, source,
 			    sizeof (source), 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)) {
 			sourcetype = ZPROP_SRC_LOCAL;
 			if (zfs_prop_get_userquota(zhp, pl->pl_user_prop,
 			    property, sizeof (property), cb->cb_literal) != 0) {
 				sourcetype = ZPROP_SRC_NONE;
 				propstr = "-";
 			} else {
 				propstr = property;
 			}
 			right_justify = B_TRUE;
 		} else if (zfs_prop_written(pl->pl_user_prop)) {
 			sourcetype = ZPROP_SRC_LOCAL;
 			if (zfs_prop_get_written(zhp, pl->pl_user_prop,
 			    property, sizeof (property), cb->cb_literal) != 0) {
 				sourcetype = ZPROP_SRC_NONE;
 				propstr = "-";
 			} else {
 				propstr = property;
 			}
 			right_justify = B_TRUE;
 		} else {
 			if (nvlist_lookup_nvlist(userprops,
 			    pl->pl_user_prop, &propval) != 0) {
 				propstr = "-";
 			} else {
 				propstr = fnvlist_lookup_string(propval,
 				    ZPROP_VALUE);
 				strlcpy(source,
 				    fnvlist_lookup_string(propval,
 				    ZPROP_SOURCE), ZFS_MAX_DATASET_NAME_LEN);
 				if (strcmp(source,
 				    zfs_get_name(zhp)) == 0) {
 					sourcetype = ZPROP_SRC_LOCAL;
 				} else if (strcmp(source,
 				    ZPROP_SOURCE_VAL_RECVD) == 0) {
 					sourcetype = ZPROP_SRC_RECEIVED;
 				} else {
 					sourcetype = ZPROP_SRC_INHERITED;
 				}
 			}
 			right_justify = B_FALSE;
 		}
 
 		if (cb->cb_json) {
 			if (pl->pl_prop == ZFS_PROP_NAME)
 				continue;
 			if (zprop_nvlist_one_property(
 			    zfs_prop_to_name(pl->pl_prop), propstr,
 			    sourcetype, source, NULL, props,
 			    cb->cb_json_as_int) != 0)
 				nomem();
 		} else {
 			/*
 			 * zfs_list_avail_color() needs
 			 * ZFS_PROP_AVAILABLE + USED, so we need another
 			 * for() search for the USED part when no colors
 			 * wanted, we can skip the whole thing
 			 */
 			if (use_color() && pl->pl_prop == ZFS_PROP_AVAILABLE) {
 				zprop_list_t *pl2 = cb->cb_proplist;
 				for (; pl2 != NULL; pl2 = pl2->pl_next) {
 					if (pl2->pl_prop == ZFS_PROP_USED) {
 						color_start(
 						    zfs_list_avail_color(zhp));
 						/*
 						 * found it, no need for more
 						 * loops
 						 */
 						break;
 					}
 				}
 			}
 
 			/*
 			 * 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) fputs(propstr, stdout);
 			else if (right_justify) {
 				(void) printf("%*s", (int)pl->pl_width,
 				    propstr);
 			} else {
 				(void) printf("%-*s", (int)pl->pl_width,
 				    propstr);
 			}
 
 			if (pl->pl_prop == ZFS_PROP_AVAILABLE)
 				color_end();
 		}
 	}
 	if (cb->cb_json) {
 		fnvlist_add_nvlist(item, "properties", props);
 		fnvlist_add_nvlist(d, zfs_get_name(zhp), item);
 		fnvlist_free(props);
 		fnvlist_free(item);
 	} else
 		(void) putchar('\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 && !cbp->cb_json)
 			print_header(cbp);
 		cbp->cb_first = B_FALSE;
 	}
 
 	collect_dataset(zhp, cbp);
 
 	return (0);
 }
 
 static int
 zfs_do_list(int argc, char **argv)
 {
 	int c;
 	char default_fields[] =
 	    "name,used,available,referenced,mountpoint";
 	int types = ZFS_TYPE_DATASET;
 	boolean_t types_specified = B_FALSE;
 	char *fields = default_fields;
 	list_cbdata_t cb = { 0 };
 	int limit = 0;
 	int ret = 0;
 	zfs_sort_column_t *sortcol = NULL;
 	int flags = ZFS_ITER_PROP_LISTSNAPS | ZFS_ITER_ARGS_CAN_BE_PATHS;
 	nvlist_t *data = NULL;
 
 	struct option long_options[] = {
+		{"json", no_argument, NULL, 'j'},
 		{"json-int", no_argument, NULL, ZFS_OPTION_JSON_NUMS_AS_INT},
 		{0, 0, 0, 0}
 	};
 
 	/* check options */
 	while ((c = getopt_long(argc, argv, "jHS:d:o:prs:t:", long_options,
 	    NULL)) != -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 'j':
 			cb.cb_json = B_TRUE;
 			cb.cb_jsobj = zfs_json_schema(0, 1);
 			data = fnvlist_alloc();
 			fnvlist_add_nvlist(cb.cb_jsobj, "datasets", data);
 			fnvlist_free(data);
 			break;
 		case ZFS_OPTION_JSON_NUMS_AS_INT:
 			cb.cb_json_as_int = B_TRUE;
 			cb.cb_literal = B_TRUE;
 			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;
 
 			for (char *tok; (tok = strsep(&optarg, ",")); ) {
 				static const char *const type_subopts[] = {
 					"filesystem",
 					"fs",
 					"volume",
 					"vol",
 					"snapshot",
 					"snap",
 					"bookmark",
 					"all"
 				};
 				static const int type_types[] = {
 					ZFS_TYPE_FILESYSTEM,
 					ZFS_TYPE_FILESYSTEM,
 					ZFS_TYPE_VOLUME,
 					ZFS_TYPE_VOLUME,
 					ZFS_TYPE_SNAPSHOT,
 					ZFS_TYPE_SNAPSHOT,
 					ZFS_TYPE_BOOKMARK,
 					ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK
 				};
 
 				for (c = 0; c < ARRAY_SIZE(type_subopts); ++c)
 					if (strcmp(tok, type_subopts[c]) == 0) {
 						types |= type_types[c];
 						goto found3;
 					}
 
 				(void) fprintf(stderr,
 				    gettext("invalid type '%s'\n"), tok);
 				usage(B_FALSE);
 found3:;
 			}
 			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 (!cb.cb_json && cb.cb_json_as_int) {
 		(void) fprintf(stderr, gettext("'--json-int' only works with"
 		    " '-j' option\n"));
 		usage(B_FALSE);
 	}
 
 	/*
 	 * 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;
 
 	/*
 	 * If we are only going to list and sort by properties that are "fast"
 	 * then we can use "simple" mode and avoid populating the properties
 	 * nvlist.
 	 */
 	if (zfs_list_only_by_fast(cb.cb_proplist) &&
 	    zfs_sort_only_by_fast(sortcol))
 		flags |= ZFS_ITER_SIMPLE;
 
 	ret = zfs_for_each(argc, argv, flags, types, sortcol, &cb.cb_proplist,
 	    limit, list_callback, &cb);
 
 	if (ret == 0 && cb.cb_json)
 		zcmd_print_json(cb.cb_jsobj);
 	else if (ret != 0 && cb.cb_json)
 		nvlist_free(cb.cb_jsobj);
 
 	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.
  */
 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
  */
 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: {
 		zfs_handle_t *zhp = zfs_open(g_zfs, snap, ZFS_TYPE_SNAPSHOT);
 		if (zhp == NULL) {
 			(void) fprintf(stderr, gettext("provided snapshot %s "
 			    "does not exist\n"), snap);
 		} else {
 			zfs_close(zhp);
 		}
 		for (int i = 0; i < numrsnaps; i++) {
 			zhp = zfs_open(g_zfs, rsnaps[i], ZFS_TYPE_SNAPSHOT);
 			if (zhp == NULL) {
 				(void) fprintf(stderr, gettext("provided "
 				    "snapshot %s does not exist\n"), rsnaps[i]);
 			} else {
 				zfs_close(zhp);
 			}
 		}
 		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;
 	case ESRCH:
 		(void) fprintf(stderr, gettext("attempted to resume redaction "
 		    " with a mismatched redaction list\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_v2(zhp, 0, 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_v2(zhp, 0, rollback_check, &cb,
 	    min_txg, 0)) != 0)
 		goto out;
 	if ((ret = zfs_iter_bookmarks_v2(zhp, 0, 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)
 {
 	zprop_set_cbdata_t *cb = data;
 	int ret = zfs_prop_set_list_flags(zhp, cb->cb_proplist, cb->cb_flags);
 
 	if (ret != 0 || libzfs_errno(g_zfs) != EZFS_SUCCESS) {
 		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 (ret);
 }
 
 static int
 zfs_do_set(int argc, char **argv)
 {
 	zprop_set_cbdata_t cb = { 0 };
 	int ds_start = -1; /* argv idx of first dataset arg */
 	int ret = 0;
 	int i, c;
 
 	/* check options */
 	while ((c = getopt(argc, argv, "u")) != -1) {
 		switch (c) {
 		case 'u':
 			cb.cb_flags |= ZFS_SET_NOMOUNT;
 			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 arguments\n"));
 		usage(B_FALSE);
 	}
 	if (argc < 2) {
 		if (strchr(argv[0], '=') == 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 = 0; 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(&cb.cb_proplist, NV_UNIQUE_NAME, 0) != 0)
 		nomem();
 	for (i = 0; i < ds_start; i++) {
 		if (!parseprop(cb.cb_proplist, 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, &cb);
 
 error:
 	nvlist_free(cb.cb_proplist);
 	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_v2(zhp, 0, 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);
 }
 
 /*
  * Array of prefixes to exclude –
  * a linear search, even if executed for each dataset,
  * is plenty good enough.
  */
 typedef struct zfs_send_exclude_arg {
 	size_t count;
 	const char **list;
 } zfs_send_exclude_arg_t;
 
 static boolean_t
 zfs_do_send_exclude(zfs_handle_t *zhp, void *context)
 {
 	zfs_send_exclude_arg_t *excludes = context;
 	const char *name = zfs_get_name(zhp);
 
 	for (size_t i = 0; i < excludes->count; ++i) {
 		size_t len = strlen(excludes->list[i]);
 		if (strncmp(name, excludes->list[i], len) == 0 &&
 		    memchr("/@", name[len], sizeof ("/@")))
 			return (B_FALSE);
 	}
 
 	return (B_TRUE);
 }
 
 /*
  * 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;
 	zfs_send_exclude_arg_t excludes = { 0 };
 
 	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'},
 		{"proctitle",	no_argument,		NULL, 'V'},
 		{"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'},
 		{"exclude",	required_argument,	NULL, 'X'},
 		{0, 0, 0, 0}
 	};
 
 	/* check options */
 	while ((c = getopt_long(argc, argv, ":i:I:RsDpVvnPLeht:cwbd:SX:",
 	    long_options, NULL)) != -1) {
 		switch (c) {
 		case 'X':
 			for (char *ds; (ds = strsep(&optarg, ",")) != NULL; ) {
 				if (!zfs_name_valid(ds, ZFS_TYPE_DATASET) ||
 				    strchr(ds, '/') == NULL) {
 					(void) fprintf(stderr, gettext("-X %s: "
 					    "not a valid non-root dataset name"
 					    ".\n"), ds);
 					usage(B_FALSE);
 				}
 				excludes.list = safe_realloc(excludes.list,
 				    sizeof (char *) * (excludes.count + 1));
 				excludes.list[excludes.count++] = ds;
 			}
 			break;
 		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.progressastitle = 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]);
 			}
 			free(excludes.list);
 			usage(B_FALSE);
 			break;
 		case '?':
 		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]);
 
 			}
 			free(excludes.list);
 			usage(B_FALSE);
 		}
 	}
 
 	if ((flags.parsable || flags.progressastitle) && flags.verbosity == 0)
 		flags.verbosity = 1;
 
 	if (excludes.count > 0 && !flags.replicate) {
 		free(excludes.list);
 		(void) fprintf(stderr, gettext("Cannot specify "
 		    "dataset exclusion (-X) on a non-recursive "
 		    "send.\n"));
 		return (1);
 	}
 
 	argc -= optind;
 	argv += optind;
 
 	if (resume_token != NULL) {
 		if (fromname != NULL || flags.replicate || flags.props ||
 		    flags.backup || flags.holds ||
 		    flags.saved || redactbook != NULL) {
 			free(excludes.list);
 			(void) fprintf(stderr,
 			    gettext("invalid flags combined with -t\n"));
 			usage(B_FALSE);
 		}
 		if (argc > 0) {
 			free(excludes.list);
 			(void) fprintf(stderr, gettext("too many arguments\n"));
 			usage(B_FALSE);
 		}
 	} else {
 		if (argc < 1) {
 			free(excludes.list);
 			(void) fprintf(stderr,
 			    gettext("missing snapshot argument\n"));
 			usage(B_FALSE);
 		}
 		if (argc > 1) {
 			free(excludes.list);
 			(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) {
 			free(excludes.list);
 
 			(void) fprintf(stderr, gettext("incompatible flags "
 			    "combined with saved send flag\n"));
 			usage(B_FALSE);
 		}
 		if (strchr(argv[0], '@') != NULL) {
 			free(excludes.list);
 
 			(void) fprintf(stderr, gettext("saved send must "
 			    "specify the dataset with partially-received "
 			    "state\n"));
 			usage(B_FALSE);
 		}
 	}
 
 	if (flags.raw && redactbook != NULL) {
 		free(excludes.list);
 		(void) fprintf(stderr,
 		    gettext("Error: raw sends may not be redacted.\n"));
 		return (1);
 	}
 
 	if (!flags.dryrun && isatty(STDOUT_FILENO)) {
 		free(excludes.list);
 		(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) {
 			free(excludes.list);
 			return (1);
 		}
 
 		err = zfs_send_saved(zhp, &flags, STDOUT_FILENO,
 		    resume_token);
 		free(excludes.list);
 		zfs_close(zhp);
 		return (err != 0);
 	} else if (resume_token != NULL) {
 		free(excludes.list);
 		return (zfs_send_resume(g_zfs, &flags, STDOUT_FILENO,
 		    resume_token));
 	}
 
 	if (flags.skipmissing && !flags.replicate) {
 		free(excludes.list);
 		(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) {
 			free(excludes.list);
 			return (1);
 		}
 		err = zfs_send_one(zhp, fromname, STDOUT_FILENO, &flags,
 		    redactbook);
 
 		free(excludes.list);
 		zfs_close(zhp);
 		return (err != 0);
 	}
 
 	if (fromname != NULL && strchr(fromname, '#')) {
 		(void) fprintf(stderr,
 		    gettext("Error: multiple snapshots cannot be "
 		    "sent from a bookmark.\n"));
 		free(excludes.list);
 		return (1);
 	}
 
 	if (redactbook != NULL) {
 		(void) fprintf(stderr, gettext("Error: multiple snapshots "
 		    "cannot be sent redacted.\n"));
 		free(excludes.list);
 		return (1);
 	}
 
 	if ((cp = strchr(argv[0], '@')) == NULL) {
 		(void) fprintf(stderr, gettext("Error: "
 		    "Unsupported flag with filesystem or bookmark.\n"));
 		free(excludes.list);
 		return (1);
 	}
 	*cp = '\0';
 	toname = cp + 1;
 	zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
 	if (zhp == NULL) {
 		free(excludes.list);
 		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)) {
 				zfs_close(zhp);
 				free(excludes.list);
 				(void) fprintf(stderr,
 				    gettext("incremental source must be "
 				    "in same filesystem\n"));
 				usage(B_FALSE);
 			}
 			fromname = cp + 1;
 			if (strchr(fromname, '@') || strchr(fromname, '/')) {
 				zfs_close(zhp);
 				free(excludes.list);
 				(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,
 	    excludes.count > 0 ? zfs_do_send_exclude : NULL,
 	    &excludes, 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);
 	free(excludes.list);
 	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:dehMnuvFsAc")) != -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 'c':
 			flags.heal = 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);
 }
 
 static int
 who_perm_compare(const void *larg, const void *rarg, void *unused)
 {
 	(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);
 }
 
 static int
 deleg_perm_compare(const void *larg, const void *rarg, void *unused)
 {
 	(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)
 {
 	memset(fspset, 0, 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;
 
 	memset(who_perm, 0, 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;
 
 	memset(fsperm, 0, 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));
 
 		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, sizeof (errbuf),
 					    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, sizeof (errbuf),
 					    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, sizeof (errbuf),
 					    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_v2(zhp, 0, 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) strlcpy(parent, path, MIN(sizeof (parent),
 		    delim - path + 1));
 
 		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,
     boolean_t parsable)
 {
 	int i;
 	nvpair_t *nvp = NULL;
 	const char *const 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) {
 		const 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];
 			const 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) {
 				if (parsable) {
 					(void) printf("%s\t%s\t%ld\n", zname,
 					    tagname, (unsigned long)time);
 				} else {
 					(void) printf("%s\t%s\t%s\n", zname,
 					    tagname, tsbuf);
 				}
 			} else {
 				if (parsable) {
 					(void) printf("%-*s  %-*s  %ld\n",
 					    nwidth, zname, tagwidth,
 					    tagname, (unsigned long)time);
 				} 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 [-rHp] <snap> ...
  *
  *	-r	Lists holds that are set on the named snapshots recursively.
  *	-H	Scripted mode; elide headers and separate columns by tabs.
  *	-p	Display values in parsable (literal) format.
  */
 static int
 zfs_do_holds(int argc, char **argv)
 {
 	int c;
 	boolean_t errors = B_FALSE;
 	boolean_t scripted = B_FALSE;
 	boolean_t recursive = B_FALSE;
 	boolean_t parsable = B_FALSE;
 
 	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, "rHp")) != -1) {
 		switch (c) {
 		case 'r':
 			recursive = B_TRUE;
 			break;
 		case 'H':
 			scripted = B_TRUE;
 			break;
 		case 'p':
 			parsable = 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);
 
 	nvlist_t *nvl = fnvlist_alloc();
 
 	for (int 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 = B_TRUE;
 			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(1, argv + i, flags, types, NULL, NULL, limit,
 		    holds_callback, &cb);
 		if (ret != 0)
 			errors = B_TRUE;
 	}
 
 	/*
 	 *  2. print holds data
 	 */
 	print_holds(scripted, cb.cb_max_namelen, cb.cb_max_taglen, nvl,
 	    parsable);
 
 	if (nvlist_empty(nvl))
 		(void) fprintf(stderr, gettext("no datasets available\n"));
 
 	nvlist_free(nvl);
 
 	return (errors);
 }
 
 #define	CHECK_SPINNER 30
 #define	SPINNER_TIME 3		/* seconds */
 #define	MOUNT_TIME 1		/* seconds */
 
 typedef struct get_all_state {
 	char		**ga_datasets;
 	int		ga_count;
 	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 const char *const 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_v2(zhp, 0, 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 int
 get_recursive_datasets(zfs_handle_t *zhp, void *data)
 {
 	get_all_state_t *state = data;
 	int len = strlen(zfs_get_name(zhp));
 	for (int i = 0; i < state->ga_count; ++i) {
 		if (strcmp(state->ga_datasets[i], zfs_get_name(zhp)) == 0)
 			return (get_one_dataset(zhp, data));
 		else if ((strncmp(state->ga_datasets[i], zfs_get_name(zhp),
 		    len) == 0) && state->ga_datasets[i][len] == '/') {
 			(void) zfs_iter_filesystems_v2(zhp, 0,
 			    get_recursive_datasets, data);
 		}
 	}
 	zfs_close(zhp);
 	return (0);
 }
 
 static void
 get_all_datasets(get_all_state_t *state)
 {
 	if (state->ga_verbose)
 		set_progress_header(gettext("Reading ZFS config"));
 	if (state->ga_datasets == NULL)
 		(void) zfs_iter_root(g_zfs, get_one_dataset, state);
 	else
 		(void) zfs_iter_root(g_zfs, get_recursive_datasets, state);
 
 	if (state->ga_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;
 	enum sa_protocol	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, enum sa_protocol 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_unshare(zhp, mountpoint, NULL);
 			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: {
 		enum sa_protocol prot[] = {SA_PROTOCOL_NFS, SA_NO_PROTOCOL};
 		shared_nfs = zfs_is_shared(zhp, NULL, prot);
 		*prot = SA_PROTOCOL_SMB;
 		shared_smb = zfs_is_shared(zhp, NULL, prot);
 
 		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);
 
 		*prot = protocol;
 		if (zfs_share(zhp, protocol == SA_NO_PROTOCOL ? NULL : prot))
 			return (1);
 
 	}
 		break;
 
 	case OP_MOUNT:
 		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 enum sa_protocol
 sa_protocol_decode(const char *protocol)
 {
 	for (enum sa_protocol i = 0; i < ARRAY_SIZE(sa_protocol_names); ++i)
 		if (strcmp(protocol, sa_protocol_names[i]) == 0)
 			return (i);
 
 	(void) fputs(gettext("share type must be one of: "), stderr);
 	for (enum sa_protocol i = 0;
 	    i < ARRAY_SIZE(sa_protocol_names); ++i)
 		(void) fprintf(stderr, "%s%s",
 		    i != 0 ? ", " : "", sa_protocol_names[i]);
 	(void) fputc('\n', stderr);
 	usage(B_FALSE);
 }
 
 static int
 share_mount(int op, int argc, char **argv)
 {
 	int do_all = 0;
 	int recursive = 0;
 	boolean_t verbose = B_FALSE;
 	boolean_t json = B_FALSE;
 	int c, ret = 0;
 	char *options = NULL;
 	int flags = 0;
 	nvlist_t *jsobj, *data, *item;
 	const uint_t mount_nthr = 512;
 	uint_t nthr;
 	jsobj = data = item = NULL;
 
+	struct option long_options[] = {
+		{"json", no_argument, NULL, 'j'},
+		{0, 0, 0, 0}
+	};
+
 	/* check options */
-	while ((c = getopt(argc, argv, op == OP_MOUNT ? ":ajRlvo:Of" : "al"))
-	    != -1) {
+	while ((c = getopt_long(argc, argv,
+	    op == OP_MOUNT ? ":ajRlvo:Of" : "al",
+	    op == OP_MOUNT ? long_options : NULL, NULL)) != -1) {
 		switch (c) {
 		case 'a':
 			do_all = 1;
 			break;
 		case 'R':
 			recursive = 1;
 			break;
 		case 'v':
 			verbose = B_TRUE;
 			break;
 		case 'l':
 			flags |= MS_CRYPT;
 			break;
 		case 'j':
 			json = B_TRUE;
 			jsobj = zfs_json_schema(0, 1);
 			data = fnvlist_alloc();
 			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;
 
 	if (json && argc != 0) {
 		(void) fprintf(stderr, gettext("too many arguments\n"));
 		usage(B_FALSE);
 	}
 
 	/* check number of arguments */
 	if (do_all || recursive) {
 		enum sa_protocol protocol = SA_NO_PROTOCOL;
 
 		if (op == OP_SHARE && argc > 0) {
 			protocol = sa_protocol_decode(argv[0]);
 			argc--;
 			argv++;
 		}
 
 		if (argc != 0 && do_all) {
 			(void) fprintf(stderr, gettext("too many arguments\n"));
 			usage(B_FALSE);
 		}
 
 		if (argc == 0 && recursive) {
 			(void) fprintf(stderr,
 			    gettext("no dataset provided\n"));
 			usage(B_FALSE);
 		}
 
 		start_progress_timer();
 		get_all_cb_t cb = { 0 };
 		get_all_state_t state = { 0 };
 		if (argc == 0) {
 			state.ga_datasets = NULL;
 			state.ga_count = -1;
 		} else {
 			zfs_handle_t *zhp;
 			for (int i = 0; i < argc; i++) {
 				zhp = zfs_open(g_zfs, argv[i],
 				    ZFS_TYPE_FILESYSTEM);
 				if (zhp == NULL)
 					usage(B_FALSE);
 				zfs_close(zhp);
 			}
 			state.ga_datasets = argv;
 			state.ga_count = argc;
 		}
 		state.ga_verbose = verbose;
 		state.ga_cbp = &cb;
 		get_all_datasets(&state);
 
 		if (cb.cb_used == 0) {
 			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);
 
 		/* For a 'zfs share -a' operation start with a clean slate. */
 		if (op == OP_SHARE)
 			zfs_truncate_shares(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.
 		 */
 		nthr = op == OP_MOUNT && !(flags & MS_CRYPT) ? mount_nthr : 1;
 		zfs_foreach_mountpoint(g_zfs, cb.cb_handles, cb.cb_used,
 		    share_mount_one_cb, &share_mount_state, nthr);
 		zfs_commit_shares(NULL);
 
 		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) {
 		FILE *mnttab;
 		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.
 		 */
 
 		if ((mnttab = fopen(MNTTAB, "re")) == NULL) {
 			free(options);
 			return (ENOENT);
 		}
 
 		while (getmntent(mnttab, &entry) == 0) {
 			if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0 ||
 			    strchr(entry.mnt_special, '@') != NULL)
 				continue;
 			if (json) {
 				item = fnvlist_alloc();
 				fnvlist_add_string(item, "filesystem",
 				    entry.mnt_special);
 				fnvlist_add_string(item, "mountpoint",
 				    entry.mnt_mountp);
 				fnvlist_add_nvlist(data, entry.mnt_special,
 				    item);
 				fnvlist_free(item);
 			} else {
 				(void) printf("%-30s  %s\n", entry.mnt_special,
 				    entry.mnt_mountp);
 			}
 		}
 
 		(void) fclose(mnttab);
 		if (json) {
 			fnvlist_add_nvlist(jsobj, "datasets", data);
 			if (nvlist_empty(data))
 				fnvlist_free(jsobj);
 			else
 				zcmd_print_json(jsobj);
 			fnvlist_free(data);
 		}
 	} 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, SA_NO_PROTOCOL,
 			    B_TRUE, options);
 			zfs_commit_shares(NULL);
 			zfs_close(zhp);
 		}
 	}
 
 	free(options);
 	return (ret);
 }
 
 /*
  * zfs mount -a
  * 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;
 
 static int
 unshare_unmount_compare(const void *larg, const void *rarg, void *unused)
 {
 	(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.
 	 */
 
 	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, NULL, NULL)) {
 			(void) fprintf(stderr, gettext("cannot unshare '%s': "
 			    "not currently shared\n"), path);
 		} else {
 			ret = zfs_unshare(zhp, path, NULL);
 			zfs_commit_shares(NULL);
 		}
 	} 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.
 		 */
 		FILE *mnttab;
 		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;
 		enum sa_protocol *protocol = NULL,
 		    single_protocol[] = {SA_NO_PROTOCOL, SA_NO_PROTOCOL};
 
 		if (op == OP_SHARE && argc > 0) {
 			*single_protocol = sa_protocol_decode(argv[0]);
 			protocol = single_protocol;
 			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();
 
 		if ((mnttab = fopen(MNTTAB, "re")) == NULL) {
 			uu_avl_destroy(tree);
 			uu_avl_pool_destroy(pool);
 			return (ENOENT);
 		}
 
 		while (getmntent(mnttab, &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);
 			}
 		}
 		(void) fclose(mnttab);
 
 		/*
 		 * 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_unshare(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, NULL, NULL)) {
 				(void) fprintf(stderr, gettext("cannot "
 				    "unshare '%s': not currently "
 				    "shared\n"), zfs_get_name(zhp));
 				ret = 1;
 			} else if (zfs_unshareall(zhp, NULL) != 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(const 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, "FHth")) != -1) {
 		switch (c) {
 		case 'F':
 			flags |= ZFS_DIFF_CLASSIFY;
 			break;
 		case 'H':
 			flags |= ZFS_DIFF_PARSEABLE;
 			break;
 		case 't':
 			flags |= ZFS_DIFF_TIMESTAMP;
 			break;
 		case 'h':
 			flags |= ZFS_DIFF_NO_MANGLE;
 			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;
 	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;
 
+	struct option long_options[] = {
+		{"json", no_argument, NULL, 'j'},
+		{0, 0, 0, 0}
+	};
+
 	/* check options */
-	while ((c = getopt(argc, argv, "nt:m:j")) != -1) {
+	while ((c = getopt_long(argc, argv, "nt:m:j", long_options,
+	    NULL)) != -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;
 	}
 
 	const char *poolname = argv[0];
 	const char *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;
 	char *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,
 	    (const char **)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.
 		 */
 		const char *errstring = NULL;
 		const char *msg = gettext("Channel program execution failed");
 		uint64_t instructions = 0;
 		if (outnvl != NULL && nvlist_exists(outnvl, ZCP_RET_ERROR)) {
 			const char *es = NULL;
 			(void) nvlist_lookup_string(outnvl,
 			    ZCP_RET_ERROR, &es);
 			if (es == NULL)
 				errstring = strerror(ret);
 			else
 				errstring = es;
 			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 = 0, 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':
 			/* Reset activities array */
 			memset(&enabled, 0, sizeof (enabled));
 
 			for (char *tok; (tok = strsep(&optarg, ",")); ) {
 				static const char *const col_subopts[
 				    ZFS_WAIT_NUM_ACTIVITIES] = { "deleteq" };
 
 				for (i = 0; i < ARRAY_SIZE(col_subopts); ++i)
 					if (strcmp(tok, col_subopts[i]) == 0) {
 						enabled[i] = B_TRUE;
 						goto found;
 					}
 
 				(void) fprintf(stderr,
 				    gettext("invalid activity '%s'\n"), tok);
 				usage(B_FALSE);
 found:;
 			}
 			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)
 {
 	int c;
 	nvlist_t *jsobj = NULL, *zfs_ver = NULL;
 	boolean_t json = B_FALSE;
-	while ((c = getopt(argc, argv, "j")) != -1) {
+
+	struct option long_options[] = {
+		{"json", no_argument, NULL, 'j'},
+		{0, 0, 0, 0}
+	};
+
+	while ((c = getopt_long(argc, argv, "j", long_options, NULL)) != -1) {
 		switch (c) {
 		case 'j':
 			json = B_TRUE;
 			jsobj = zfs_json_schema(0, 1);
 			break;
 		case '?':
 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
 			    optopt);
 			usage(B_FALSE);
 		}
 	}
 
 	argc -= optind;
 	if (argc != 0) {
 		(void) fprintf(stderr, "too many arguments\n");
 		usage(B_FALSE);
 	}
 
 	if (json) {
 		zfs_ver = zfs_version_nvlist();
 		if (zfs_ver) {
 			fnvlist_add_nvlist(jsobj, "zfs_version", zfs_ver);
 			zcmd_print_json(jsobj);
 			fnvlist_free(zfs_ver);
 			return (0);
 		} else
 			return (-1);
 	} else
 		return (zfs_version_print() != 0);
 }
 
 /* Display documentation */
 static int
 zfs_do_help(int argc, char **argv)
 {
 	char page[MAXNAMELEN];
 	if (argc < 3 || strcmp(argv[2], "zfs") == 0)
 		strcpy(page, "zfs");
 	else if (strcmp(argv[2], "concepts") == 0 ||
 	    strcmp(argv[2], "props") == 0)
 		snprintf(page, sizeof (page), "zfs%s", argv[2]);
 	else
 		snprintf(page, sizeof (page), "zfs-%s", argv[2]);
 
 	execlp("man", "man", page, NULL);
 
 	fprintf(stderr, "couldn't run man program: %s", strerror(errno));
 	return (-1);
 }
 
 int
 main(int argc, char **argv)
 {
 	int ret = 0;
 	int i = 0;
 	const 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));
+		return (zfs_version_print() != 0);
 
 	/*
 	 * Special case 'help'
 	 */
 	if (strcmp(cmdname, "help") == 0)
 		return (zfs_do_help(argc, argv));
 
 	if ((g_zfs = libzfs_init()) == NULL) {
 		(void) fprintf(stderr, "%s\n", libzfs_error_init(errno));
 		return (1);
 	}
 
 	zfs_save_arguments(argc, argv, history_str, sizeof (history_str));
 
 	libzfs_print_on_error(g_zfs, B_TRUE);
 
 	zfs_setproctitle_init(argc, argv, environ);
 
 	/*
 	 * Many commands modify input strings for string parsing reasons.
 	 * We create a copy to protect the original argv.
 	 */
 	newargv = safe_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);
 }
 
 /*
  * zfs zone nsfile filesystem
  *
  * Add or delete the given dataset to/from the namespace.
  */
 #ifdef __linux__
 static int
 zfs_do_zone_impl(int argc, char **argv, boolean_t attach)
 {
 	zfs_handle_t *zhp;
 	int ret;
 
 	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);
 	}
 
 	zhp = zfs_open(g_zfs, argv[2], ZFS_TYPE_FILESYSTEM);
 	if (zhp == NULL)
 		return (1);
 
 	ret = (zfs_userns(zhp, argv[1], attach) != 0);
 
 	zfs_close(zhp);
 	return (ret);
 }
 
 static int
 zfs_do_zone(int argc, char **argv)
 {
 	return (zfs_do_zone_impl(argc, argv, B_TRUE));
 }
 
 static int
 zfs_do_unzone(int argc, char **argv)
 {
 	return (zfs_do_zone_impl(argc, argv, B_FALSE));
 }
 #endif
 
 #ifdef __FreeBSD__
 #include <sys/jail.h>
 #include <jail.h>
 /*
  * Attach/detach the given dataset to/from the given jail
  */
 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
  */
 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
  */
 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/zpool_main.c b/sys/contrib/openzfs/cmd/zpool/zpool_main.c
index aa7da68aa683..ea180f6b705e 100644
--- a/sys/contrib/openzfs/cmd/zpool/zpool_main.c
+++ b/sys/contrib/openzfs/cmd/zpool/zpool_main.c
@@ -1,13694 +1,13708 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 
 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
  * Copyright (c) 2011, 2024 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 (c) 2021, 2023, Klara Inc.
  * 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 <thread_pool.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 <string.h>
 #include <math.h>
 
 #include <libzfs.h>
 #include <libzutil.h>
 
 #include "zpool_util.h"
 #include "zfs_comutil.h"
 #include "zfeature_common.h"
 #include "zfs_valstr.h"
 
 #include "statcommon.h"
 
 libzfs_handle_t *g_zfs;
 
 static int mount_tp_nthr = 512;  /* tpool threads for multi-threaded mounting */
 
 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_prefetch(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 int zpool_do_ddt_prune(int, char **);
 
 static int zpool_do_help(int argc, char **argv);
 
 static zpool_compat_status_t zpool_do_load_compat(
     const char *, boolean_t *);
 
 enum zpool_options {
 	ZPOOL_OPTION_POWER = 1024,
 	ZPOOL_OPTION_ALLOW_INUSE,
 	ZPOOL_OPTION_ALLOW_REPLICATION_MISMATCH,
 	ZPOOL_OPTION_ALLOW_ASHIFT_MISMATCH,
 	ZPOOL_OPTION_POOL_KEY_GUID,
 	ZPOOL_OPTION_JSON_NUMS_AS_INT,
 	ZPOOL_OPTION_JSON_FLAT_VDEVS
 };
 
 /*
  * 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_DDT_PRUNE,
 	HELP_DESTROY,
 	HELP_DETACH,
 	HELP_EXPORT,
 	HELP_HISTORY,
 	HELP_IMPORT,
 	HELP_IOSTAT,
 	HELP_LABELCLEAR,
 	HELP_LIST,
 	HELP_OFFLINE,
 	HELP_ONLINE,
 	HELP_PREFETCH,
 	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][15] = {
 	[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,
 	    ZPOOL_CONFIG_VDEV_REBUILD_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,
 	    ZPOOL_CONFIG_VDEV_REBUILD_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,
 	    ZPOOL_CONFIG_VDEV_REBUILD_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,
 	    ZPOOL_CONFIG_VDEV_IND_REBUILD_HISTO,
 	    ZPOOL_CONFIG_VDEV_AGG_REBUILD_HISTO,
 	    NULL},
 };
 
 static const char *pool_scan_func_str[] = {
 	"NONE",
 	"SCRUB",
 	"RESILVER",
 	"ERRORSCRUB"
 };
 
 static const char *pool_scan_state_str[] = {
 	"NONE",
 	"SCANNING",
 	"FINISHED",
 	"CANCELED",
 	"ERRORSCRUBBING"
 };
 
 static const char *vdev_rebuild_state_str[] = {
 	"NONE",
 	"ACTIVE",
 	"CANCELED",
 	"COMPLETE"
 };
 
 static const char *checkpoint_state_str[] = {
 	"NONE",
 	"EXISTS",
 	"DISCARDING"
 };
 
 static const char *vdev_state_str[] = {
 	"UNKNOWN",
 	"CLOSED",
 	"OFFLINE",
 	"REMOVED",
 	"CANT_OPEN",
 	"FAULTED",
 	"DEGRADED",
 	"ONLINE"
 };
 
 static const char *vdev_aux_str[] = {
 	"NONE",
 	"OPEN_FAILED",
 	"CORRUPT_DATA",
 	"NO_REPLICAS",
 	"BAD_GUID_SUM",
 	"TOO_SMALL",
 	"BAD_LABEL",
 	"VERSION_NEWER",
 	"VERSION_OLDER",
 	"UNSUP_FEAT",
 	"SPARED",
 	"ERR_EXCEEDED",
 	"IO_FAILURE",
 	"BAD_LOG",
 	"EXTERNAL",
 	"SPLIT_POOL",
 	"BAD_ASHIFT",
 	"EXTERNAL_PERSIST",
 	"ACTIVE",
 	"CHILDREN_OFFLINE",
 	"ASHIFT_TOO_BIG"
 };
 
 static const char *vdev_init_state_str[] = {
 	"NONE",
 	"ACTIVE",
 	"CANCELED",
 	"SUSPENDED",
 	"COMPLETE"
 };
 
 static const char *vdev_trim_state_str[] = {
 	"NONE",
 	"ACTIVE",
 	"CANCELED",
 	"SUSPENDED",
 	"COMPLETE"
 };
 
 #define	ZFS_NICE_TIMESTAMP	100
 
 /*
  * 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		},
 	{ "prefetch",	zpool_do_prefetch,	HELP_PREFETCH		},
 	{ 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		},
 	{ NULL },
 	{ "ddtprune",	zpool_do_ddt_prune,	HELP_DDT_PRUNE		},
 };
 
 #define	NCOMMAND	(ARRAY_SIZE(command_table))
 
 #define	VDEV_ALLOC_CLASS_LOGS	"logs"
 
 #define	MAX_CMD_LEN	256
 
 static zpool_command_t *current_command;
 static zfs_type_t current_prop_type = (ZFS_TYPE_POOL | ZFS_TYPE_VDEV);
 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 [-afgLnP] [-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 [[--power]|[-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[,...]] [-j "
 		    "[--json-int, --json-pool-key-guid]] ...\n"
 		    "\t    [-T d|u] [pool] [interval [count]]\n"));
 	case HELP_PREFETCH:
 		return (gettext("\tprefetch -t <type> [<type opts>] <pool>\n"
 		    "\t    -t ddt <pool>\n"));
 	case HELP_OFFLINE:
 		return (gettext("\toffline [--power]|[[-f][-t]] <pool> "
 		    "<device> ...\n"));
 	case HELP_ONLINE:
 		return (gettext("\tonline [--power][-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 | -u] [-w] <pool> "
 		    "[<device> ...]\n"));
 	case HELP_SCRUB:
 		return (gettext("\tscrub [-s | -p] [-w] [-e] <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 [--power] [-j [--json-int, "
 		    "--json-flat-vdevs, ...\n"
 		    "\t    --json-pool-key-guid]] [-c [script1,script2,...]] "
 		    "[-dDegiLpPstvx] ...\n"
 		    "\t    [-T d|u] [pool] [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] [-j [--json-int, "
 		    "--json-pool-key-guid]] ...\n"
 		    "\t    [-o \"all\" | field[,...]] "
 		    "<\"all\" | property[,...]> <pool> ...\n"));
 	case HELP_SET:
 		return (gettext("\tset <property=value> <pool>\n"
 		    "\tset <vdev_property=value> <pool> <vdev>\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 [-g guid] <pool>\n"));
 	case HELP_SYNC:
 		return (gettext("\tsync [pool] ...\n"));
 	case HELP_VERSION:
 		return (gettext("\tversion [-j]\n"));
 	case HELP_WAIT:
 		return (gettext("\twait [-Hp] [-T d|u] [-t <activity>[,...]] "
 		    "<pool> [interval]\n"));
 	case HELP_DDT_PRUNE:
 		return (gettext("\tddtprune -d|-p <amount> <pool>\n"));
 	default:
 		__builtin_unreachable();
 	}
 }
 
 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_pool_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);
 }
 
 /*
  * Callback routine that will print out a vdev property value.
  */
 static int
 print_vdev_prop_cb(int prop, void *cb)
 {
 	FILE *fp = cb;
 
 	(void) fprintf(fp, "\t%-19s  ", vdev_prop_to_name(prop));
 
 	if (vdev_prop_readonly(prop))
 		(void) fprintf(fp, "  NO   ");
 	else
 		(void) fprintf(fp, " YES   ");
 
 	if (vdev_prop_values(prop) == NULL)
 		(void) fprintf(fp, "-\n");
 	else
 		(void) fprintf(fp, "%s\n", vdev_prop_values(prop));
 
 	return (ZPROP_CONT);
 }
 
 /*
  * Given a leaf vdev name like 'L5' return its VDEV_CONFIG_PATH like
  * '/dev/disk/by-vdev/L5'.
  */
 static const char *
 vdev_name_to_path(zpool_handle_t *zhp, char *vdev)
 {
 	nvlist_t *vdev_nv = zpool_find_vdev(zhp, vdev, NULL, NULL, NULL);
 	if (vdev_nv == NULL) {
 		return (NULL);
 	}
 	return (fnvlist_lookup_string(vdev_nv, ZPOOL_CONFIG_PATH));
 }
 
 static int
 zpool_power_on(zpool_handle_t *zhp, char *vdev)
 {
 	return (zpool_power(zhp, vdev, B_TRUE));
 }
 
 static int
 zpool_power_on_and_disk_wait(zpool_handle_t *zhp, char *vdev)
 {
 	int rc;
 
 	rc = zpool_power_on(zhp, vdev);
 	if (rc != 0)
 		return (rc);
 
 	zpool_disk_wait(vdev_name_to_path(zhp, vdev));
 
 	return (0);
 }
 
 static int
 zpool_power_on_pool_and_wait_for_devices(zpool_handle_t *zhp)
 {
 	nvlist_t *nv;
 	const char *path = NULL;
 	int rc;
 
 	/* Power up all the devices first */
 	FOR_EACH_REAL_LEAF_VDEV(zhp, nv) {
 		path = fnvlist_lookup_string(nv, ZPOOL_CONFIG_PATH);
 		if (path != NULL) {
 			rc = zpool_power_on(zhp, (char *)path);
 			if (rc != 0) {
 				return (rc);
 			}
 		}
 	}
 
 	/*
 	 * Wait for their devices to show up.  Since we powered them on
 	 * at roughly the same time, they should all come online around
 	 * the same time.
 	 */
 	FOR_EACH_REAL_LEAF_VDEV(zhp, nv) {
 		path = fnvlist_lookup_string(nv, ZPOOL_CONFIG_PATH);
 		zpool_disk_wait(path);
 	}
 
 	return (0);
 }
 
 static int
 zpool_power_off(zpool_handle_t *zhp, char *vdev)
 {
 	return (zpool_power(zhp, vdev, B_FALSE));
 }
 
 /*
  * 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 __attribute__((noreturn)) 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));
 		}
 
 		(void) fprintf(fp,
 		    gettext("\nFor further help on a command or topic, "
 		    "run: %s\n"), "zpool help [<topic>]");
 	} else {
 		(void) fprintf(fp, gettext("usage:\n"));
 		(void) fprintf(fp, "%s", get_usage(current_command->usage));
 	}
 
 	if (current_command != NULL &&
 	    current_prop_type != (ZFS_TYPE_POOL | ZFS_TYPE_VDEV) &&
 	    ((strcmp(current_command->name, "set") == 0) ||
 	    (strcmp(current_command->name, "get") == 0) ||
 	    (strcmp(current_command->name, "list") == 0))) {
 
 		(void) fprintf(fp, "%s",
 		    gettext("\nthe following properties are supported:\n"));
 
 		(void) fprintf(fp, "\n\t%-19s  %s   %s\n\n",
 		    "PROPERTY", "EDIT", "VALUES");
 
 		/* Iterate over all properties */
 		if (current_prop_type == ZFS_TYPE_POOL) {
 			(void) zprop_iter(print_pool_prop_cb, fp, B_FALSE,
 			    B_TRUE, current_prop_type);
 
 			(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.\n"
 			    "See zpool-features(7).\n"));
 		} else if (current_prop_type == ZFS_TYPE_VDEV) {
 			(void) zprop_iter(print_vdev_prop_cb, fp, B_FALSE,
 			    B_TRUE, current_prop_type);
 		}
 	}
 
 	/*
 	 * 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 | -u] [-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.
  *	-u	Uninitialize. Clears initialization state.
  *	-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'},
 		{"uninit",	no_argument,		NULL, 'u'},
 		{"wait",	no_argument,		NULL, 'w'},
 		{0, 0, 0, 0}
 	};
 
 	pool_initialize_func_t cmd_type = POOL_INITIALIZE_START;
 	while ((c = getopt_long(argc, argv, "csuw", 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 'u':
 			if (cmd_type != POOL_INITIALIZE_START &&
 			    cmd_type != POOL_INITIALIZE_UNINIT) {
 				(void) fprintf(stderr, gettext("-u cannot be "
 				    "combined with other options\n"));
 				usage(B_FALSE);
 			}
 			cmd_type = POOL_INITIALIZE_UNINIT;
 			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, -s"
 		    "or -u\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;
 		const 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);
 	}
 }
 
 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);
 }
 
 static void
 nice_num_str_nvlist(nvlist_t *item, const char *key, uint64_t value,
     boolean_t literal, boolean_t as_int, int format)
 {
 	char buf[256];
 	if (literal) {
 		if (!as_int)
 			snprintf(buf, 256, "%llu", (u_longlong_t)value);
 	} else {
 		switch (format) {
 		case ZFS_NICENUM_1024:
 			zfs_nicenum_format(value, buf, 256, ZFS_NICENUM_1024);
 			break;
 		case ZFS_NICENUM_BYTES:
 			zfs_nicenum_format(value, buf, 256, ZFS_NICENUM_BYTES);
 			break;
 		case ZFS_NICENUM_TIME:
 			zfs_nicenum_format(value, buf, 256, ZFS_NICENUM_TIME);
 			break;
 		case ZFS_NICE_TIMESTAMP:
 			format_timestamp(value, buf, 256);
 			break;
 		default:
 			fprintf(stderr, "Invalid number format");
 			exit(1);
 		}
 	}
 	if (as_int)
 		fnvlist_add_uint64(item, key, value);
 	else
 		fnvlist_add_string(item, key, buf);
 }
 
 /*
  * Generates an nvlist with output version for every command based on params.
  * Purpose of this is to add a version of JSON output, considering the schema
  * format might be updated for each command in future.
  *
  * Schema:
  *
  * "output_version": {
  *    "command": string,
  *    "vers_major": integer,
  *    "vers_minor": integer,
  *  }
  */
 static nvlist_t *
 zpool_json_schema(int maj_v, int min_v)
 {
 	char cmd[MAX_CMD_LEN];
 	nvlist_t *sch = fnvlist_alloc();
 	nvlist_t *ov = fnvlist_alloc();
 
 	snprintf(cmd, MAX_CMD_LEN, "zpool %s", current_command->name);
 	fnvlist_add_string(ov, "command", cmd);
 	fnvlist_add_uint32(ov, "vers_major", maj_v);
 	fnvlist_add_uint32(ov, "vers_minor", min_v);
 	fnvlist_add_nvlist(sch, "output_version", ov);
 	fnvlist_free(ov);
 	return (sch);
 }
 
 static void
 fill_pool_info(nvlist_t *list, zpool_handle_t *zhp, boolean_t addtype,
     boolean_t as_int)
 {
 	nvlist_t *config = zpool_get_config(zhp, NULL);
 	uint64_t guid = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID);
 	uint64_t txg = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG);
 
 	fnvlist_add_string(list, "name", zpool_get_name(zhp));
 	if (addtype)
 		fnvlist_add_string(list, "type", "POOL");
 	fnvlist_add_string(list, "state", zpool_get_state_str(zhp));
 	if (as_int) {
 		if (guid)
 			fnvlist_add_uint64(list, ZPOOL_CONFIG_POOL_GUID, guid);
 		if (txg)
 			fnvlist_add_uint64(list, ZPOOL_CONFIG_POOL_TXG, txg);
 		fnvlist_add_uint64(list, "spa_version", SPA_VERSION);
 		fnvlist_add_uint64(list, "zpl_version", ZPL_VERSION);
 	} else {
 		char value[ZFS_MAXPROPLEN];
 		if (guid) {
 			snprintf(value, ZFS_MAXPROPLEN, "%llu",
 			    (u_longlong_t)guid);
 			fnvlist_add_string(list, ZPOOL_CONFIG_POOL_GUID, value);
 		}
 		if (txg) {
 			snprintf(value, ZFS_MAXPROPLEN, "%llu",
 			    (u_longlong_t)txg);
 			fnvlist_add_string(list, ZPOOL_CONFIG_POOL_TXG, value);
 		}
 		fnvlist_add_string(list, "spa_version", SPA_VERSION_STRING);
 		fnvlist_add_string(list, "zpl_version", ZPL_VERSION_STRING);
 	}
 }
 
 static void
 used_by_other(zpool_handle_t *zhp, nvlist_t *nvdev, nvlist_t *list)
 {
 	spare_cbdata_t spare_cb;
 	verify(nvlist_lookup_uint64(nvdev, 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) {
 			fnvlist_add_string(list, "used_by",
 			    zpool_get_name(spare_cb.cb_zhp));
 		}
 		zpool_close(spare_cb.cb_zhp);
 	}
 }
 
 static void
 fill_vdev_info(nvlist_t *list, zpool_handle_t *zhp, char *name,
     boolean_t addtype, boolean_t as_int)
 {
 	boolean_t l2c = B_FALSE;
 	const char *path, *phys, *devid, *bias = NULL;
 	uint64_t hole = 0, log = 0, spare = 0;
 	vdev_stat_t *vs;
 	uint_t c;
 	nvlist_t *nvdev;
 	nvlist_t *nvdev_parent = NULL;
 	char *_name;
 
 	if (strcmp(name, zpool_get_name(zhp)) != 0)
 		_name = name;
 	else
 		_name = (char *)"root-0";
 
 	nvdev = zpool_find_vdev(zhp, _name, NULL, &l2c, NULL);
 
 	fnvlist_add_string(list, "name", name);
 	if (addtype)
 		fnvlist_add_string(list, "type", "VDEV");
 	if (nvdev) {
 		const char *type = fnvlist_lookup_string(nvdev,
 		    ZPOOL_CONFIG_TYPE);
 		if (type)
 			fnvlist_add_string(list, "vdev_type", type);
 		uint64_t guid = fnvlist_lookup_uint64(nvdev, ZPOOL_CONFIG_GUID);
 		if (guid) {
 			if (as_int) {
 				fnvlist_add_uint64(list, "guid", guid);
 			} else {
 				char buf[ZFS_MAXPROPLEN];
 				snprintf(buf, ZFS_MAXPROPLEN, "%llu",
 				    (u_longlong_t)guid);
 				fnvlist_add_string(list, "guid", buf);
 			}
 		}
 		if (nvlist_lookup_string(nvdev, ZPOOL_CONFIG_PATH, &path) == 0)
 			fnvlist_add_string(list, "path", path);
 		if (nvlist_lookup_string(nvdev, ZPOOL_CONFIG_PHYS_PATH,
 		    &phys) == 0)
 			fnvlist_add_string(list, "phys_path", phys);
 		if (nvlist_lookup_string(nvdev, ZPOOL_CONFIG_DEVID,
 		    &devid) == 0)
 			fnvlist_add_string(list, "devid", devid);
 		(void) nvlist_lookup_uint64(nvdev, ZPOOL_CONFIG_IS_LOG, &log);
 		(void) nvlist_lookup_uint64(nvdev, ZPOOL_CONFIG_IS_SPARE,
 		    &spare);
 		(void) nvlist_lookup_uint64(nvdev, ZPOOL_CONFIG_IS_HOLE, &hole);
 		if (hole)
 			fnvlist_add_string(list, "class", VDEV_TYPE_HOLE);
 		else if (l2c)
 			fnvlist_add_string(list, "class", VDEV_TYPE_L2CACHE);
 		else if (spare)
 			fnvlist_add_string(list, "class", VDEV_TYPE_SPARE);
 		else if (log)
 			fnvlist_add_string(list, "class", VDEV_TYPE_LOG);
 		else {
 			(void) nvlist_lookup_string(nvdev,
 			    ZPOOL_CONFIG_ALLOCATION_BIAS, &bias);
 			if (bias != NULL)
 				fnvlist_add_string(list, "class", bias);
 			else {
 				nvdev_parent = NULL;
 				nvdev_parent = zpool_find_parent_vdev(zhp,
 				    _name, NULL, NULL, NULL);
 
 				/*
 				 * With a mirrored special device, the parent
 				 * "mirror" vdev will have
 				 * ZPOOL_CONFIG_ALLOCATION_BIAS set to "special"
 				 * not the leaf vdevs.  If we're a leaf vdev
 				 * in that case we need to look at our parent
 				 * to see if they're "special" to know if we
 				 * are "special" too.
 				 */
 				if (nvdev_parent) {
 					(void) nvlist_lookup_string(
 					    nvdev_parent,
 					    ZPOOL_CONFIG_ALLOCATION_BIAS,
 					    &bias);
 				}
 				if (bias != NULL)
 					fnvlist_add_string(list, "class", bias);
 				else
 					fnvlist_add_string(list, "class",
 					    "normal");
 			}
 		}
 		if (nvlist_lookup_uint64_array(nvdev, ZPOOL_CONFIG_VDEV_STATS,
 		    (uint64_t **)&vs, &c) == 0) {
 			fnvlist_add_string(list, "state",
 			    vdev_state_str[vs->vs_state]);
 		}
 	}
 }
 
 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, const char *propval, nvlist_t **props,
     boolean_t poolprop)
 {
 	zpool_prop_t prop = ZPOOL_PROP_INVAL;
 	nvlist_t *proplist;
 	const char *normnm;
 	const 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) &&
 		    !zpool_prop_vdev(propname))) {
 			(void) fprintf(stderr, gettext("property '%s' is "
 			    "not a valid pool or vdev 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) || zpool_prop_vdev(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, const char *propval,
     nvlist_t **props)
 {
 	const char *pval;
 
 	if (nvlist_lookup_string(*props, propname, &pval) == 0)
 		return (0);
 
 	return (add_prop_list(propname, propval, props, B_TRUE));
 }
 
 /*
  * zpool add [-afgLnP] [-o property=value] <pool> <vdev> ...
  *
  *	-a	Disable the ashift validation checks
  *	-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 check_replication = B_TRUE;
 	boolean_t check_inuse = B_TRUE;
 	boolean_t dryrun = B_FALSE;
 	boolean_t check_ashift = B_TRUE;
 	boolean_t force = 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;
 
 	struct option long_options[] = {
 		{"allow-in-use", no_argument, NULL, ZPOOL_OPTION_ALLOW_INUSE},
 		{"allow-replication-mismatch", no_argument, NULL,
 		    ZPOOL_OPTION_ALLOW_REPLICATION_MISMATCH},
 		{"allow-ashift-mismatch", no_argument, NULL,
 		    ZPOOL_OPTION_ALLOW_ASHIFT_MISMATCH},
 		{0, 0, 0, 0}
 	};
 
 	/* check options */
 	while ((c = getopt_long(argc, argv, "fgLno:P", long_options, NULL))
 	    != -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 ZPOOL_OPTION_ALLOW_INUSE:
 			check_inuse = B_FALSE;
 			break;
 		case ZPOOL_OPTION_ALLOW_REPLICATION_MISMATCH:
 			check_replication = B_FALSE;
 			break;
 		case ZPOOL_OPTION_ALLOW_ASHIFT_MISMATCH:
 			check_ashift = B_FALSE;
 			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);
 	}
 
 	if (force) {
 		if (!check_inuse || !check_replication || !check_ashift) {
 			(void) fprintf(stderr, gettext("'-f' option is not "
 			    "allowed with '--allow-replication-mismatch', "
 			    "'--allow-ashift-mismatch', or "
 			    "'--allow-in-use'\n"));
 			usage(B_FALSE);
 		}
 		check_inuse = B_FALSE;
 		check_replication = B_FALSE;
 		check_ashift = 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, !check_inuse,
 	    check_replication, 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, check_ashift) != 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) {
 		zpool_close(zhp);
 		(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;
 	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);
 	}
 
 	(void) strlcpy(vdev, argv[0], sizeof (vdev));
 
 	/*
 	 * If we cannot open an absolute path, we quit.
 	 * Otherwise if the provided vdev name doesn't point to a file,
 	 * try prepending expected disk paths and partition numbers.
 	 */
 	if ((fd = open(vdev, O_RDWR)) < 0) {
 		int error;
 		if (vdev[0] == '/') {
 			(void) fprintf(stderr, gettext("failed to open "
 			    "%s: %s\n"), vdev, strerror(errno));
 			return (1);
 		}
 
 		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 || ((fd = open(vdev, O_RDWR)) < 0)) {
 			if (errno == ENOENT) {
 				(void) fprintf(stderr, gettext(
 				    "failed to find device %s, try "
 				    "specifying absolute path instead\n"),
 				    argv[0]);
 				return (1);
 			}
 
 			(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))
 				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, 0);
 				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))
 				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];
 			const 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);
 				} else 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_share(pool, NULL);
 					zfs_commit_shares(NULL);
 				}
 				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 {
 	tpool_t *tpool;
 	pthread_mutex_t mnttab_lock;
 	boolean_t force;
 	boolean_t hardforce;
 	int retval;
 } export_cbdata_t;
 
 
 typedef struct {
 	char *aea_poolname;
 	export_cbdata_t	*aea_cbdata;
 } async_export_args_t;
 
 /*
  * Export one pool
  */
 static int
 zpool_export_one(zpool_handle_t *zhp, void *data)
 {
 	export_cbdata_t *cb = data;
 
 	/*
 	 * zpool_disable_datasets() is not thread-safe for mnttab access.
 	 * So we serialize access here for 'zpool export -a' parallel case.
 	 */
 	if (cb->tpool != NULL)
 		pthread_mutex_lock(&cb->mnttab_lock);
 
 	int retval = zpool_disable_datasets(zhp, cb->force);
 
 	if (cb->tpool != NULL)
 		pthread_mutex_unlock(&cb->mnttab_lock);
 
 	if (retval)
 		return (1);
 
 	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);
 }
 
 /*
  * Asynchronous export request
  */
 static void
 zpool_export_task(void *arg)
 {
 	async_export_args_t *aea = arg;
 
 	zpool_handle_t *zhp = zpool_open(g_zfs, aea->aea_poolname);
 	if (zhp != NULL) {
 		int ret = zpool_export_one(zhp, aea->aea_cbdata);
 		if (ret != 0)
 			aea->aea_cbdata->retval = ret;
 		zpool_close(zhp);
 	} else {
 		aea->aea_cbdata->retval = 1;
 	}
 
 	free(aea->aea_poolname);
 	free(aea);
 }
 
 /*
  * Process an export request in parallel
  */
 static int
 zpool_export_one_async(zpool_handle_t *zhp, void *data)
 {
 	tpool_t *tpool = ((export_cbdata_t *)data)->tpool;
 	async_export_args_t *aea = safe_malloc(sizeof (async_export_args_t));
 
 	/* save pool name since zhp will go out of scope */
 	aea->aea_poolname = strdup(zpool_get_name(zhp));
 	aea->aea_cbdata = data;
 
 	/* ship off actual export to another thread */
 	if (tpool_dispatch(tpool, zpool_export_task, (void *)aea) != 0)
 		return (errno);	/* unlikely */
 	else
 		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;
 	cb.tpool = NULL;
 	cb.retval = 0;
 	argc -= optind;
 	argv += optind;
 
 	/* The history will be logged as part of the export itself */
 	log_history = B_FALSE;
 
 	if (do_all) {
 		if (argc != 0) {
 			(void) fprintf(stderr, gettext("too many arguments\n"));
 			usage(B_FALSE);
 		}
 
 		cb.tpool = tpool_create(1, 5 * sysconf(_SC_NPROCESSORS_ONLN),
 		    0, NULL);
 		pthread_mutex_init(&cb.mnttab_lock, NULL);
 
 		/* Asynchronously call zpool_export_one using thread pool */
 		ret = for_each_pool(argc, argv, B_TRUE, NULL, ZFS_TYPE_POOL,
 		    B_FALSE, zpool_export_one_async, &cb);
 
 		tpool_wait(cb.tpool);
 		tpool_destroy(cb.tpool);
 		(void) pthread_mutex_destroy(&cb.mnttab_lock);
 
 		return (ret | cb.retval);
 	}
 
 	/* 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, ZFS_TYPE_POOL,
 	    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)
 {
 	static const char *const subtypes[] =
 	    {ZPOOL_CONFIG_SPARES, ZPOOL_CONFIG_L2CACHE, ZPOOL_CONFIG_CHILDREN};
 
 	char *name = zpool_vdev_name(g_zfs, zhp, nv, name_flags);
 	max = MAX(strlen(name) + depth, max);
 	free(name);
 
 	nvlist_t **child;
 	uint_t children;
 	for (size_t i = 0; i < ARRAY_SIZE(subtypes); ++i)
 		if (nvlist_lookup_nvlist_array(nv, subtypes[i],
 		    &child, &children) == 0)
 			for (uint_t c = 0; c < children; ++c)
 				max = MAX(max_width(zhp, child[c], depth + 2,
 				    max, name_flags), max);
 
 	return (max);
 }
 
 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_unhealthy;
 	boolean_t	cb_print_status;
 	boolean_t	cb_print_slow_ios;
 	boolean_t	cb_print_dio_verify;
 	boolean_t	cb_print_vdev_init;
 	boolean_t	cb_print_vdev_trim;
 	vdev_cmd_data_list_t	*vcdl;
 	boolean_t	cb_print_power;
 	boolean_t	cb_json;
 	boolean_t	cb_flat_vdevs;
 	nvlist_t	*cb_jsobj;
 	boolean_t	cb_json_as_int;
 	boolean_t	cb_json_pool_key_guid;
 } status_cbdata_t;
 
 /* Return 1 if string is NULL, empty, or whitespace; return 0 otherwise. */
 static boolean_t
 is_blank_str(const char *str)
 {
 	for (; str != NULL && *str != '\0'; ++str)
 		if (!isblank(*str))
 			return (B_FALSE);
 	return (B_TRUE);
 }
 
 static void
 zpool_nvlist_cmd(vdev_cmd_data_list_t *vcdl, const char *pool, const char *path,
     nvlist_t *item)
 {
 	vdev_cmd_data_t *data;
 	int i, j, k = 1;
 	char tmp[256];
 	const char *val;
 
 	for (i = 0; i < vcdl->count; i++) {
 		if ((strcmp(vcdl->data[i].path, path) != 0) ||
 		    (strcmp(vcdl->data[i].pool, pool) != 0))
 			continue;
 
 		data = &vcdl->data[i];
 		for (j = 0; j < vcdl->uniq_cols_cnt; j++) {
 			val = NULL;
 			for (int k = 0; k < data->cols_cnt; k++) {
 				if (strcmp(data->cols[k],
 				    vcdl->uniq_cols[j]) == 0) {
 					val = data->lines[k];
 					break;
 				}
 			}
 			if (val == NULL || is_blank_str(val))
 				val = "-";
 			fnvlist_add_string(item, vcdl->uniq_cols[j], val);
 		}
 
 		for (j = data->cols_cnt; j < data->lines_cnt; j++) {
 			if (data->lines[j]) {
 				snprintf(tmp, 256, "extra_%d", k++);
 				fnvlist_add_string(item, tmp,
 				    data->lines[j]);
 			}
 		}
 		break;
 	}
 }
 
 /* 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, const char *path)
 {
 	vdev_cmd_data_t *data;
 	int i, j;
 	const 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)
 				fputs("  ", stdout);
 		}
 
 		/* 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)
 				fputs("  ", stdout);
 
 			val = data->lines[j];
 			fputs(val ?: "", stdout);
 		}
 		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];
 
 			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) ctime_r(&t, tbuf);
 			tbuf[24] = 0;
 
 			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];
 
 			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) ctime_r(&t, tbuf);
 			tbuf[24] = 0;
 
 			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 const 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);
 }
 
 /*
  * Called for each leaf vdev.  Returns 0 if the vdev is healthy.
  * A vdev is unhealthy if any of the following are true:
  * 1) there are read, write, or checksum errors,
  * 2) its state is not ONLINE, or
  * 3) slow IO reporting was requested (-s) and there are slow IOs.
  */
 static int
 vdev_health_check_cb(void *hdl_data, nvlist_t *nv, void *data)
 {
 	status_cbdata_t *cb = data;
 	vdev_stat_t *vs;
 	uint_t vsc;
 	(void) hdl_data;
 
 	if (nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS,
 	    (uint64_t **)&vs, &vsc) != 0)
 		return (1);
 
 	if (vs->vs_checksum_errors || vs->vs_read_errors ||
 	    vs->vs_write_errors || vs->vs_state != VDEV_STATE_HEALTHY)
 		return (1);
 
 	if (cb->cb_print_slow_ios && vs->vs_slow_ios)
 		return (1);
 
 	return (0);
 }
 
 /*
  * 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], dbuf[6];
 	char *vname;
 	uint64_t notpresent;
 	spare_cbdata_t spare_cb;
 	const char *state;
 	const char *type;
 	const char *path = NULL;
 	const char *rcolor = NULL, *wcolor = NULL, *ccolor = NULL,
 	    *scolor = 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");
 	}
 
 	/*
 	 * If '-e' is specified then top-level vdevs and their children
 	 * can be pruned if all of their leaves are healthy.
 	 */
 	if (cb->cb_print_unhealthy && depth > 0 &&
 	    for_each_vdev_in_nvlist(nv, vdev_health_check_cb, cb) == 0) {
 		return;
 	}
 
 	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 (vs->vs_slow_ios)
 			scolor = ANSI_BLUE;
 
 		if (cb->cb_literal) {
 			fputc(' ', stdout);
 			printf_color(rcolor, "%5llu",
 			    (u_longlong_t)vs->vs_read_errors);
 			fputc(' ', stdout);
 			printf_color(wcolor, "%5llu",
 			    (u_longlong_t)vs->vs_write_errors);
 			fputc(' ', stdout);
 			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));
 			fputc(' ', stdout);
 			printf_color(rcolor, "%5s", rbuf);
 			fputc(' ', stdout);
 			printf_color(wcolor, "%5s", wbuf);
 			fputc(' ', stdout);
 			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_color(scolor, " %5llu",
 				    (u_longlong_t)vs->vs_slow_ios);
 			else
 				printf_color(scolor, " %5s", rbuf);
 		}
 		if (cb->cb_print_power) {
 			if (children == 0)  {
 				/* Only leaf vdevs have physical slots */
 				switch (zpool_power_current_state(zhp, (char *)
 				    fnvlist_lookup_string(nv,
 				    ZPOOL_CONFIG_PATH))) {
 				case 0:
 					printf_color(ANSI_RED, " %5s",
 					    gettext("off"));
 					break;
 				case 1:
 					printf(" %5s", gettext("on"));
 					break;
 				default:
 					printf(" %5s", "-");
 				}
 			} else {
 				printf(" %5s", "-");
 			}
 		}
 		if (VDEV_STAT_VALID(vs_dio_verify_errors, vsc) &&
 		    cb->cb_print_dio_verify) {
 			zfs_nicenum(vs->vs_dio_verify_errors, dbuf,
 			    sizeof (dbuf));
 
 			if (cb->cb_literal)
 				printf(" %5llu",
 				    (u_longlong_t)vs->vs_dio_verify_errors);
 			else
 				printf(" %5s", dbuf);
 		}
 	}
 
 	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:
 			if (vs->vs_read_errors + vs->vs_write_errors +
 			    vs->vs_checksum_errors == 0 && children == 0 &&
 			    vs->vs_slow_ios > 0) {
 				(void) printf(gettext("too many slow I/Os"));
 			} else {
 				(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);
 	}
 
 	if (vs->vs_scan_removing != 0) {
 		(void) printf(gettext("  (removing)"));
 	} else if (VDEV_STAT_VALID(vs_noalloc, vsc) && vs->vs_noalloc != 0) {
 		(void) printf(gettext("  (non-allocating)"));
 	}
 
 	/* 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 you force fault a drive that's resilvering, its scan stats can
 	 * get frozen in time, giving the false impression that it's
 	 * being resilvered.  That's why we check the state to see if the vdev
 	 * is healthy before reporting "resilvering" or "repairing".
 	 */
 	if (ps != NULL && ps->pss_state == DSS_SCANNING && children == 0 &&
 	    vs->vs_state == VDEV_STATE_HEALTHY) {
 		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 && vs->vs_state == VDEV_STATE_HEALTHY) {
 		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;
 	const char *type;
 	char *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;
 		const char *bias = NULL;
 		const char *type = NULL;
 
 		(void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
 		    &is_log);
 
 		if (is_log) {
 			bias = (char *)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;
 	const char *name;
 	uint64_t guid;
 	uint64_t hostid = 0;
 	const char *msgid;
 	const char *hostname = "unknown";
 	nvlist_t *nvroot, *nvinfo;
 	zpool_status_t reason;
 	zpool_errata_t errata;
 	const char *health;
 	uint_t vsc;
 	const char *comment;
 	const char *indent;
 	char buf[2048];
 	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);
 
 	if (nvlist_lookup_string(config, ZPOOL_CONFIG_COMMENT, &comment) == 0) {
 		indent = " ";
 	} else {
 		comment = NULL;
 		indent = "";
 	}
 
 	(void) printf(gettext("%s  pool: %s\n"), indent, name);
 	(void) printf(gettext("%s    id: %llu\n"), indent, (u_longlong_t)guid);
 	(void) printf(gettext("%s state: %s"), indent, health);
 	if (pool_state == POOL_STATE_DESTROYED)
 		(void) printf(gettext(" (DESTROYED)"));
 	(void) printf("\n");
 
 	if (reason != ZPOOL_STATUS_OK) {
 		(void) printf("%s", indent);
 		printf_color(ANSI_BOLD, gettext("status: "));
 	}
 	switch (reason) {
 	case ZPOOL_STATUS_MISSING_DEV_R:
 	case ZPOOL_STATUS_MISSING_DEV_NR:
 	case ZPOOL_STATUS_BAD_GUID_SUM:
 		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_YELLOW, gettext("One or more devices "
 		    "contains corrupted data.\n"));
 		break;
 
 	case ZPOOL_STATUS_CORRUPT_DATA:
 		printf_color(ANSI_YELLOW, gettext("The pool data is "
 		    "corrupted.\n"));
 		break;
 
 	case ZPOOL_STATUS_OFFLINE_DEV:
 		printf_color(ANSI_YELLOW, gettext("One or more devices "
 		    "are offlined.\n"));
 		break;
 
 	case ZPOOL_STATUS_CORRUPT_POOL:
 		printf_color(ANSI_YELLOW, gettext("The pool metadata is "
 		    "corrupted.\n"));
 		break;
 
 	case ZPOOL_STATUS_VERSION_OLDER:
 		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_YELLOW, gettext("The pool is formatted using "
 		    "an incompatible version.\n"));
 		break;
 
 	case ZPOOL_STATUS_FEAT_DISABLED:
 		printf_color(ANSI_YELLOW, gettext("Some supported "
 		    "features are not enabled on the pool.\n"
 		    "\t%s(Note that they may be intentionally disabled if the\n"
 		    "\t%s'compatibility' property is set.)\n"), indent, indent);
 		break;
 
 	case ZPOOL_STATUS_COMPATIBILITY_ERR:
 		printf_color(ANSI_YELLOW, gettext("Error reading or parsing "
 		    "the file(s) indicated by the 'compatibility'\n"
 		    "\t%sproperty.\n"), indent);
 		break;
 
 	case ZPOOL_STATUS_INCOMPATIBLE_FEAT:
 		printf_color(ANSI_YELLOW, gettext("One or more features "
 		    "are enabled on the pool despite not being\n"
 		    "\t%srequested by the 'compatibility' property.\n"),
 		    indent);
 		break;
 
 	case ZPOOL_STATUS_UNSUP_FEAT_READ:
 		printf_color(ANSI_YELLOW, gettext("The pool uses the following "
 		    "feature(s) not supported on this system:\n"));
 		color_start(ANSI_YELLOW);
 		zpool_collect_unsup_feat(config, buf, 2048);
 		(void) printf("%s", buf);
 		color_end();
 		break;
 
 	case ZPOOL_STATUS_UNSUP_FEAT_WRITE:
 		printf_color(ANSI_YELLOW, gettext("The pool can only be "
 		    "accessed in read-only mode on this system. It\n"
 		    "\t%scannot be accessed in read-write mode because it uses "
 		    "the following\n"
 		    "\t%sfeature(s) not supported on this system:\n"),
 		    indent, indent);
 		color_start(ANSI_YELLOW);
 		zpool_collect_unsup_feat(config, buf, 2048);
 		(void) printf("%s", buf);
 		color_end();
 		break;
 
 	case ZPOOL_STATUS_HOSTID_ACTIVE:
 		printf_color(ANSI_YELLOW, gettext("The pool is currently "
 		    "imported by another system.\n"));
 		break;
 
 	case ZPOOL_STATUS_HOSTID_REQUIRED:
 		printf_color(ANSI_YELLOW, gettext("The pool has the "
 		    "multihost property on.  It cannot\n"
 		    "\t%sbe safely imported when the system hostid is not "
 		    "set.\n"), indent);
 		break;
 
 	case ZPOOL_STATUS_HOSTID_MISMATCH:
 		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_YELLOW, gettext("One or more devices are "
 		    "faulted.\n"));
 		break;
 
 	case ZPOOL_STATUS_BAD_LOG:
 		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_YELLOW, gettext("One or more devices were "
 		    "being resilvered.\n"));
 		break;
 
 	case ZPOOL_STATUS_ERRATA:
 		printf_color(ANSI_YELLOW, gettext("Errata #%d detected.\n"),
 		    errata);
 		break;
 
 	case ZPOOL_STATUS_NON_NATIVE_ASHIFT:
 		printf_color(ANSI_YELLOW, gettext("One or more devices are "
 		    "configured to use a non-native block size.\n"
 		    "\t%sExpect reduced performance.\n"), indent);
 		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 ||
 	    reason != ZPOOL_STATUS_ERRATA || errata != ZPOOL_ERRATA_NONE) {
 		(void) printf("%s", indent);
 		(void) printf(gettext("action: "));
 	}
 	if (vs->vs_state == VDEV_STATE_HEALTHY) {
 		if (reason == ZPOOL_STATUS_VERSION_OLDER ||
 		    reason == ZPOOL_STATUS_FEAT_DISABLED) {
 			(void) printf(gettext("The pool can be imported using "
 			    "its name or numeric identifier, though\n"
 			    "\t%ssome features will not be available without "
 			    "an explicit 'zpool upgrade'.\n"), indent);
 		} else if (reason == ZPOOL_STATUS_COMPATIBILITY_ERR) {
 			(void) printf(gettext("The pool can be imported using "
 			    "its name or numeric\n"
 			    "\t%sidentifier, though the file(s) indicated by "
 			    "its 'compatibility'\n"
 			    "\t%sproperty cannot be parsed at this time.\n"),
 			    indent, indent);
 		} else if (reason == ZPOOL_STATUS_HOSTID_MISMATCH) {
 			(void) printf(gettext("The pool can be imported using "
 			    "its name or numeric identifier and\n"
 			    "\t%sthe '-f' flag.\n"), indent);
 		} else if (reason == ZPOOL_STATUS_ERRATA) {
 			switch (errata) {
 			case ZPOOL_ERRATA_ZOL_2094_SCRUB:
 				(void) printf(gettext("The pool can be "
 				    "imported using its name or numeric "
 				    "identifier,\n"
 				    "\t%showever there is a compatibility "
 				    "issue which should be corrected\n"
 				    "\t%sby running 'zpool scrub'\n"),
 				    indent, indent);
 				break;
 
 			case ZPOOL_ERRATA_ZOL_2094_ASYNC_DESTROY:
 				(void) printf(gettext("The pool cannot be "
 				    "imported with this version of ZFS due to\n"
 				    "\t%san active asynchronous destroy. "
 				    "Revert to an earlier version\n"
 				    "\t%sand allow the destroy to complete "
 				    "before updating.\n"), indent, indent);
 				break;
 
 			case ZPOOL_ERRATA_ZOL_6845_ENCRYPTION:
 				(void) printf(gettext("Existing encrypted "
 				    "datasets contain an on-disk "
 				    "incompatibility, which\n"
 				    "\t%sneeds to be corrected. Backup these "
 				    "datasets to new encrypted datasets\n"
 				    "\t%sand destroy the old ones.\n"),
 				    indent, indent);
 				break;
 
 			case ZPOOL_ERRATA_ZOL_8308_ENCRYPTION:
 				(void) printf(gettext("Existing encrypted "
 				    "snapshots and bookmarks contain an "
 				    "on-disk\n"
 				    "\t%sincompatibility. This may cause "
 				    "on-disk corruption if they are used\n"
 				    "\t%swith 'zfs recv'. To correct the "
 				    "issue, enable the bookmark_v2 feature.\n"
 				    "\t%sNo additional action is needed if "
 				    "there are no encrypted snapshots or\n"
 				    "\t%sbookmarks. If preserving the "
 				    "encrypted snapshots and bookmarks is\n"
 				    "\t%srequired, use a non-raw send to "
 				    "backup and restore them. Alternately,\n"
 				    "\t%sthey may be removed to resolve the "
 				    "incompatibility.\n"), indent, indent,
 				    indent, indent, indent, indent);
 				break;
 			default:
 				/*
 				 * All errata must contain an action message.
 				 */
 				assert(errata == ZPOOL_ERRATA_NONE);
 			}
 		} else {
 			(void) printf(gettext("The pool can be imported using "
 			    "its name or numeric identifier.\n"));
 		}
 	} else if (vs->vs_state == VDEV_STATE_DEGRADED) {
 		(void) printf(gettext("The pool can be imported despite "
 		    "missing or damaged devices.  The\n"
 		    "\t%sfault tolerance of the pool may be compromised if "
 		    "imported.\n"), indent);
 	} else {
 		switch (reason) {
 		case ZPOOL_STATUS_VERSION_NEWER:
 			(void) printf(gettext("The pool cannot be imported.  "
 			    "Access the pool on a system running newer\n"
 			    "\t%ssoftware, or recreate the pool from "
 			    "backup.\n"), indent);
 			break;
 		case ZPOOL_STATUS_UNSUP_FEAT_READ:
 			(void) printf(gettext("The pool cannot be imported. "
 			    "Access the pool on a system that supports\n"
 			    "\t%sthe required feature(s), or recreate the pool "
 			    "from backup.\n"), indent);
 			break;
 		case ZPOOL_STATUS_UNSUP_FEAT_WRITE:
 			(void) printf(gettext("The pool cannot be imported in "
 			    "read-write mode. Import the pool with\n"
 			    "\t%s'-o readonly=on', access the pool on a system "
 			    "that supports the\n"
 			    "\t%srequired feature(s), or recreate the pool "
 			    "from backup.\n"), indent, indent);
 			break;
 		case ZPOOL_STATUS_MISSING_DEV_R:
 		case ZPOOL_STATUS_MISSING_DEV_NR:
 		case ZPOOL_STATUS_BAD_GUID_SUM:
 			(void) printf(gettext("The pool cannot be imported. "
 			    "Attach the missing\n"
 			    "\t%sdevices and try again.\n"), indent);
 			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("The pool must be exported from "
 			    "%s (hostid=%"PRIx64")\n"
 			    "\t%sbefore it can be safely imported.\n"),
 			    hostname, hostid, indent);
 			break;
 		case ZPOOL_STATUS_HOSTID_REQUIRED:
 			(void) printf(gettext("Set a unique system hostid with "
 			    "the zgenhostid(8) command.\n"));
 			break;
 		default:
 			(void) printf(gettext("The pool cannot be imported due "
 			    "to damaged devices or data.\n"));
 		}
 	}
 
 	/* Print the comment attached to the pool. */
 	if (comment != NULL)
 		(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("\t%sThe pool was destroyed, "
 			    "but can be imported using the '-Df' flags.\n"),
 			    indent);
 		else if (pool_state != POOL_STATE_EXPORTED)
 			(void) printf(gettext("\t%sThe pool may be active on "
 			    "another system, but can be imported using\n"
 			    "\t%sthe '-f' flag.\n"), indent, indent);
 	}
 
 	if (msgid != NULL) {
 		(void) printf(gettext("%s   see: "
 		    "https://openzfs.github.io/openzfs-docs/msg/%s\n"),
 		    indent, msgid);
 	}
 
 	(void) printf(gettext("%sconfig:\n\n"), indent);
 
 	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\t%sAdditional devices are known to "
 		    "be part of this pool, though their\n"
 		    "\t%sexact configuration cannot be determined.\n"),
 		    indent, indent);
 	}
 	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);
 	nvinfo = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO);
 
 	/*
 	 * The hostid on LOAD_INFO comes from the MOS label via
 	 * spa_tryimport(). If its not there then we're likely talking to an
 	 * older kernel, so use the top one, which will be from the label
 	 * discovered in zpool_find_import(), or if a cachefile is in use, the
 	 * local hostid.
 	 */
 	if (nvlist_lookup_uint64(nvinfo, ZPOOL_CONFIG_HOSTID, &hostid) != 0)
 		(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_HOSTID,
 		    &hostid);
 
 	if (state != POOL_STATE_EXPORTED && hostid != get_system_hostid())
 		return (B_TRUE);
 
 	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, uint_t mntthreads)
 {
 	int ret = 0;
 	int ms_status = 0;
 	zpool_handle_t *zhp;
 	const 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) {
 			const 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%"PRIx64")\nExport the pool on the other "
 			    "system, then run 'zpool import'.\n"),
 			    name, hostname, 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 {
 			const char *hostname = "<unknown>";
 			time_t timestamp = 0;
 			uint64_t hostid = 0;
 
 			if (nvlist_exists(nvinfo, ZPOOL_CONFIG_HOSTNAME))
 				hostname = fnvlist_lookup_string(nvinfo,
 				    ZPOOL_CONFIG_HOSTNAME);
 			else 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(nvinfo, ZPOOL_CONFIG_HOSTID))
 				hostid = fnvlist_lookup_uint64(nvinfo,
 				    ZPOOL_CONFIG_HOSTID);
 			else 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=%"PRIx64") at %s"
 			    "The pool can be imported, use 'zpool import -f' "
 			    "to import the pool.\n"), name, hostname,
 			    hostid, ctime(&timestamp));
 		}
 
 		return (1);
 	}
 
 	if (zpool_import_props(g_zfs, config, newname, props, flags) != 0)
 		return (1);
 
 	if (newname != NULL)
 		name = 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 &&
 	    zfs_crypto_attempt_load_keys(g_zfs, name) != 0)
 			ret = 1;
 
 	if (zpool_get_state(zhp) != POOL_STATE_UNAVAIL &&
 	    !(flags & ZFS_IMPORT_ONLY)) {
 		ms_status = zpool_enable_datasets(zhp, mntopts, 0, mntthreads);
 		if (ms_status == EZFS_SHAREFAILED) {
 			(void) fprintf(stderr, gettext("Import was "
 			    "successful, but unable to share some datasets\n"));
 		} else if (ms_status == EZFS_MOUNTFAILED) {
 			(void) fprintf(stderr, gettext("Import was "
 			    "successful, but unable to mount some datasets\n"));
 		}
 	}
 
 	zpool_close(zhp);
 	return (ret);
 }
 
 typedef struct import_parameters {
 	nvlist_t *ip_config;
 	const char *ip_mntopts;
 	nvlist_t *ip_props;
 	int ip_flags;
 	uint_t ip_mntthreads;
 	int *ip_err;
 } import_parameters_t;
 
 static void
 do_import_task(void *arg)
 {
 	import_parameters_t *ip = arg;
 	*ip->ip_err |= do_import(ip->ip_config, NULL, ip->ip_mntopts,
 	    ip->ip_props, ip->ip_flags, ip->ip_mntthreads);
 	free(ip);
 }
 
 
 static int
 import_pools(nvlist_t *pools, nvlist_t *props, char *mntopts, int flags,
     char *orig_name, char *new_name, importargs_t *import)
 {
 	nvlist_t *config = NULL;
 	nvlist_t *found_config = NULL;
 	uint64_t pool_state;
 	boolean_t pool_specified = (import->poolname != NULL ||
 	    import->guid != 0);
 	uint_t npools = 0;
 
 
 	tpool_t *tp = NULL;
 	if (import->do_all) {
 		tp = tpool_create(1, 5 * sysconf(_SC_NPROCESSORS_ONLN),
 		    0, NULL);
 	}
 
 	/*
 	 * 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;
 	if (!pool_specified && import->do_all) {
 		while ((elem = nvlist_next_nvpair(pools, elem)) != NULL)
 			npools++;
 	}
 	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 (!import->do_destroyed &&
 		    pool_state == POOL_STATE_DESTROYED)
 			continue;
 		if (import->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 (!import->do_all)
 				(void) fputc('\n', stdout);
 
 			if (import->do_all) {
 				import_parameters_t *ip = safe_malloc(
 				    sizeof (import_parameters_t));
 
 				ip->ip_config = config;
 				ip->ip_mntopts = mntopts;
 				ip->ip_props = props;
 				ip->ip_flags = flags;
 				ip->ip_mntthreads = mount_tp_nthr / npools;
 				ip->ip_err = &err;
 
 				(void) tpool_dispatch(tp, do_import_task,
 				    (void *)ip);
 			} 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) {
 			const 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 (import->do_all) {
 		tpool_wait(tp);
 		tpool_destroy(tp);
 	}
 
 	/*
 	 * 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, mount_tp_nthr);
 		}
 	}
 
 	/*
 	 * 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) {
 		const 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 prefetch <type> [<type opts>] <pool>
  *
  * Prefetchs a particular type of data in the specified pool.
  */
 int
 zpool_do_prefetch(int argc, char **argv)
 {
 	int c;
 	char *poolname;
 	char *typestr = NULL;
 	zpool_prefetch_type_t type;
 	zpool_handle_t *zhp;
 	int err = 0;
 
 	while ((c = getopt(argc, argv, "t:")) != -1) {
 		switch (c) {
 		case 't':
 			typestr = optarg;
 			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 pool name argument\n"));
 		usage(B_FALSE);
 	}
 
 	if (argc > 1) {
 		(void) fprintf(stderr, gettext("too many arguments\n"));
 		usage(B_FALSE);
 	}
 
 	poolname = argv[0];
 
 	argc--;
 	argv++;
 
 	if (strcmp(typestr, "ddt") == 0) {
 		type = ZPOOL_PREFETCH_DDT;
 	} else {
 		(void) fprintf(stderr, gettext("unsupported prefetch type\n"));
 		usage(B_FALSE);
 	}
 
 	if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
 		return (1);
 
 	err = zpool_prefetch(zhp, type);
 
 	zpool_close(zhp);
 
 	return (err);
 }
 
 /*
  * 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;
 	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':
 			searchdirs = safe_realloc(searchdirs,
 			    (nsearch + 1) * sizeof (char *));
 			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))
 				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))
 				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"));
 
 		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;
 		}
 
 		/*
 		 * 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, *tmp = NULL;
 
 		envdup = strdup(env);
 
 		for (dir = strtok_r(envdup, ":", &tmp);
 		    dir != NULL;
 		    dir = strtok_r(NULL, ":", &tmp)) {
 			searchdirs = safe_realloc(searchdirs,
 			    (nsearch + 1) * sizeof (char *));
 			searchdirs[nsearch++] = dir;
 		}
 	}
 
 	idata.path = searchdirs;
 	idata.paths = nsearch;
 	idata.poolname = searchname;
 	idata.guid = searchguid;
 	idata.cachefile = cachefile;
 	idata.scan = do_scan;
 	idata.policy = policy;
 	idata.do_destroyed = do_destroyed;
 	idata.do_all = do_all;
 
 	libpc_handle_t lpch = {
 		.lpc_lib_handle = g_zfs,
 		.lpc_ops = &libzfs_config_ops,
 		.lpc_printerr = B_TRUE
 	};
 	pools = zpool_search_import(&lpch, &idata);
 
 	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) {
 		free(searchdirs);
 		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, &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(&lpch, &idata);
 
 		err = import_pools(pools, props, mntopts, flags,
 		    argc >= 1 ? argv[0] : NULL, argc >= 2 ? argv[1] : NULL,
 		    &idata);
 	}
 
 error:
 	nvlist_free(props);
 	nvlist_free(pools);
 	nvlist_free(policy);
 	free(searchdirs);
 	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, ZFS_TYPE_POOL,
 	    B_FALSE, zpool_sync_one, &force);
 
 	return (ret);
 }
 
 typedef struct iostat_cbdata {
 	uint64_t cb_flags;
 	int cb_namewidth;
 	int cb_iteration;
 	boolean_t cb_verbose;
 	boolean_t cb_literal;
 	boolean_t cb_scripted;
 	zpool_list_t *cb_list;
 	vdev_cmd_data_list_t *vcdl;
 	vdev_cbdata_t cb_vdevs;
 } 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	15	/* 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}, {"rebuild", 1},
 	    {NULL}},
 	[IOS_QUEUES] = {{"syncq_read", 2}, {"syncq_write", 2},
 	    {"asyncq_read", 2}, {"asyncq_write", 2}, {"scrubq_read", 2},
 	    {"trimq_write", 2}, {"rebuildq_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}, {"rebuild", 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"}, {"wait"},
 	    {NULL}},
 	[IOS_QUEUES] = {{"pend"}, {"activ"}, {"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"}, {"rebuild"},
 	    {NULL}},
 	[IOS_RQ_HISTO] = {{"ind"}, {"agg"}, {"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_vdevs.cb_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;
 
 	color_start(ANSI_BOLD);
 
 	if (cb->cb_flags & IOS_ANYHISTO_M) {
 		title = histo_to_title[IOS_HISTO_IDX(cb->cb_flags)];
 	} else if (cb->cb_vdevs.cb_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);
 
 	color_end();
 
 	printf("\n");
 }
 
 static void
 print_iostat_header(iostat_cbdata_t *cb)
 {
 	print_iostat_header_impl(cb, 0, NULL);
 }
 
 /*
  * Prints a size string (i.e. 120M) with the suffix ("M") colored
  * by order of magnitude. Uses column_size to add padding.
  */
 static void
 print_stat_color(const char *statbuf, unsigned int column_size)
 {
 	fputs("  ", stdout);
 	size_t len = strlen(statbuf);
 	while (len < column_size) {
 		fputc(' ', stdout);
 		column_size--;
 	}
 	if (*statbuf == '0') {
 		color_start(ANSI_GRAY);
 		fputc('0', stdout);
 	} else {
 		for (; *statbuf; statbuf++) {
 			if (*statbuf == 'K') color_start(ANSI_GREEN);
 			else if (*statbuf == 'M') color_start(ANSI_YELLOW);
 			else if (*statbuf == 'G') color_start(ANSI_RED);
 			else if (*statbuf == 'T') color_start(ANSI_BOLD_BLUE);
 			else if (*statbuf == 'P') color_start(ANSI_MAGENTA);
 			else if (*statbuf == 'E') color_start(ANSI_CYAN);
 			fputc(*statbuf, stdout);
 			if (--column_size <= 0)
 				break;
 		}
 	}
 	color_end();
 }
 
 /*
  * 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
 		print_stat_color(buf, column_size);
 }
 
 /*
  * 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 *newnv)
 {
 	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,
 		ZPOOL_CONFIG_VDEV_REBUILD_PEND_QUEUE,
 		ZPOOL_CONFIG_VDEV_REBUILD_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 (int i = 0; i < ARRAY_SIZE(names); i++) {
 		uint64_t 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,
 		ZPOOL_CONFIG_VDEV_REBUILD_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 *const 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_vdevs.cb_names_count; i++) {
 		/* Yes we do.  Is this the vdev? */
 		if (strcmp(name, cb->cb_vdevs.cb_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_vdevs.cb_names_count && (i == cb->cb_vdevs.cb_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, newnv);
 	if (cb->cb_flags & IOS_ANYHISTO_M) {
 		printf("\n");
 		print_iostat_histos(cb, oldnv, newnv, scale, name);
 	}
 
 	if (cb->vcdl != NULL) {
 		const 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_vdevs.cb_name_flags | VDEV_NAME_TYPE_ID);
 		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 < ARRAY_SIZE(class_name); n++) {
 		boolean_t printed = B_FALSE;
 
 		for (c = 0; c < children; c++) {
 			uint64_t islog = B_FALSE;
 			const char *bias = NULL;
 			const 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_vdevs.cb_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_vdevs.cb_name_flags | VDEV_NAME_TYPE_ID);
 			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_vdevs.cb_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_vdevs.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_vdevs.cb_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);
 		size_t 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_names[0] is this vdev's name, 0 otherwise.
  */
 static int
 is_vdev_cb(void *zhp_data, nvlist_t *nv, void *cb_data)
 {
 	uint64_t guid;
 	vdev_cbdata_t *cb = cb_data;
 	zpool_handle_t *zhp = zhp_data;
 
 	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0)
 		return (0);
 
 	return (guid == zpool_vdev_path_to_guid(zhp, cb->cb_names[0]));
 }
 
 /*
  * Returns 1 if cb_data->cb_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,
     vdev_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_names for a second... */
 	tmp_name = cb->cb_names;
 
 	/* Go though our list of prospective vdev names */
 	for (i = 0; i < argc; i++) {
 		cb->cb_names = argv + i;
 
 		/* Is this name a vdev in our pools? */
 		ret = for_each_pool(pool_count, &pool_name, B_TRUE, NULL,
 		    ZFS_TYPE_POOL, B_FALSE, is_vdev, cb);
 		if (!ret) {
 			/* No match */
 			break;
 		}
 	}
 
 	cb->cb_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, ZFS_TYPE_POOL, 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,
     vdev_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_vdevs.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->cb_vdevs)) {
 		/*
 		 * 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->cb_vdevs)) {
 			/*
 			 * 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);
 }
 
 /*
  * 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, (char *)"-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) {
 			if (snprintf(fullpath, sizeof (fullpath), "%s/%s",
 			    dirpath, ent->d_name) >= sizeof (fullpath)) {
 				(void) fprintf(stderr,
 				    gettext("internal error: "
 				    "ZPOOL_SCRIPTS_PATH too large.\n"));
 				exit(1);
 			}
 
 			/* 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(const char *subcommand)
 {
 	char *dir, *sp, *tmp;
 
 	printf(gettext("Available 'zpool %s -c' commands:\n"), subcommand);
 
 	sp = zpool_get_cmd_search_path();
 	if (sp == NULL)
 		return;
 
 	for (dir = strtok_r(sp, ":", &tmp);
 	    dir != NULL;
 	    dir = strtok_r(NULL, ":", &tmp))
 		print_zpool_dir_scripts(dir);
 
 	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_vdevs.cb_name_flags | VDEV_NAME_TYPE_ID, 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_vdevs.cb_name_flags |= VDEV_NAME_GUID;
 	if (follow_links)
 		cb.cb_vdevs.cb_name_flags |= VDEV_NAME_FOLLOW_LINKS;
 	if (full_name)
 		cb.cb_vdevs.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.cb_vdevs)) {
 		/* All the args are vdevs */
 		cb.cb_vdevs.cb_names = argv;
 		cb.cb_vdevs.cb_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.cb_vdevs)) {
 			/* ...and the rest are vdev names */
 			cb.cb_vdevs.cb_names = argv + 1;
 			cb.cb_vdevs.cb_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.cb_vdevs);
 			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_vdevs.cb_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, ZFS_TYPE_POOL, 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_vdevs.cb_names,
 				    cb.cb_vdevs.cb_names_count,
 				    cb.cb_vdevs.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) fflush(stdout);
 				(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_vdevs.cb_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);
 
 		}
 
 		if (interval == 0)
 			break;
 
 		if (count != 0 && --count == 0)
 			break;
 
 		(void) fflush(stdout);
 		(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_json;
 	boolean_t	cb_scripted;
 	zprop_list_t	*cb_proplist;
 	boolean_t	cb_literal;
 	nvlist_t	*cb_jsobj;
 	boolean_t	cb_json_as_int;
 	boolean_t	cb_json_pool_key_guid;
 } 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) fputs("  ", stdout);
 		else
 			first = B_FALSE;
 
 		right_justify = B_FALSE;
 		if (pl->pl_prop != ZPROP_USERPROP) {
 			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) fputs(header, stdout);
 		else if (right_justify)
 			(void) printf("%*s", (int)width, header);
 		else
 			(void) printf("%-*s", (int)width, header);
 	}
 
 	(void) fputc('\n', stdout);
 }
 
 /*
  * 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
 collect_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];
 	const char *propstr;
 	boolean_t right_justify;
 	size_t width;
 	zprop_source_t sourcetype = ZPROP_SRC_NONE;
 	nvlist_t *item, *d, *props;
 	item = d = props = NULL;
 
 	if (cb->cb_json) {
 		item = fnvlist_alloc();
 		props = fnvlist_alloc();
 		d = fnvlist_lookup_nvlist(cb->cb_jsobj, "pools");
 		if (d == NULL) {
 			fprintf(stderr, "pools obj not found.\n");
 			exit(1);
 		}
 		fill_pool_info(item, zhp, B_TRUE, cb->cb_json_as_int);
 	}
 
 	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 (!cb->cb_json && !first) {
 			if (cb->cb_scripted)
 				(void) fputc('\t', stdout);
 			else
 				(void) fputs("  ", stdout);
 		} else {
 			first = B_FALSE;
 		}
 
 		right_justify = B_FALSE;
 		if (pl->pl_prop != ZPROP_USERPROP) {
 			if (zpool_get_prop(zhp, pl->pl_prop, property,
 			    sizeof (property), &sourcetype,
 			    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;
 			sourcetype = ZPROP_SRC_LOCAL;
 		} else if (zfs_prop_user(pl->pl_user_prop) &&
 		    zpool_get_userprop(zhp, pl->pl_user_prop, property,
 		    sizeof (property), &sourcetype) == 0) {
 			propstr = property;
 		} else {
 			propstr = "-";
 		}
 
 		if (cb->cb_json) {
 			if (pl->pl_prop == ZPOOL_PROP_NAME)
 				continue;
 			(void) zprop_nvlist_one_property(
 			    zpool_prop_to_name(pl->pl_prop), propstr,
 			    sourcetype, NULL, NULL, props, cb->cb_json_as_int);
 		} else {
 			/*
 			 * 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) fputs(propstr, stdout);
 			else if (right_justify)
 				(void) printf("%*s", (int)width, propstr);
 			else
 				(void) printf("%-*s", (int)width, propstr);
 		}
 	}
 
 	if (cb->cb_json) {
 		fnvlist_add_nvlist(item, "properties", props);
 		if (cb->cb_json_pool_key_guid) {
 			char pool_guid[256];
 			uint64_t guid = fnvlist_lookup_uint64(
 			    zpool_get_config(zhp, NULL),
 			    ZPOOL_CONFIG_POOL_GUID);
 			snprintf(pool_guid, 256, "%llu",
 			    (u_longlong_t)guid);
 			fnvlist_add_nvlist(d, pool_guid, item);
 		} else {
 			fnvlist_add_nvlist(d, zpool_get_name(zhp),
 			    item);
 		}
 		fnvlist_free(props);
 		fnvlist_free(item);
 	} else
 		(void) fputc('\n', stdout);
 }
 
 static void
 collect_vdev_prop(zpool_prop_t prop, uint64_t value, const char *str,
     boolean_t scripted, boolean_t valid, enum zfs_nicenum_format format,
     boolean_t json, nvlist_t *nvl, boolean_t as_int)
 {
 	char propval[64];
 	boolean_t fixed;
 	size_t width = zprop_width(prop, &fixed, ZFS_TYPE_POOL);
 
 	switch (prop) {
 	case ZPOOL_PROP_SIZE:
 	case ZPOOL_PROP_EXPANDSZ:
 	case ZPOOL_PROP_CHECKPOINT:
 	case ZPOOL_PROP_DEDUPRATIO:
 	case ZPOOL_PROP_DEDUPCACHED:
 		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 (json) {
 		zprop_nvlist_one_property(zpool_prop_to_name(prop), propval,
 		    ZPROP_SRC_NONE, NULL, NULL, nvl, as_int);
 	} else {
 		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
 collect_list_stats(zpool_handle_t *zhp, const char *name, nvlist_t *nv,
     list_cbdata_t *cb, int depth, boolean_t isspare, nvlist_t *item)
 {
 	nvlist_t **child;
 	vdev_stat_t *vs;
 	uint_t c, children = 0;
 	char *vname;
 	boolean_t scripted = cb->cb_scripted;
 	uint64_t islog = B_FALSE;
 	nvlist_t *props, *ent, *ch, *obj, *l2c, *sp;
 	props = ent = ch = obj = sp = l2c = NULL;
 	const 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 (cb->cb_json) {
 			props = fnvlist_alloc();
 			ent = fnvlist_alloc();
 			fill_vdev_info(ent, zhp, (char *)name, B_FALSE,
 			    cb->cb_json_as_int);
 		} else {
 			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.
 		 */
 		if (VDEV_STAT_VALID(vs_pspace, c) && vs->vs_pspace) {
 			collect_vdev_prop(ZPOOL_PROP_SIZE, vs->vs_pspace, NULL,
 			    scripted, B_TRUE, format, cb->cb_json, props,
 			    cb->cb_json_as_int);
 		} else {
 			collect_vdev_prop(ZPOOL_PROP_SIZE, vs->vs_space, NULL,
 			    scripted, toplevel, format, cb->cb_json, props,
 			    cb->cb_json_as_int);
 		}
 		collect_vdev_prop(ZPOOL_PROP_ALLOCATED, vs->vs_alloc, NULL,
 		    scripted, toplevel, format, cb->cb_json, props,
 		    cb->cb_json_as_int);
 		collect_vdev_prop(ZPOOL_PROP_FREE, vs->vs_space - vs->vs_alloc,
 		    NULL, scripted, toplevel, format, cb->cb_json, props,
 		    cb->cb_json_as_int);
 		collect_vdev_prop(ZPOOL_PROP_CHECKPOINT,
 		    vs->vs_checkpoint_space, NULL, scripted, toplevel, format,
 		    cb->cb_json, props, cb->cb_json_as_int);
 		collect_vdev_prop(ZPOOL_PROP_EXPANDSZ, vs->vs_esize, NULL,
 		    scripted, B_TRUE, format, cb->cb_json, props,
 		    cb->cb_json_as_int);
 		collect_vdev_prop(ZPOOL_PROP_FRAGMENTATION,
 		    vs->vs_fragmentation, NULL, scripted,
 		    (vs->vs_fragmentation != ZFS_FRAG_INVALID && toplevel),
 		    format, cb->cb_json, props, cb->cb_json_as_int);
 		cap = (vs->vs_space == 0) ? 0 :
 		    (vs->vs_alloc * 10000 / vs->vs_space);
 		collect_vdev_prop(ZPOOL_PROP_CAPACITY, cap, NULL,
 		    scripted, toplevel, format, cb->cb_json, props,
 		    cb->cb_json_as_int);
 		collect_vdev_prop(ZPOOL_PROP_DEDUPRATIO, 0, NULL,
 		    scripted, toplevel, format, cb->cb_json, props,
 		    cb->cb_json_as_int);
 		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";
 		}
 		collect_vdev_prop(ZPOOL_PROP_HEALTH, 0, state, scripted,
 		    B_TRUE, format, cb->cb_json, props, cb->cb_json_as_int);
 
 		if (cb->cb_json) {
 			fnvlist_add_nvlist(ent, "properties", props);
 			fnvlist_free(props);
 		} else
 			(void) fputc('\n', stdout);
 	}
 
 	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
 	    &child, &children) != 0) {
 		if (cb->cb_json) {
 			fnvlist_add_nvlist(item, name, ent);
 			fnvlist_free(ent);
 		}
 		return;
 	}
 
 	if (cb->cb_json) {
 		ch = fnvlist_alloc();
 	}
 
 	/* 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 | VDEV_NAME_TYPE_ID);
 
 		if (name == NULL || cb->cb_json != B_TRUE)
 			collect_list_stats(zhp, vname, child[c], cb, depth + 2,
 			    B_FALSE, item);
 		else if (cb->cb_json) {
 			collect_list_stats(zhp, vname, child[c], cb, depth + 2,
 			    B_FALSE, ch);
 		}
 		free(vname);
 	}
 
 	if (cb->cb_json) {
 		if (!nvlist_empty(ch))
 			fnvlist_add_nvlist(ent, "vdevs", ch);
 		fnvlist_free(ch);
 	}
 
 	/* list the classes: 'logs', 'dedup', and 'special' */
 	for (uint_t n = 0; n < ARRAY_SIZE(class_name); n++) {
 		boolean_t printed = B_FALSE;
 		if (cb->cb_json)
 			obj = fnvlist_alloc();
 		for (c = 0; c < children; c++) {
 			const char *bias = NULL;
 			const 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 && !cb->cb_json) {
 				/* 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 | VDEV_NAME_TYPE_ID);
 			collect_list_stats(zhp, vname, child[c], cb, depth + 2,
 			    B_FALSE, obj);
 			free(vname);
 		}
 		if (cb->cb_json) {
 			if (!nvlist_empty(obj))
 				fnvlist_add_nvlist(item, class_name[n], obj);
 			fnvlist_free(obj);
 		}
 	}
 
 	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE,
 	    &child, &children) == 0 && children > 0) {
 		if (cb->cb_json) {
 			l2c = fnvlist_alloc();
 		} else {
 			/* 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);
 			collect_list_stats(zhp, vname, child[c], cb, depth + 2,
 			    B_FALSE, l2c);
 			free(vname);
 		}
 		if (cb->cb_json) {
 			if (!nvlist_empty(l2c))
 				fnvlist_add_nvlist(item, "l2cache", l2c);
 			fnvlist_free(l2c);
 		}
 	}
 
 	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, &child,
 	    &children) == 0 && children > 0) {
 		if (cb->cb_json) {
 			sp = fnvlist_alloc();
 		} else {
 			/* 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);
 			collect_list_stats(zhp, vname, child[c], cb, depth + 2,
 			    B_TRUE, sp);
 			free(vname);
 		}
 		if (cb->cb_json) {
 			if (!nvlist_empty(sp))
 				fnvlist_add_nvlist(item, "spares", sp);
 			fnvlist_free(sp);
 		}
 	}
 
 	if (name != NULL && cb->cb_json) {
 		fnvlist_add_nvlist(item, name, ent);
 		fnvlist_free(ent);
 	}
 }
 
 /*
  * Generic callback function to list a pool.
  */
 static int
 list_callback(zpool_handle_t *zhp, void *data)
 {
 	nvlist_t *p, *d, *nvdevs;
 	uint64_t guid;
 	char pool_guid[256];
 	const char *pool_name = zpool_get_name(zhp);
 	list_cbdata_t *cbp = data;
 	p = d = nvdevs = NULL;
 
 	collect_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);
 		if (cbp->cb_json) {
 			d = fnvlist_lookup_nvlist(cbp->cb_jsobj,
 			    "pools");
 			if (cbp->cb_json_pool_key_guid) {
 				guid = fnvlist_lookup_uint64(config,
 				    ZPOOL_CONFIG_POOL_GUID);
 				snprintf(pool_guid, 256, "%llu",
 				    (u_longlong_t)guid);
 				p = fnvlist_lookup_nvlist(d, pool_guid);
 			} else {
 				p = fnvlist_lookup_nvlist(d, pool_name);
 			}
 			nvdevs = fnvlist_alloc();
 		}
 		collect_list_stats(zhp, NULL, nvroot, cbp, 0, B_FALSE, nvdevs);
 		if (cbp->cb_json) {
 			fnvlist_add_nvlist(p, "vdevs", nvdevs);
 			if (cbp->cb_json_pool_key_guid)
 				fnvlist_add_nvlist(d, pool_guid, p);
 			else
 				fnvlist_add_nvlist(d, pool_name, p);
 			fnvlist_add_nvlist(cbp->cb_jsobj, "pools", d);
 			fnvlist_free(nvdevs);
 		}
 	}
 
 	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 | VDEV_NAME_TYPE_ID, 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
  *	-j	Display the output in JSON format
  *	--json-int	Display the numbers as integer instead of strings.
  *	--json-pool-key-guid  Set pool GUID as key for pool objects.
  *
  * 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;
 	nvlist_t *data = NULL;
 	current_prop_type = ZFS_TYPE_POOL;
 
 	struct option long_options[] = {
+		{"json", no_argument, NULL, 'j'},
 		{"json-int", no_argument, NULL, ZPOOL_OPTION_JSON_NUMS_AS_INT},
 		{"json-pool-key-guid", no_argument, NULL,
 		    ZPOOL_OPTION_POOL_KEY_GUID},
 		{0, 0, 0, 0}
 	};
 
 	/* check options */
 	while ((c = getopt_long(argc, argv, ":gjHLo:pPT:v", long_options,
 	    NULL)) != -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 'j':
 			cb.cb_json = B_TRUE;
 			break;
 		case ZPOOL_OPTION_JSON_NUMS_AS_INT:
 			cb.cb_json_as_int = B_TRUE;
 			cb.cb_literal = B_TRUE;
 			break;
 		case ZPOOL_OPTION_POOL_KEY_GUID:
 			cb.cb_json_pool_key_guid = 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;
 
 	if (!cb.cb_json && cb.cb_json_as_int) {
 		(void) fprintf(stderr, gettext("'--json-int' only works with"
 		    " '-j' option\n"));
 		usage(B_FALSE);
 	}
 
 	if (!cb.cb_json && cb.cb_json_pool_key_guid) {
 		(void) fprintf(stderr, gettext("'json-pool-key-guid' only"
 		    " works with '-j' option\n"));
 		usage(B_FALSE);
 	}
 
 	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,
 		    ZFS_TYPE_POOL, cb.cb_literal, &ret)) == NULL)
 			return (1);
 
 		if (pool_list_count(list) == 0)
 			break;
 
 		if (cb.cb_json) {
 			cb.cb_jsobj = zpool_json_schema(0, 1);
 			data = fnvlist_alloc();
 			fnvlist_add_nvlist(cb.cb_jsobj, "pools", data);
 			fnvlist_free(data);
 		}
 
 		cb.cb_namewidth = 0;
 		(void) pool_list_iter(list, B_FALSE, get_namewidth_list, &cb);
 
 		if (timestamp_fmt != NODATE) {
 			if (cb.cb_json) {
 				if (cb.cb_json_as_int) {
 					fnvlist_add_uint64(cb.cb_jsobj, "time",
 					    time(NULL));
 				} else {
 					char ts[128];
 					get_timestamp(timestamp_fmt, ts, 128);
 					fnvlist_add_string(cb.cb_jsobj, "time",
 					    ts);
 				}
 			} else
 				print_timestamp(timestamp_fmt);
 		}
 
 		if (!cb.cb_scripted && (first || cb.cb_verbose) &&
 		    !cb.cb_json) {
 			print_header(&cb);
 			first = B_FALSE;
 		}
 		ret = pool_list_iter(list, B_TRUE, list_callback, &cb);
 
 		if (ret == 0 && cb.cb_json)
 			zcmd_print_json(cb.cb_jsobj);
 		else if (ret != 0 && cb.cb_json)
 			nvlist_free(cb.cb_jsobj);
 
 		if (interval == 0)
 			break;
 
 		if (count != 0 && --count == 0)
 			break;
 
 		pool_list_free(list);
 
 		(void) fflush(stdout);
 		(void) fsleep(interval);
 	}
 
 	if (argc == 0 && !cb.cb_scripted && !cb.cb_json &&
 	    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) {
 		zpool_wait_activity_t activity = ZPOOL_WAIT_RESILVER;
 		char raidz_prefix[] = "raidz";
 		if (replacing) {
 			activity = ZPOOL_WAIT_REPLACE;
 		} else if (strncmp(old_disk,
 		    raidz_prefix, strlen(raidz_prefix)) == 0) {
 			activity = ZPOOL_WAIT_RAIDZ_EXPAND;
 		}
 		ret = zpool_wait(zhp, activity);
 	}
 
 	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>.
  */
 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>|<vdev> <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 (mirror) or expansion (raidz) to complete
  *		before returning.
  *
  * Attach <new_device> to a <device> or <vdev>, where the vdev can be of type
  * mirror or raidz. If <device> is not part of a mirror, then <device> will
  * be transformed into a mirror of <device> and <new_device>. When a mirror
  * is involved, <new_device> will begin life with a DTL of [0, now], and will
  * immediately begin to resilver itself. For the raidz case, a expansion will
  * commence and reflow the raidz data across all the disks including the
  * <new_device>.
  */
 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.
  */
 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;
 	int ms_status = 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) {
 		ms_status = zpool_enable_datasets(zhp, mntopts, 0,
 		    mount_tp_nthr);
 		if (ms_status == EZFS_SHAREFAILED) {
 			(void) fprintf(stderr, gettext("Split was successful, "
 			    "datasets are mounted but sharing of some datasets "
 			    "has failed\n"));
 		} else if (ms_status == EZFS_MOUNTFAILED) {
 			(void) fprintf(stderr, gettext("Split was successful"
 			    ", but some datasets could not 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 [--power] <pool> <device> ...
  *
  * --power: Power on the enclosure slot to the drive (if possible)
  */
 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;
 	boolean_t is_power_on = B_FALSE;
 	struct option long_options[] = {
 		{"power", no_argument, NULL, ZPOOL_OPTION_POWER},
 		{0, 0, 0, 0}
 	};
 
 	/* check options */
 	while ((c = getopt_long(argc, argv, "e", long_options, NULL)) != -1) {
 		switch (c) {
 		case 'e':
 			flags |= ZFS_ONLINE_EXPAND;
 			break;
 		case ZPOOL_OPTION_POWER:
 			is_power_on = B_TRUE;
 			break;
 		case '?':
 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
 			    optopt);
 			usage(B_FALSE);
 		}
 	}
 
 	if (libzfs_envvar_is_set("ZPOOL_AUTO_POWER_ON_SLOT"))
 		is_power_on = B_TRUE;
 
 	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++) {
 		vdev_state_t oldstate;
 		boolean_t avail_spare, l2cache;
 		int rc;
 
 		if (is_power_on) {
 			rc = zpool_power_on_and_disk_wait(zhp, argv[i]);
 			if (rc == ENOTSUP) {
 				(void) fprintf(stderr,
 				    gettext("Power control not supported\n"));
 			}
 			if (rc != 0)
 				return (rc);
 		}
 
 		nvlist_t *tgt = zpool_find_vdev(zhp, argv[i], &avail_spare,
 		    &l2cache, NULL);
 		if (tgt == NULL) {
 			ret = 1;
 			continue;
 		}
 		uint_t vsc;
 		oldstate = ((vdev_stat_t *)fnvlist_lookup_uint64_array(tgt,
 		    ZPOOL_CONFIG_VDEV_STATS, &vsc))->vs_state;
 		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"));
 				if ((flags & ZFS_ONLINE_EXPAND)) {
 					(void) printf(gettext("%s: failed "
 					    "to expand usable space on "
 					    "unhealthy device '%s'\n"),
 					    (oldstate >= VDEV_STATE_DEGRADED ?
 					    "error" : "warning"), argv[i]);
 					if (oldstate >= VDEV_STATE_DEGRADED) {
 						ret = 1;
 						break;
 					}
 				}
 			}
 		} else {
 			ret = 1;
 		}
 	}
 
 	zpool_close(zhp);
 
 	return (ret);
 }
 
 /*
  * zpool offline [-ft]|[--power] <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.
  *
  *	--power Power off the enclosure slot to the drive (if possible)
  */
 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;
 	boolean_t is_power_off = B_FALSE;
 
 	struct option long_options[] = {
 		{"power", no_argument, NULL, ZPOOL_OPTION_POWER},
 		{0, 0, 0, 0}
 	};
 
 	/* check options */
 	while ((c = getopt_long(argc, argv, "ft", long_options, NULL)) != -1) {
 		switch (c) {
 		case 'f':
 			fault = B_TRUE;
 			break;
 		case 't':
 			istmp = B_TRUE;
 			break;
 		case ZPOOL_OPTION_POWER:
 			is_power_off = B_TRUE;
 			break;
 		case '?':
 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
 			    optopt);
 			usage(B_FALSE);
 		}
 	}
 
 	if (is_power_off && fault) {
 		(void) fprintf(stderr,
 		    gettext("-0 and -f cannot be used together\n"));
 		usage(B_FALSE);
 		return (1);
 	}
 
 	if (is_power_off && istmp) {
 		(void) fprintf(stderr,
 		    gettext("-0 and -t cannot be used together\n"));
 		usage(B_FALSE);
 		return (1);
 	}
 
 	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++) {
 		uint64_t guid = zpool_vdev_path_to_guid(zhp, argv[i]);
 		if (is_power_off) {
 			/*
 			 * Note: we have to power off first, then set REMOVED,
 			 * or else zpool_vdev_set_removed_state() returns
 			 * EAGAIN.
 			 */
 			ret = zpool_power_off(zhp, argv[i]);
 			if (ret != 0) {
 				(void) fprintf(stderr, "%s %s %d\n",
 				    gettext("unable to power off slot for"),
 				    argv[i], ret);
 			}
 			zpool_vdev_set_removed_state(zhp, guid, VDEV_AUX_NONE);
 
 		} else if (fault) {
 			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 [-nF]|[--power] <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;
 	boolean_t is_power_on = B_FALSE;
 	uint32_t rewind_policy = ZPOOL_NO_REWIND;
 	nvlist_t *policy = NULL;
 	zpool_handle_t *zhp;
 	char *pool, *device;
 
 	struct option long_options[] = {
 		{"power", no_argument, NULL, ZPOOL_OPTION_POWER},
 		{0, 0, 0, 0}
 	};
 
 	/* check options */
 	while ((c = getopt_long(argc, argv, "FnX", long_options,
 	    NULL)) != -1) {
 		switch (c) {
 		case 'F':
 			do_rewind = B_TRUE;
 			break;
 		case 'n':
 			dryrun = B_TRUE;
 			break;
 		case 'X':
 			xtreme_rewind = B_TRUE;
 			break;
 		case ZPOOL_OPTION_POWER:
 			is_power_on = B_TRUE;
 			break;
 		case '?':
 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
 			    optopt);
 			usage(B_FALSE);
 		}
 	}
 
 	if (libzfs_envvar_is_set("ZPOOL_AUTO_POWER_ON_SLOT"))
 		is_power_on = B_TRUE;
 
 	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 (is_power_on) {
 		if (device == NULL) {
 			zpool_power_on_pool_and_wait_for_devices(zhp);
 		} else {
 			zpool_power_on_and_disk_wait(zhp, device);
 		}
 	}
 
 	if (zpool_clear(zhp, device, policy) != 0)
 		ret = 1;
 
 	zpool_close(zhp);
 
 	nvlist_free(policy);
 
 	return (ret);
 }
 
 /*
  * zpool reguid [-g <guid>] <pool>
  */
 int
 zpool_do_reguid(int argc, char **argv)
 {
 	uint64_t guid;
 	uint64_t *guidp = NULL;
 	int c;
 	char *endptr;
 	char *poolname;
 	zpool_handle_t *zhp;
 	int ret = 0;
 
 	/* check options */
 	while ((c = getopt(argc, argv, "g:")) != -1) {
 		switch (c) {
 		case 'g':
 			errno = 0;
 			guid = strtoull(optarg, &endptr, 10);
 			if (errno != 0 || *endptr != '\0') {
 				(void) fprintf(stderr,
 				    gettext("invalid GUID: %s\n"), optarg);
 				usage(B_FALSE);
 			}
 			guidp = &guid;
 			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 > 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_set_guid(zhp, guidp);
 
 	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, ZFS_TYPE_POOL,
 	    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] [-e] <pool> ...
  *
  *	-e	Only scrub blocks in the error log.
  *	-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;
 
 	boolean_t is_error_scrub = B_FALSE;
 	boolean_t is_pause = B_FALSE;
 	boolean_t is_stop = B_FALSE;
 
 	/* check options */
 	while ((c = getopt(argc, argv, "spwe")) != -1) {
 		switch (c) {
 		case 'e':
 			is_error_scrub = B_TRUE;
 			break;
 		case 's':
 			is_stop = B_TRUE;
 			break;
 		case 'p':
 			is_pause = B_TRUE;
 			break;
 		case 'w':
 			wait = B_TRUE;
 			break;
 		case '?':
 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
 			    optopt);
 			usage(B_FALSE);
 		}
 	}
 
 	if (is_pause && is_stop) {
 		(void) fprintf(stderr, gettext("invalid option "
 		    "combination :-s and -p are mutually exclusive\n"));
 		usage(B_FALSE);
 	} else {
 		if (is_error_scrub)
 			cb.cb_type = POOL_SCAN_ERRORSCRUB;
 
 		if (is_pause) {
 			cb.cb_scrub_cmd = POOL_SCRUB_PAUSE;
 		} else if (is_stop) {
 			cb.cb_type = POOL_SCAN_NONE;
 		} else {
 			cb.cb_scrub_cmd = POOL_SCRUB_NORMAL;
 		}
 	}
 
 	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, ZFS_TYPE_POOL,
 	    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, ZFS_TYPE_POOL,
 		    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, ZFS_TYPE_POOL,
 	    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(g_zfs, optarg, &rate) == -1) {
 				(void) fprintf(stderr, "%s: %s\n",
 				    gettext("invalid value for rate"),
 				    libzfs_error_description(g_zfs));
 				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 error scrub status.
  */
 static void
 print_err_scrub_status(pool_scan_stat_t *ps)
 {
 	time_t start, end, pause;
 	uint64_t total_secs_left;
 	uint64_t secs_left, mins_left, hours_left, days_left;
 	uint64_t examined, to_be_examined;
 
 	if (ps == NULL || ps->pss_error_scrub_func != POOL_SCAN_ERRORSCRUB) {
 		return;
 	}
 
 	(void) printf(gettext(" scrub: "));
 
 	start = ps->pss_error_scrub_start;
 	end = ps->pss_error_scrub_end;
 	pause = ps->pss_pass_error_scrub_pause;
 	examined = ps->pss_error_scrub_examined;
 	to_be_examined = ps->pss_error_scrub_to_be_examined;
 
 	assert(ps->pss_error_scrub_func == POOL_SCAN_ERRORSCRUB);
 
 	if (ps->pss_error_scrub_state == DSS_FINISHED) {
 		total_secs_left = end - start;
 		days_left = total_secs_left / 60 / 60 / 24;
 		hours_left = (total_secs_left / 60 / 60) % 24;
 		mins_left = (total_secs_left / 60) % 60;
 		secs_left = (total_secs_left % 60);
 
 		(void) printf(gettext("scrubbed %llu error blocks in %llu days "
 		    "%02llu:%02llu:%02llu on %s"), (u_longlong_t)examined,
 		    (u_longlong_t)days_left, (u_longlong_t)hours_left,
 		    (u_longlong_t)mins_left, (u_longlong_t)secs_left,
 		    ctime(&end));
 
 		return;
 	} else if (ps->pss_error_scrub_state == DSS_CANCELED) {
 		(void) printf(gettext("error scrub canceled on %s"),
 		    ctime(&end));
 		return;
 	}
 	assert(ps->pss_error_scrub_state == DSS_ERRORSCRUBBING);
 
 	/* Error scrub is in progress. */
 	if (pause == 0) {
 		(void) printf(gettext("error scrub in progress since %s"),
 		    ctime(&start));
 	} else {
 		(void) printf(gettext("error scrub paused since %s"),
 		    ctime(&pause));
 		(void) printf(gettext("\terror scrub started on %s"),
 		    ctime(&start));
 	}
 
 	double fraction_done = (double)examined / (to_be_examined + examined);
 	(void) printf(gettext("\t%.2f%% done, issued I/O for %llu error"
 	    " blocks"), 100 * fraction_done, (u_longlong_t)examined);
 
 	(void) printf("\n");
 }
 
 /*
  * 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_s, total_i;
 	uint64_t elapsed, scan_rate, issue_rate;
 	double fraction_done;
 	char processed_buf[7], scanned_buf[7], issued_buf[7], total_s_buf[7];
 	char total_i_buf[7], 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));
 
 	int is_resilver = ps->pss_func == POOL_SCAN_RESILVER;
 	int is_scrub = ps->pss_func == POOL_SCAN_SCRUB;
 	assert(is_resilver || is_scrub);
 
 	/* Scan is finished or canceled. */
 	if (ps->pss_state == DSS_FINISHED) {
 		secs_to_dhms(end - start, time_buf);
 
 		if (is_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 (is_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 (is_scrub) {
 			(void) printf(gettext("scrub canceled on %s"),
 			    ctime(&end));
 		} else if (is_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 (is_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 (is_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_s = ps->pss_to_examine;
 	total_i = ps->pss_to_examine - ps->pss_skipped;
 
 	/* we are only done with a block once we have issued the IO for it */
 	fraction_done = (double)issued / total_i;
 
 	/* 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;
 
 	/* 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_s, total_s_buf, sizeof (total_s_buf));
 	zfs_nicebytes(total_i, total_i_buf, sizeof (total_i_buf));
 
 	/* do not print estimated time if we have a paused scrub */
 	(void) printf(gettext("\t%s / %s scanned"), scanned_buf, total_s_buf);
 	if (pause == 0 && scan_rate > 0) {
 		zfs_nicebytes(scan_rate, srate_buf, sizeof (srate_buf));
 		(void) printf(gettext(" at %s/s"), srate_buf);
 	}
 	(void) printf(gettext(", %s / %s issued"), issued_buf, total_i_buf);
 	if (pause == 0 && issue_rate > 0) {
 		zfs_nicebytes(issue_rate, irate_buf, sizeof (irate_buf));
 		(void) printf(gettext(" at %s/s"), irate_buf);
 	}
 	(void) printf(gettext("\n"));
 
 	if (is_resilver) {
 		(void) printf(gettext("\t%s resilvered, %.2f%% done"),
 		    processed_buf, 100 * fraction_done);
 	} else if (is_scrub) {
 		(void) printf(gettext("\t%s repaired, %.2f%% done"),
 		    processed_buf, 100 * fraction_done);
 	}
 
 	if (pause == 0) {
 		/*
 		 * Only provide an estimate iff:
 		 * 1) we haven't yet issued all we expected, and
 		 * 2) the issue rate exceeds 10 MB/s, and
 		 * 3) it's either:
 		 *    a) a resilver which has started repairs, or
 		 *    b) a scrub which has entered the issue phase.
 		 */
 		if (total_i >= issued && issue_rate >= 10 * 1024 * 1024 &&
 		    ((is_resilver && ps->pss_processed > 0) ||
 		    (is_scrub && issued > 0))) {
 			secs_to_dhms((total_i - issued) / issue_rate, time_buf);
 			(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, uint_t c, 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_s = vrs->vrs_bytes_est;
 	uint64_t bytes_est_i = vrs->vrs_bytes_est;
 	if (c > offsetof(vdev_rebuild_stat_t, vrs_pass_bytes_skipped) / 8)
 		bytes_est_i -= vrs->vrs_pass_bytes_skipped;
 	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_s + 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_s_buf[7], bytes_est_i_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_s, bytes_est_s_buf, sizeof (bytes_est_s_buf));
 	zfs_nicebytes(bytes_est_i, bytes_est_i_buf, sizeof (bytes_est_i_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);
 
 	(void) printf(gettext("\t%s / %s scanned"), bytes_scanned_buf,
 	    bytes_est_s_buf);
 	if (scan_rate > 0) {
 		zfs_nicebytes(scan_rate, scan_rate_buf, sizeof (scan_rate_buf));
 		(void) printf(gettext(" at %s/s"), scan_rate_buf);
 	}
 	(void) printf(gettext(", %s / %s issued"), bytes_issued_buf,
 	    bytes_est_i_buf);
 	if (issue_rate > 0) {
 		zfs_nicebytes(issue_rate, issue_rate_buf,
 		    sizeof (issue_rate_buf));
 		(void) printf(gettext(" at %s/s"), issue_rate_buf);
 	}
 	(void) printf(gettext("\n"));
 
 	(void) printf(gettext("\t%s resilvered, %.2f%% done"),
 	    bytes_rebuilt_buf, scan_pct);
 
 	if (vrs->vrs_state == VDEV_REBUILD_ACTIVE) {
 		if (bytes_est_s >= bytes_scanned &&
 		    scan_rate >= 10 * 1024 * 1024) {
 			secs_to_dhms((bytes_est_s - bytes_scanned) / scan_rate,
 			    time_buf);
 			(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, i, 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);
 }
 
 static void
 vdev_stats_nvlist(zpool_handle_t *zhp, status_cbdata_t *cb, nvlist_t *nv,
     int depth, boolean_t isspare, char *parent, nvlist_t *item)
 {
 	nvlist_t *vds, **child, *ch = NULL;
 	uint_t vsc, children;
 	vdev_stat_t *vs;
 	char *vname;
 	uint64_t notpresent;
 	const char *type, *path;
 
 	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;
 
 	if (cb->cb_print_unhealthy && depth > 0 &&
 	    for_each_vdev_in_nvlist(nv, vdev_health_check_cb, cb) == 0) {
 		return;
 	}
 	vname = zpool_vdev_name(g_zfs, zhp, nv,
 	    cb->cb_name_flags | VDEV_NAME_TYPE_ID);
 	vds = fnvlist_alloc();
 	fill_vdev_info(vds, zhp, vname, B_FALSE, cb->cb_json_as_int);
 	if (cb->cb_flat_vdevs && parent != NULL) {
 		fnvlist_add_string(vds, "parent", parent);
 	}
 
 	if (isspare) {
 		if (vs->vs_aux == VDEV_AUX_SPARED) {
 			fnvlist_add_string(vds, "state", "INUSE");
 			used_by_other(zhp, nv, vds);
 		} else if (vs->vs_state == VDEV_STATE_HEALTHY)
 			fnvlist_add_string(vds, "state", "AVAIL");
 	} else {
 		if (vs->vs_alloc) {
 			nice_num_str_nvlist(vds, "alloc_space", vs->vs_alloc,
 			    cb->cb_literal, cb->cb_json_as_int,
 			    ZFS_NICENUM_BYTES);
 		}
 		if (vs->vs_space) {
 			nice_num_str_nvlist(vds, "total_space", vs->vs_space,
 			    cb->cb_literal, cb->cb_json_as_int,
 			    ZFS_NICENUM_BYTES);
 		}
 		if (vs->vs_dspace) {
 			nice_num_str_nvlist(vds, "def_space", vs->vs_dspace,
 			    cb->cb_literal, cb->cb_json_as_int,
 			    ZFS_NICENUM_BYTES);
 		}
 		if (vs->vs_rsize) {
 			nice_num_str_nvlist(vds, "rep_dev_size", vs->vs_rsize,
 			    cb->cb_literal, cb->cb_json_as_int,
 			    ZFS_NICENUM_BYTES);
 		}
 		if (vs->vs_esize) {
 			nice_num_str_nvlist(vds, "ex_dev_size", vs->vs_esize,
 			    cb->cb_literal, cb->cb_json_as_int,
 			    ZFS_NICENUM_BYTES);
 		}
 		if (vs->vs_self_healed) {
 			nice_num_str_nvlist(vds, "self_healed",
 			    vs->vs_self_healed, cb->cb_literal,
 			    cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 		}
 		if (vs->vs_pspace) {
 			nice_num_str_nvlist(vds, "phys_space", vs->vs_pspace,
 			    cb->cb_literal, cb->cb_json_as_int,
 			    ZFS_NICENUM_BYTES);
 		}
 		nice_num_str_nvlist(vds, "read_errors", vs->vs_read_errors,
 		    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_1024);
 		nice_num_str_nvlist(vds, "write_errors", vs->vs_write_errors,
 		    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_1024);
 		nice_num_str_nvlist(vds, "checksum_errors",
 		    vs->vs_checksum_errors, cb->cb_literal,
 		    cb->cb_json_as_int, ZFS_NICENUM_1024);
 		if (vs->vs_scan_processed) {
 			nice_num_str_nvlist(vds, "scan_processed",
 			    vs->vs_scan_processed, cb->cb_literal,
 			    cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 		}
 		if (vs->vs_checkpoint_space) {
 			nice_num_str_nvlist(vds, "checkpoint_space",
 			    vs->vs_checkpoint_space, cb->cb_literal,
 			    cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 		}
 		if (vs->vs_resilver_deferred) {
 			nice_num_str_nvlist(vds, "resilver_deferred",
 			    vs->vs_resilver_deferred, B_TRUE,
 			    cb->cb_json_as_int, ZFS_NICENUM_1024);
 		}
 		if (children == 0) {
 			nice_num_str_nvlist(vds, "slow_ios", vs->vs_slow_ios,
 			    cb->cb_literal, cb->cb_json_as_int,
 			    ZFS_NICENUM_1024);
 		}
 		if (cb->cb_print_power) {
 			if (children == 0)  {
 				/* Only leaf vdevs have physical slots */
 				switch (zpool_power_current_state(zhp, (char *)
 				    fnvlist_lookup_string(nv,
 				    ZPOOL_CONFIG_PATH))) {
 				case 0:
 					fnvlist_add_string(vds, "power_state",
 					    "off");
 					break;
 				case 1:
 					fnvlist_add_string(vds, "power_state",
 					    "on");
 					break;
 				default:
 					fnvlist_add_string(vds, "power_state",
 					    "-");
 				}
 			} else {
 				fnvlist_add_string(vds, "power_state", "-");
 			}
 		}
 	}
 
+	if (cb->cb_print_dio_verify) {
+		nice_num_str_nvlist(vds, "dio_verify_errors",
+		    vs->vs_dio_verify_errors, cb->cb_literal,
+		    cb->cb_json_as_int, ZFS_NICENUM_1024);
+	}
+
 	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT,
 	    &notpresent) == 0) {
 		nice_num_str_nvlist(vds, ZPOOL_CONFIG_NOT_PRESENT,
 		    1, B_TRUE, cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 		fnvlist_add_string(vds, "was",
 		    fnvlist_lookup_string(nv, ZPOOL_CONFIG_PATH));
 	} else if (vs->vs_aux != VDEV_AUX_NONE) {
 		fnvlist_add_string(vds, "aux", vdev_aux_str[vs->vs_aux]);
 	} 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) {
 		nice_num_str_nvlist(vds, "configured_ashift",
 		    vs->vs_configured_ashift, B_TRUE, cb->cb_json_as_int,
 		    ZFS_NICENUM_1024);
 		nice_num_str_nvlist(vds, "physical_ashift",
 		    vs->vs_physical_ashift, B_TRUE, cb->cb_json_as_int,
 		    ZFS_NICENUM_1024);
 	}
 	if (vs->vs_scan_removing != 0) {
 		nice_num_str_nvlist(vds, "removing", vs->vs_scan_removing,
 		    B_TRUE, cb->cb_json_as_int, ZFS_NICENUM_1024);
 	} else if (VDEV_STAT_VALID(vs_noalloc, vsc) && vs->vs_noalloc != 0) {
 		nice_num_str_nvlist(vds, "noalloc", vs->vs_noalloc,
 		    B_TRUE, cb->cb_json_as_int, ZFS_NICENUM_1024);
 	}
 
 	if (cb->vcdl != NULL) {
 		if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0) {
 			zpool_nvlist_cmd(cb->vcdl, zpool_get_name(zhp),
 			    path, vds);
 		}
 	}
 
 	if (children == 0) {
 		if (cb->cb_print_vdev_init) {
 			if (vs->vs_initialize_state != 0) {
 				uint64_t st = vs->vs_initialize_state;
 				fnvlist_add_string(vds, "init_state",
 				    vdev_init_state_str[st]);
 				nice_num_str_nvlist(vds, "initialized",
 				    vs->vs_initialize_bytes_done,
 				    cb->cb_literal, cb->cb_json_as_int,
 				    ZFS_NICENUM_BYTES);
 				nice_num_str_nvlist(vds, "to_initialize",
 				    vs->vs_initialize_bytes_est,
 				    cb->cb_literal, cb->cb_json_as_int,
 				    ZFS_NICENUM_BYTES);
 				nice_num_str_nvlist(vds, "init_time",
 				    vs->vs_initialize_action_time,
 				    cb->cb_literal, cb->cb_json_as_int,
 				    ZFS_NICE_TIMESTAMP);
 				nice_num_str_nvlist(vds, "init_errors",
 				    vs->vs_initialize_errors,
 				    cb->cb_literal, cb->cb_json_as_int,
 				    ZFS_NICENUM_1024);
 			} else {
 				fnvlist_add_string(vds, "init_state",
 				    "UNINITIALIZED");
 			}
 		}
 		if (cb->cb_print_vdev_trim) {
 			if (vs->vs_trim_notsup == 0) {
 					if (vs->vs_trim_state != 0) {
 					uint64_t st = vs->vs_trim_state;
 					fnvlist_add_string(vds, "trim_state",
 					    vdev_trim_state_str[st]);
 					nice_num_str_nvlist(vds, "trimmed",
 					    vs->vs_trim_bytes_done,
 					    cb->cb_literal, cb->cb_json_as_int,
 					    ZFS_NICENUM_BYTES);
 					nice_num_str_nvlist(vds, "to_trim",
 					    vs->vs_trim_bytes_est,
 					    cb->cb_literal, cb->cb_json_as_int,
 					    ZFS_NICENUM_BYTES);
 					nice_num_str_nvlist(vds, "trim_time",
 					    vs->vs_trim_action_time,
 					    cb->cb_literal, cb->cb_json_as_int,
 					    ZFS_NICE_TIMESTAMP);
 					nice_num_str_nvlist(vds, "trim_errors",
 					    vs->vs_trim_errors,
 					    cb->cb_literal, cb->cb_json_as_int,
 					    ZFS_NICENUM_1024);
 				} else
 					fnvlist_add_string(vds, "trim_state",
 					    "UNTRIMMED");
 			}
 			nice_num_str_nvlist(vds, "trim_notsup",
 			    vs->vs_trim_notsup, B_TRUE,
 			    cb->cb_json_as_int, ZFS_NICENUM_1024);
 		}
 	} else {
 		ch = fnvlist_alloc();
 	}
 
 	if (cb->cb_flat_vdevs && children == 0) {
 		fnvlist_add_nvlist(item, vname, vds);
 	}
 
 	for (int c = 0; c < children; c++) {
 		uint64_t islog = B_FALSE, ishole = B_FALSE;
 		(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;
 		if (nvlist_exists(child[c], ZPOOL_CONFIG_ALLOCATION_BIAS))
 			continue;
 		if (cb->cb_flat_vdevs) {
 			vdev_stats_nvlist(zhp, cb, child[c], depth + 2, isspare,
 			    vname, item);
 		}
 		vdev_stats_nvlist(zhp, cb, child[c], depth + 2, isspare,
 		    vname, ch);
 	}
 
 	if (ch != NULL) {
 		if (!nvlist_empty(ch))
 			fnvlist_add_nvlist(vds, "vdevs", ch);
 		fnvlist_free(ch);
 	}
 	fnvlist_add_nvlist(item, vname, vds);
 	fnvlist_free(vds);
 	free(vname);
 }
 
 static void
 class_vdevs_nvlist(zpool_handle_t *zhp, status_cbdata_t *cb, nvlist_t *nv,
     const char *class, nvlist_t *item)
 {
 	uint_t c, children;
 	nvlist_t **child;
 	nvlist_t *class_obj = NULL;
 
 	if (!cb->cb_flat_vdevs)
 		class_obj = fnvlist_alloc();
 
 	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;
 		const char *bias = NULL;
 		const char *type = NULL;
 		char *name = zpool_vdev_name(g_zfs, zhp, child[c],
 		    cb->cb_name_flags | VDEV_NAME_TYPE_ID);
 
 		(void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
 		    &is_log);
 
 		if (is_log) {
 			bias = (char *)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 (cb->cb_flat_vdevs) {
 			vdev_stats_nvlist(zhp, cb, child[c], 2, B_FALSE,
 			    NULL, item);
 		} else {
 			vdev_stats_nvlist(zhp, cb, child[c], 2, B_FALSE,
 			    NULL, class_obj);
 		}
 		free(name);
 	}
 	if (!cb->cb_flat_vdevs) {
 		if (!nvlist_empty(class_obj))
 			fnvlist_add_nvlist(item, class, class_obj);
 		fnvlist_free(class_obj);
 	}
 }
 
 static void
 l2cache_nvlist(zpool_handle_t *zhp, status_cbdata_t *cb, nvlist_t *nv,
     nvlist_t *item)
 {
 	nvlist_t *l2c = NULL, **l2cache;
 	uint_t nl2cache;
 	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE,
 	    &l2cache, &nl2cache) == 0) {
 		if (nl2cache == 0)
 			return;
 		if (!cb->cb_flat_vdevs)
 			l2c = fnvlist_alloc();
 		for (int i = 0; i < nl2cache; i++) {
 			if (cb->cb_flat_vdevs) {
 				vdev_stats_nvlist(zhp, cb, l2cache[i], 2,
 				    B_FALSE, NULL, item);
 			} else {
 				vdev_stats_nvlist(zhp, cb, l2cache[i], 2,
 				    B_FALSE, NULL, l2c);
 			}
 		}
 	}
 	if (!cb->cb_flat_vdevs) {
 		if (!nvlist_empty(l2c))
 			fnvlist_add_nvlist(item, "l2cache", l2c);
 		fnvlist_free(l2c);
 	}
 }
 
 static void
 spares_nvlist(zpool_handle_t *zhp, status_cbdata_t *cb, nvlist_t *nv,
     nvlist_t *item)
 {
 	nvlist_t *sp = NULL, **spares;
 	uint_t nspares;
 	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES,
 	    &spares, &nspares) == 0) {
 		if (nspares == 0)
 			return;
 		if (!cb->cb_flat_vdevs)
 			sp = fnvlist_alloc();
 		for (int i = 0; i < nspares; i++) {
 			if (cb->cb_flat_vdevs) {
 				vdev_stats_nvlist(zhp, cb, spares[i], 2, B_TRUE,
 				    NULL, item);
 			} else {
 				vdev_stats_nvlist(zhp, cb, spares[i], 2, B_TRUE,
 				    NULL, sp);
 			}
 		}
 	}
 	if (!cb->cb_flat_vdevs) {
 		if (!nvlist_empty(sp))
 			fnvlist_add_nvlist(item, "spares", sp);
 		fnvlist_free(sp);
 	}
 }
 
 static void
 errors_nvlist(zpool_handle_t *zhp, status_cbdata_t *cb, nvlist_t *item)
 {
 	uint64_t nerr;
 	nvlist_t *config = zpool_get_config(zhp, NULL);
 	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_ERRCOUNT,
 	    &nerr) == 0) {
 		nice_num_str_nvlist(item, ZPOOL_CONFIG_ERRCOUNT, nerr,
 		    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_1024);
 		if (nerr != 0 && cb->cb_verbose) {
 			nvlist_t *nverrlist = NULL;
 			if (zpool_get_errlog(zhp, &nverrlist) == 0) {
 				int i = 0;
 				int count = 0;
 				size_t len = MAXPATHLEN * 2;
 				nvpair_t *elem = NULL;
 
 				for (nvpair_t *pair =
 				    nvlist_next_nvpair(nverrlist, NULL);
 				    pair != NULL;
 				    pair = nvlist_next_nvpair(nverrlist, pair))
 					count++;
 				char **errl = (char **)malloc(
 				    count * sizeof (char *));
 
 				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);
 					errl[i] = safe_malloc(len);
 					zpool_obj_to_path(zhp, dsobj, obj,
 					    errl[i++], len);
 				}
 				nvlist_free(nverrlist);
 				fnvlist_add_string_array(item, "errlist",
 				    (const char **)errl, count);
 				for (int i = 0; i < count; ++i)
 					free(errl[i]);
 				free(errl);
 			} else
 				fnvlist_add_string(item, "errlist",
 				    strerror(errno));
 		}
 	}
 }
 
 static void
 ddt_stats_nvlist(ddt_stat_t *dds, status_cbdata_t *cb, nvlist_t *item)
 {
 	nice_num_str_nvlist(item, "blocks", dds->dds_blocks,
 	    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_1024);
 	nice_num_str_nvlist(item, "logical_size", dds->dds_lsize,
 	    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 	nice_num_str_nvlist(item, "physical_size", dds->dds_psize,
 	    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 	nice_num_str_nvlist(item, "deflated_size", dds->dds_dsize,
 	    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 	nice_num_str_nvlist(item, "ref_blocks", dds->dds_ref_blocks,
 	    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_1024);
 	nice_num_str_nvlist(item, "ref_lsize", dds->dds_ref_lsize,
 	    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 	nice_num_str_nvlist(item, "ref_psize", dds->dds_ref_psize,
 	    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 	nice_num_str_nvlist(item, "ref_dsize", dds->dds_ref_dsize,
 	    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 }
 
 static void
 dedup_stats_nvlist(zpool_handle_t *zhp, status_cbdata_t *cb, nvlist_t *item)
 {
 	nvlist_t *config;
 	if (cb->cb_dedup_stats) {
 		ddt_histogram_t *ddh;
 		ddt_stat_t *dds;
 		ddt_object_t *ddo;
 		nvlist_t *ddt_stat, *ddt_obj, *dedup;
 		uint_t c;
 		uint64_t cspace_prop;
 
 		config = zpool_get_config(zhp, NULL);
 		if (nvlist_lookup_uint64_array(config,
 		    ZPOOL_CONFIG_DDT_OBJ_STATS, (uint64_t **)&ddo, &c) != 0)
 			return;
 
 		dedup = fnvlist_alloc();
 		ddt_obj = fnvlist_alloc();
 		nice_num_str_nvlist(dedup, "obj_count", ddo->ddo_count,
 		    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_1024);
 		if (ddo->ddo_count == 0) {
 			fnvlist_add_nvlist(dedup, ZPOOL_CONFIG_DDT_OBJ_STATS,
 			    ddt_obj);
 			fnvlist_add_nvlist(item, "dedup_stats", dedup);
 			fnvlist_free(ddt_obj);
 			fnvlist_free(dedup);
 			return;
 		} else {
 			nice_num_str_nvlist(dedup, "dspace", ddo->ddo_dspace,
 			    cb->cb_literal, cb->cb_json_as_int,
 			    ZFS_NICENUM_1024);
 			nice_num_str_nvlist(dedup, "mspace", ddo->ddo_mspace,
 			    cb->cb_literal, cb->cb_json_as_int,
 			    ZFS_NICENUM_1024);
 			/*
 			 * Squash cached size into in-core size to handle race.
 			 * Only include cached size if it is available.
 			 */
 			cspace_prop = zpool_get_prop_int(zhp,
 			    ZPOOL_PROP_DEDUPCACHED, NULL);
 			cspace_prop = MIN(cspace_prop, ddo->ddo_mspace);
 			nice_num_str_nvlist(dedup, "cspace", cspace_prop,
 			    cb->cb_literal, cb->cb_json_as_int,
 			    ZFS_NICENUM_1024);
 		}
 
 		ddt_stat = fnvlist_alloc();
 		if (nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_STATS,
 		    (uint64_t **)&dds, &c) == 0) {
 			nvlist_t *total = fnvlist_alloc();
 			if (dds->dds_blocks == 0)
 				fnvlist_add_string(total, "blocks", "0");
 			else
 				ddt_stats_nvlist(dds, cb, total);
 			fnvlist_add_nvlist(ddt_stat, "total", total);
 			fnvlist_free(total);
 		}
 		if (nvlist_lookup_uint64_array(config,
 		    ZPOOL_CONFIG_DDT_HISTOGRAM, (uint64_t **)&ddh, &c) == 0) {
 			nvlist_t *hist = fnvlist_alloc();
 			nvlist_t *entry = NULL;
 			char buf[16];
 			for (int h = 0; h < 64; h++) {
 				if (ddh->ddh_stat[h].dds_blocks != 0) {
 					entry = fnvlist_alloc();
 					ddt_stats_nvlist(&ddh->ddh_stat[h], cb,
 					    entry);
 					snprintf(buf, 16, "%d", h);
 					fnvlist_add_nvlist(hist, buf, entry);
 					fnvlist_free(entry);
 				}
 			}
 			if (!nvlist_empty(hist))
 				fnvlist_add_nvlist(ddt_stat, "histogram", hist);
 			fnvlist_free(hist);
 		}
 
 		if (!nvlist_empty(ddt_obj)) {
 			fnvlist_add_nvlist(dedup, ZPOOL_CONFIG_DDT_OBJ_STATS,
 			    ddt_obj);
 		}
 		fnvlist_free(ddt_obj);
 		if (!nvlist_empty(ddt_stat)) {
 			fnvlist_add_nvlist(dedup, ZPOOL_CONFIG_DDT_STATS,
 			    ddt_stat);
 		}
 		fnvlist_free(ddt_stat);
 		if (!nvlist_empty(dedup))
 			fnvlist_add_nvlist(item, "dedup_stats", dedup);
 		fnvlist_free(dedup);
 	}
 }
 
 static void
 raidz_expand_status_nvlist(zpool_handle_t *zhp, status_cbdata_t *cb,
     nvlist_t *nvroot, nvlist_t *item)
 {
 	uint_t c;
 	pool_raidz_expand_stat_t *pres = NULL;
 	if (nvlist_lookup_uint64_array(nvroot,
 	    ZPOOL_CONFIG_RAIDZ_EXPAND_STATS, (uint64_t **)&pres, &c) == 0) {
 		nvlist_t **child;
 		uint_t children;
 		nvlist_t *nv = fnvlist_alloc();
 		verify(nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
 		    &child, &children) == 0);
 		assert(pres->pres_expanding_vdev < children);
 		char *name =
 		    zpool_vdev_name(g_zfs, zhp,
 		    child[pres->pres_expanding_vdev], 0);
 		fill_vdev_info(nv, zhp, name, B_FALSE, cb->cb_json_as_int);
 		fnvlist_add_string(nv, "state",
 		    pool_scan_state_str[pres->pres_state]);
 		nice_num_str_nvlist(nv, "expanding_vdev",
 		    pres->pres_expanding_vdev, B_TRUE, cb->cb_json_as_int,
 		    ZFS_NICENUM_1024);
 		nice_num_str_nvlist(nv, "start_time", pres->pres_start_time,
 		    cb->cb_literal, cb->cb_json_as_int, ZFS_NICE_TIMESTAMP);
 		nice_num_str_nvlist(nv, "end_time", pres->pres_end_time,
 		    cb->cb_literal, cb->cb_json_as_int, ZFS_NICE_TIMESTAMP);
 		nice_num_str_nvlist(nv, "to_reflow", pres->pres_to_reflow,
 		    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 		nice_num_str_nvlist(nv, "reflowed", pres->pres_reflowed,
 		    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 		nice_num_str_nvlist(nv, "waiting_for_resilver",
 		    pres->pres_waiting_for_resilver, B_TRUE,
 		    cb->cb_json_as_int, ZFS_NICENUM_1024);
 		fnvlist_add_nvlist(item, ZPOOL_CONFIG_RAIDZ_EXPAND_STATS, nv);
 		fnvlist_free(nv);
 		free(name);
 	}
 }
 
 static void
 checkpoint_status_nvlist(nvlist_t *nvroot, status_cbdata_t *cb,
     nvlist_t *item)
 {
 	uint_t c;
 	pool_checkpoint_stat_t *pcs = NULL;
 	if (nvlist_lookup_uint64_array(nvroot,
 	    ZPOOL_CONFIG_CHECKPOINT_STATS, (uint64_t **)&pcs, &c) == 0) {
 		nvlist_t *nv = fnvlist_alloc();
 		fnvlist_add_string(nv, "state",
 		    checkpoint_state_str[pcs->pcs_state]);
 		nice_num_str_nvlist(nv, "start_time",
 		    pcs->pcs_start_time, cb->cb_literal, cb->cb_json_as_int,
 		    ZFS_NICE_TIMESTAMP);
 		nice_num_str_nvlist(nv, "space",
 		    pcs->pcs_space, cb->cb_literal, cb->cb_json_as_int,
 		    ZFS_NICENUM_BYTES);
 		fnvlist_add_nvlist(item, ZPOOL_CONFIG_CHECKPOINT_STATS, nv);
 		fnvlist_free(nv);
 	}
 }
 
 static void
 removal_status_nvlist(zpool_handle_t *zhp, status_cbdata_t *cb,
     nvlist_t *nvroot, nvlist_t *item)
 {
 	uint_t c;
 	pool_removal_stat_t *prs = NULL;
 	if (nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_REMOVAL_STATS,
 	    (uint64_t **)&prs, &c) == 0) {
 		if (prs->prs_state != DSS_NONE) {
 			nvlist_t **child;
 			uint_t children;
 			verify(nvlist_lookup_nvlist_array(nvroot,
 			    ZPOOL_CONFIG_CHILDREN, &child, &children) == 0);
 			assert(prs->prs_removing_vdev < children);
 			char *vdev_name = zpool_vdev_name(g_zfs, zhp,
 			    child[prs->prs_removing_vdev], B_TRUE);
 			nvlist_t *nv = fnvlist_alloc();
 			fill_vdev_info(nv, zhp, vdev_name, B_FALSE,
 			    cb->cb_json_as_int);
 			fnvlist_add_string(nv, "state",
 			    pool_scan_state_str[prs->prs_state]);
 			nice_num_str_nvlist(nv, "removing_vdev",
 			    prs->prs_removing_vdev, B_TRUE, cb->cb_json_as_int,
 			    ZFS_NICENUM_1024);
 			nice_num_str_nvlist(nv, "start_time",
 			    prs->prs_start_time, cb->cb_literal,
 			    cb->cb_json_as_int, ZFS_NICE_TIMESTAMP);
 			nice_num_str_nvlist(nv, "end_time", prs->prs_end_time,
 			    cb->cb_literal, cb->cb_json_as_int,
 			    ZFS_NICE_TIMESTAMP);
 			nice_num_str_nvlist(nv, "to_copy", prs->prs_to_copy,
 			    cb->cb_literal, cb->cb_json_as_int,
 			    ZFS_NICENUM_BYTES);
 			nice_num_str_nvlist(nv, "copied", prs->prs_copied,
 			    cb->cb_literal, cb->cb_json_as_int,
 			    ZFS_NICENUM_BYTES);
 			nice_num_str_nvlist(nv, "mapping_memory",
 			    prs->prs_mapping_memory, cb->cb_literal,
 			    cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 			fnvlist_add_nvlist(item,
 			    ZPOOL_CONFIG_REMOVAL_STATS, nv);
 			fnvlist_free(nv);
 			free(vdev_name);
 		}
 	}
 }
 
 static void
 scan_status_nvlist(zpool_handle_t *zhp, status_cbdata_t *cb,
     nvlist_t *nvroot, nvlist_t *item)
 {
 	pool_scan_stat_t *ps = NULL;
 	uint_t c;
 	nvlist_t *scan = fnvlist_alloc();
 	nvlist_t **child;
 	uint_t children;
 
 	if (nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_SCAN_STATS,
 	    (uint64_t **)&ps, &c) == 0) {
 		fnvlist_add_string(scan, "function",
 		    pool_scan_func_str[ps->pss_func]);
 		fnvlist_add_string(scan, "state",
 		    pool_scan_state_str[ps->pss_state]);
 		nice_num_str_nvlist(scan, "start_time", ps->pss_start_time,
 		    cb->cb_literal, cb->cb_json_as_int, ZFS_NICE_TIMESTAMP);
 		nice_num_str_nvlist(scan, "end_time", ps->pss_end_time,
 		    cb->cb_literal, cb->cb_json_as_int, ZFS_NICE_TIMESTAMP);
 		nice_num_str_nvlist(scan, "to_examine", ps->pss_to_examine,
 		    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 		nice_num_str_nvlist(scan, "examined", ps->pss_examined,
 		    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 		nice_num_str_nvlist(scan, "skipped", ps->pss_skipped,
 		    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 		nice_num_str_nvlist(scan, "processed", ps->pss_processed,
 		    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 		nice_num_str_nvlist(scan, "errors", ps->pss_errors,
 		    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_1024);
 		nice_num_str_nvlist(scan, "bytes_per_scan", ps->pss_pass_exam,
 		    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 		nice_num_str_nvlist(scan, "pass_start", ps->pss_pass_start,
 		    B_TRUE, cb->cb_json_as_int, ZFS_NICENUM_1024);
 		nice_num_str_nvlist(scan, "scrub_pause",
 		    ps->pss_pass_scrub_pause, cb->cb_literal,
 		    cb->cb_json_as_int, ZFS_NICE_TIMESTAMP);
 		nice_num_str_nvlist(scan, "scrub_spent_paused",
 		    ps->pss_pass_scrub_spent_paused,
 		    B_TRUE, cb->cb_json_as_int, ZFS_NICENUM_1024);
 		nice_num_str_nvlist(scan, "issued_bytes_per_scan",
 		    ps->pss_pass_issued, cb->cb_literal,
 		    cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 		nice_num_str_nvlist(scan, "issued", ps->pss_issued,
 		    cb->cb_literal, cb->cb_json_as_int, ZFS_NICENUM_BYTES);
 		if (ps->pss_error_scrub_func == POOL_SCAN_ERRORSCRUB &&
 		    ps->pss_error_scrub_start > ps->pss_start_time) {
 			fnvlist_add_string(scan, "err_scrub_func",
 			    pool_scan_func_str[ps->pss_error_scrub_func]);
 			fnvlist_add_string(scan, "err_scrub_state",
 			    pool_scan_state_str[ps->pss_error_scrub_state]);
 			nice_num_str_nvlist(scan, "err_scrub_start_time",
 			    ps->pss_error_scrub_start,
 			    cb->cb_literal, cb->cb_json_as_int,
 			    ZFS_NICE_TIMESTAMP);
 			nice_num_str_nvlist(scan, "err_scrub_end_time",
 			    ps->pss_error_scrub_end,
 			    cb->cb_literal, cb->cb_json_as_int,
 			    ZFS_NICE_TIMESTAMP);
 			nice_num_str_nvlist(scan, "err_scrub_examined",
 			    ps->pss_error_scrub_examined,
 			    cb->cb_literal, cb->cb_json_as_int,
 			    ZFS_NICENUM_1024);
 			nice_num_str_nvlist(scan, "err_scrub_to_examine",
 			    ps->pss_error_scrub_to_be_examined,
 			    cb->cb_literal, cb->cb_json_as_int,
 			    ZFS_NICENUM_1024);
 			nice_num_str_nvlist(scan, "err_scrub_pause",
 			    ps->pss_pass_error_scrub_pause,
 			    B_TRUE, cb->cb_json_as_int, ZFS_NICENUM_1024);
 		}
 	}
 
 	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
 	    &child, &children) == 0) {
 		vdev_rebuild_stat_t *vrs;
 		uint_t i;
 		char *name;
 		nvlist_t *nv;
 		nvlist_t *rebuild = fnvlist_alloc();
 		uint64_t st;
 		for (uint_t c = 0; c < children; c++) {
 			if (nvlist_lookup_uint64_array(child[c],
 			    ZPOOL_CONFIG_REBUILD_STATS, (uint64_t **)&vrs,
 			    &i) == 0) {
 				if (vrs->vrs_state != VDEV_REBUILD_NONE) {
 					nv = fnvlist_alloc();
 					name = zpool_vdev_name(g_zfs, zhp,
 					    child[c], VDEV_NAME_TYPE_ID);
 					fill_vdev_info(nv, zhp, name, B_FALSE,
 					    cb->cb_json_as_int);
 					st = vrs->vrs_state;
 					fnvlist_add_string(nv, "state",
 					    vdev_rebuild_state_str[st]);
 					nice_num_str_nvlist(nv, "start_time",
 					    vrs->vrs_start_time, cb->cb_literal,
 					    cb->cb_json_as_int,
 					    ZFS_NICE_TIMESTAMP);
 					nice_num_str_nvlist(nv, "end_time",
 					    vrs->vrs_end_time, cb->cb_literal,
 					    cb->cb_json_as_int,
 					    ZFS_NICE_TIMESTAMP);
 					nice_num_str_nvlist(nv, "scan_time",
 					    vrs->vrs_scan_time_ms * 1000000,
 					    cb->cb_literal, cb->cb_json_as_int,
 					    ZFS_NICENUM_TIME);
 					nice_num_str_nvlist(nv, "scanned",
 					    vrs->vrs_bytes_scanned,
 					    cb->cb_literal, cb->cb_json_as_int,
 					    ZFS_NICENUM_BYTES);
 					nice_num_str_nvlist(nv, "issued",
 					    vrs->vrs_bytes_issued,
 					    cb->cb_literal, cb->cb_json_as_int,
 					    ZFS_NICENUM_BYTES);
 					nice_num_str_nvlist(nv, "rebuilt",
 					    vrs->vrs_bytes_rebuilt,
 					    cb->cb_literal, cb->cb_json_as_int,
 					    ZFS_NICENUM_BYTES);
 					nice_num_str_nvlist(nv, "to_scan",
 					    vrs->vrs_bytes_est, cb->cb_literal,
 					    cb->cb_json_as_int,
 					    ZFS_NICENUM_BYTES);
 					nice_num_str_nvlist(nv, "errors",
 					    vrs->vrs_errors, cb->cb_literal,
 					    cb->cb_json_as_int,
 					    ZFS_NICENUM_1024);
 					nice_num_str_nvlist(nv, "pass_time",
 					    vrs->vrs_pass_time_ms * 1000000,
 					    cb->cb_literal, cb->cb_json_as_int,
 					    ZFS_NICENUM_TIME);
 					nice_num_str_nvlist(nv, "pass_scanned",
 					    vrs->vrs_pass_bytes_scanned,
 					    cb->cb_literal, cb->cb_json_as_int,
 					    ZFS_NICENUM_BYTES);
 					nice_num_str_nvlist(nv, "pass_issued",
 					    vrs->vrs_pass_bytes_issued,
 					    cb->cb_literal, cb->cb_json_as_int,
 					    ZFS_NICENUM_BYTES);
 					nice_num_str_nvlist(nv, "pass_skipped",
 					    vrs->vrs_pass_bytes_skipped,
 					    cb->cb_literal, cb->cb_json_as_int,
 					    ZFS_NICENUM_BYTES);
 					fnvlist_add_nvlist(rebuild, name, nv);
 					free(name);
 				}
 			}
 		}
 		if (!nvlist_empty(rebuild))
 			fnvlist_add_nvlist(scan, "rebuild_stats", rebuild);
 		fnvlist_free(rebuild);
 	}
 
 	if (!nvlist_empty(scan))
 		fnvlist_add_nvlist(item, ZPOOL_CONFIG_SCAN_STATS, scan);
 	fnvlist_free(scan);
 }
 
 /*
  * 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 have_errorscrub = B_FALSE;
 	boolean_t active_resilver = B_FALSE;
 	pool_checkpoint_stat_t *pcs = NULL;
 	pool_scan_stat_t *ps = NULL;
 	uint_t c;
 	time_t scrub_start = 0, errorscrub_start = 0;
 
 	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);
 		scrub_start = ps->pss_start_time;
 		if (c > offsetof(pool_scan_stat_t,
 		    pss_pass_error_scrub_pause) / 8) {
 			have_errorscrub = (ps->pss_error_scrub_func ==
 			    POOL_SCAN_ERRORSCRUB);
 			errorscrub_start = ps->pss_error_scrub_start;
 		}
 	}
 
 	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 && scrub_start > errorscrub_start)
 		print_scan_scrub_resilver_status(ps);
 	else if (have_errorscrub && errorscrub_start >= scrub_start)
 		print_err_scrub_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);
 	}
 }
 
 /*
  * Print out detailed raidz expansion status.
  */
 static void
 print_raidz_expand_status(zpool_handle_t *zhp, pool_raidz_expand_stat_t *pres)
 {
 	char copied_buf[7];
 
 	if (pres == NULL || pres->pres_state == DSS_NONE)
 		return;
 
 	/*
 	 * Determine name of vdev.
 	 */
 	nvlist_t *config = zpool_get_config(zhp, NULL);
 	nvlist_t *nvroot = fnvlist_lookup_nvlist(config,
 	    ZPOOL_CONFIG_VDEV_TREE);
 	nvlist_t **child;
 	uint_t children;
 	verify(nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
 	    &child, &children) == 0);
 	assert(pres->pres_expanding_vdev < children);
 
 	printf_color(ANSI_BOLD, gettext("expand: "));
 
 	time_t start = pres->pres_start_time;
 	time_t end = pres->pres_end_time;
 	char *vname =
 	    zpool_vdev_name(g_zfs, zhp, child[pres->pres_expanding_vdev], 0);
 	zfs_nicenum(pres->pres_reflowed, copied_buf, sizeof (copied_buf));
 
 	/*
 	 * Expansion is finished or canceled.
 	 */
 	if (pres->pres_state == DSS_FINISHED) {
 		char time_buf[32];
 		secs_to_dhms(end - start, time_buf);
 
 		(void) printf(gettext("expanded %s-%u copied %s in %s, "
 		    "on %s"), vname, (int)pres->pres_expanding_vdev,
 		    copied_buf, time_buf, ctime((time_t *)&end));
 	} else {
 		char examined_buf[7], total_buf[7], rate_buf[7];
 		uint64_t copied, total, elapsed, secs_left;
 		double fraction_done;
 		uint_t rate;
 
 		assert(pres->pres_state == DSS_SCANNING);
 
 		/*
 		 * Expansion is in progress.
 		 */
 		(void) printf(gettext(
 		    "expansion of %s-%u in progress since %s"),
 		    vname, (int)pres->pres_expanding_vdev, ctime(&start));
 
 		copied = pres->pres_reflowed > 0 ? pres->pres_reflowed : 1;
 		total = pres->pres_to_reflow;
 		fraction_done = (double)copied / total;
 
 		/* elapsed time for this pass */
 		elapsed = time(NULL) - pres->pres_start_time;
 		elapsed = elapsed > 0 ? elapsed : 1;
 		rate = copied / elapsed;
 		rate = rate > 0 ? rate : 1;
 		secs_left = (total - copied) / rate;
 
 		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 / %s copied at %s/s, %.2f%% done"),
 		    examined_buf, total_buf, rate_buf, 100 * fraction_done);
 		if (pres->pres_waiting_for_resilver) {
 			(void) printf(gettext(", paused for resilver or "
 			    "clear\n"));
 		} else if (secs_left < (30 * 24 * 3600)) {
 			char time_buf[32];
 			secs_to_dhms(secs_left, time_buf);
 			(void) printf(gettext(", %s to go\n"), time_buf);
 		} else {
 			(void) printf(gettext(
 			    ", (copy is slow, no estimated time)\n"));
 		}
 	}
 	free(vname);
 }
 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(zpool_handle_t *zhp, nvlist_t *config, boolean_t literal)
 {
 	ddt_histogram_t *ddh;
 	ddt_stat_t *dds;
 	ddt_object_t *ddo;
 	uint_t c;
 	/* Extra space provided for literal display */
 	char dspace[32], mspace[32], cspace[32];
 	uint64_t cspace_prop;
 	enum zfs_nicenum_format format;
 	zprop_source_t src;
 
 	/*
 	 * 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;
 	}
 
 	/*
 	 * Squash cached size into in-core size to handle race.
 	 * Only include cached size if it is available.
 	 */
 	cspace_prop = zpool_get_prop_int(zhp, ZPOOL_PROP_DEDUPCACHED, &src);
 	cspace_prop = MIN(cspace_prop, ddo->ddo_mspace);
 	format = literal ? ZFS_NICENUM_RAW : ZFS_NICENUM_1024;
 	zfs_nicenum_format(cspace_prop, cspace, sizeof (cspace), format);
 	zfs_nicenum_format(ddo->ddo_dspace, dspace, sizeof (dspace), format);
 	zfs_nicenum_format(ddo->ddo_mspace, mspace, sizeof (mspace), format);
 	(void) printf("DDT entries %llu, size %s on disk, %s in core",
 	    (u_longlong_t)ddo->ddo_count,
 	    dspace,
 	    mspace);
 	if (src != ZPROP_SRC_DEFAULT) {
 		(void) printf(", %s cached (%.02f%%)",
 		    cspace,
 		    (double)cspace_prop / (double)ddo->ddo_mspace * 100.0);
 	}
 	(void) printf("\n");
 
 	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);
 }
 
 #define	ST_SIZE	4096
 #define	AC_SIZE	2048
 
 static void
 print_status_reason(zpool_handle_t *zhp, status_cbdata_t *cbp,
     zpool_status_t reason, zpool_errata_t errata, nvlist_t *item)
 {
 	char status[ST_SIZE];
 	char action[AC_SIZE];
 	memset(status, 0, ST_SIZE);
 	memset(action, 0, AC_SIZE);
 
 	switch (reason) {
 	case ZPOOL_STATUS_MISSING_DEV_R:
 		snprintf(status, ST_SIZE, gettext("One or more devices could "
 		    "not be opened.  Sufficient replicas exist for\n\tthe pool "
 		    "to continue functioning in a degraded state.\n"));
 		snprintf(action, AC_SIZE, gettext("Attach the missing device "
 		    "and online it using 'zpool online'.\n"));
 		break;
 
 	case ZPOOL_STATUS_MISSING_DEV_NR:
 		snprintf(status, ST_SIZE, gettext("One or more devices could "
 		    "not be opened.  There are insufficient\n\treplicas for the"
 		    " pool to continue functioning.\n"));
 		snprintf(action, AC_SIZE, gettext("Attach the missing device "
 		    "and online it using 'zpool online'.\n"));
 		break;
 
 	case ZPOOL_STATUS_CORRUPT_LABEL_R:
 		snprintf(status, ST_SIZE, 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"));
 		snprintf(action, AC_SIZE, gettext("Replace the device using "
 		    "'zpool replace'.\n"));
 		break;
 
 	case ZPOOL_STATUS_CORRUPT_LABEL_NR:
 		snprintf(status, ST_SIZE, 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, zpool_get_config(zhp, NULL),
 		    action, AC_SIZE);
 		break;
 
 	case ZPOOL_STATUS_FAILING_DEV:
 		snprintf(status, ST_SIZE, gettext("One or more devices has "
 		    "experienced an unrecoverable error.  An\n\tattempt was "
 		    "made to correct the error.  Applications are "
 		    "unaffected.\n"));
 		snprintf(action, AC_SIZE, 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:
 		snprintf(status, ST_SIZE, 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"));
 		snprintf(action, AC_SIZE, gettext("Online the device "
 		    "using 'zpool online' or replace the device with\n\t'zpool "
 		    "replace'.\n"));
 		break;
 
 	case ZPOOL_STATUS_REMOVED_DEV:
 		snprintf(status, ST_SIZE, 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"));
 		snprintf(action, AC_SIZE, 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:
 		snprintf(status, ST_SIZE, gettext("One or more devices is "
 		    "currently being resilvered.  The pool will\n\tcontinue "
 		    "to function, possibly in a degraded state.\n"));
 		snprintf(action, AC_SIZE, gettext("Wait for the resilver to "
 		    "complete.\n"));
 		break;
 
 	case ZPOOL_STATUS_REBUILD_SCRUB:
 		snprintf(status, ST_SIZE, gettext("One or more devices have "
 		    "been sequentially resilvered, scrubbing\n\tthe pool "
 		    "is recommended.\n"));
 		snprintf(action, AC_SIZE, gettext("Use 'zpool scrub' to "
 		    "verify all data checksums.\n"));
 		break;
 
 	case ZPOOL_STATUS_CORRUPT_DATA:
 		snprintf(status, ST_SIZE, gettext("One or more devices has "
 		    "experienced an error resulting in data\n\tcorruption.  "
 		    "Applications may be affected.\n"));
 		snprintf(action, AC_SIZE, gettext("Restore the file in question"
 		    " if possible.  Otherwise restore the\n\tentire pool from "
 		    "backup.\n"));
 		break;
 
 	case ZPOOL_STATUS_CORRUPT_POOL:
 		snprintf(status, ST_SIZE, 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, zpool_get_config(zhp, NULL),
 		    action, AC_SIZE);
 		break;
 
 	case ZPOOL_STATUS_VERSION_OLDER:
 		snprintf(status, ST_SIZE, gettext("The pool is formatted using "
 		    "a legacy on-disk format.  The pool can\n\tstill be used, "
 		    "but some features are unavailable.\n"));
 		snprintf(action, AC_SIZE, 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:
 		snprintf(status, ST_SIZE, gettext("The pool has been upgraded "
 		    "to a newer, incompatible on-disk version.\n\tThe pool "
 		    "cannot be accessed on this system.\n"));
 		snprintf(action, AC_SIZE, 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:
 		snprintf(status, ST_SIZE, 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"));
 		snprintf(action, AC_SIZE, 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:
 		snprintf(status, ST_SIZE, 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"));
 		snprintf(action, AC_SIZE, 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:
 		snprintf(status, ST_SIZE, gettext("One or more features "
 		    "are enabled on the pool despite not being\n\t"
 		    "requested by the 'compatibility' property.\n"));
 		snprintf(action, AC_SIZE, 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:
 		snprintf(status, ST_SIZE, gettext("The pool cannot be accessed "
 		    "on this system because it uses the\n\tfollowing feature(s)"
 		    " not supported on this system:\n"));
 		zpool_collect_unsup_feat(zpool_get_config(zhp, NULL), status,
 		    1024);
 		snprintf(action, AC_SIZE, 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:
 		snprintf(status, ST_SIZE, 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_collect_unsup_feat(zpool_get_config(zhp, NULL), status,
 		    1024);
 		snprintf(action, AC_SIZE, 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:
 		snprintf(status, ST_SIZE, 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"));
 		snprintf(action, AC_SIZE, gettext("Replace the faulted device, "
 		    "or use 'zpool clear' to mark the device\n\trepaired.\n"));
 		break;
 
 	case ZPOOL_STATUS_FAULTED_DEV_NR:
 		snprintf(status, ST_SIZE, gettext("One or more devices are "
 		    "faulted in response to persistent errors.  There are "
 		    "insufficient replicas for the pool to\n\tcontinue "
 		    "functioning.\n"));
 		snprintf(action, AC_SIZE, 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:
 		snprintf(status, ST_SIZE, gettext("The pool is suspended "
 		    "because multihost writes failed or were delayed;\n\t"
 		    "another system could import the pool undetected.\n"));
 		snprintf(action, AC_SIZE, gettext("Make sure the pool's devices"
 		    " are connected, then reboot your system and\n\timport the "
 		    "pool or run 'zpool clear' to resume the pool.\n"));
 		break;
 
 	case ZPOOL_STATUS_IO_FAILURE_WAIT:
 	case ZPOOL_STATUS_IO_FAILURE_CONTINUE:
 		snprintf(status, ST_SIZE, gettext("One or more devices are "
 		    "faulted in response to IO failures.\n"));
 		snprintf(action, AC_SIZE, gettext("Make sure the affected "
 		    "devices are connected, then run 'zpool clear'.\n"));
 		break;
 
 	case ZPOOL_STATUS_BAD_LOG:
 		snprintf(status, ST_SIZE, gettext("An intent log record "
 		    "could not be read.\n"
 		    "\tWaiting for administrator intervention to fix the "
 		    "faulted pool.\n"));
 		snprintf(action, AC_SIZE, 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:
 		snprintf(status, ST_SIZE, gettext("One or more devices are "
 		    "configured to use a non-native block size.\n"
 		    "\tExpect reduced performance.\n"));
 		snprintf(action, AC_SIZE, gettext("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:
 		snprintf(status, ST_SIZE, 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"));
 		snprintf(action, AC_SIZE, 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:
 		snprintf(status, ST_SIZE, gettext("Errata #%d detected.\n"),
 		    errata);
 		switch (errata) {
 		case ZPOOL_ERRATA_NONE:
 			break;
 
 		case ZPOOL_ERRATA_ZOL_2094_SCRUB:
 			snprintf(action, AC_SIZE, gettext("To correct the issue"
 			    " run 'zpool scrub'.\n"));
 			break;
 
 		case ZPOOL_ERRATA_ZOL_6845_ENCRYPTION:
 			(void) strlcat(status, gettext("\tExisting encrypted "
 			    "datasets contain an on-disk incompatibility\n\t "
 			    "which needs to be corrected.\n"), ST_SIZE);
 			snprintf(action, AC_SIZE, 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) strlcat(status, gettext("\tExisting encrypted "
 			    "snapshots and bookmarks contain an on-disk\n\t"
 			    "incompatibility. This may cause on-disk "
 			    "corruption if they are used\n\twith "
 			    "'zfs recv'.\n"), ST_SIZE);
 			snprintf(action, AC_SIZE, 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 (status[0] != 0) {
 		if (cbp->cb_json)
 			fnvlist_add_string(item, "status", status);
 		else {
 			printf_color(ANSI_BOLD, gettext("status: "));
 			printf_color(ANSI_YELLOW, status);
 		}
 	}
 
 	if (action[0] != 0) {
 		if (cbp->cb_json)
 			fnvlist_add_string(item, "action", action);
 		else {
 			printf_color(ANSI_BOLD, gettext("action: "));
 			printf_color(ANSI_YELLOW, action);
 		}
 	}
 }
 
 static int
 status_callback_json(zpool_handle_t *zhp, void *data)
 {
 	status_cbdata_t *cbp = data;
 	nvlist_t *config, *nvroot;
 	const char *msgid;
 	char pool_guid[256];
 	char msgbuf[256];
 	uint64_t guid;
 	zpool_status_t reason;
 	zpool_errata_t errata;
 	uint_t c;
 	vdev_stat_t *vs;
 	nvlist_t *item, *d, *load_info, *vds;
 	item = d = NULL;
 
 	/* If dedup stats were requested, also fetch dedupcached. */
 	if (cbp->cb_dedup_stats > 1)
 		zpool_add_propname(zhp, ZPOOL_DEDUPCACHED_PROP_NAME);
 	reason = zpool_get_status(zhp, &msgid, &errata);
 	/*
 	 * 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)) {
 		return (0);
 	}
 
 	d = fnvlist_lookup_nvlist(cbp->cb_jsobj, "pools");
 	item = fnvlist_alloc();
 	vds = fnvlist_alloc();
 	fill_pool_info(item, zhp, B_FALSE, cbp->cb_json_as_int);
 	config = zpool_get_config(zhp, NULL);
 
 	if (config != NULL) {
 		nvroot = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE);
 		verify(nvlist_lookup_uint64_array(nvroot,
 		    ZPOOL_CONFIG_VDEV_STATS, (uint64_t **)&vs, &c) == 0);
 		if (cbp->cb_json_pool_key_guid) {
 			guid = fnvlist_lookup_uint64(config,
 			    ZPOOL_CONFIG_POOL_GUID);
 			snprintf(pool_guid, 256, "%llu", (u_longlong_t)guid);
 		}
 		cbp->cb_count++;
 
 		print_status_reason(zhp, cbp, reason, errata, item);
 		if (msgid != NULL) {
 			snprintf(msgbuf, 256,
 			    "https://openzfs.github.io/openzfs-docs/msg/%s",
 			    msgid);
 			fnvlist_add_string(item, "msgid", msgid);
 			fnvlist_add_string(item, "moreinfo", msgbuf);
 		}
 
 		if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO,
 		    &load_info) == 0) {
 			fnvlist_add_nvlist(item, ZPOOL_CONFIG_LOAD_INFO,
 			    load_info);
 		}
 
 		scan_status_nvlist(zhp, cbp, nvroot, item);
 		removal_status_nvlist(zhp, cbp, nvroot, item);
 		checkpoint_status_nvlist(nvroot, cbp, item);
 		raidz_expand_status_nvlist(zhp, cbp, nvroot, item);
 		vdev_stats_nvlist(zhp, cbp, nvroot, 0, B_FALSE, NULL, vds);
 		if (cbp->cb_flat_vdevs) {
 			class_vdevs_nvlist(zhp, cbp, nvroot,
 			    VDEV_ALLOC_BIAS_DEDUP, vds);
 			class_vdevs_nvlist(zhp, cbp, nvroot,
 			    VDEV_ALLOC_BIAS_SPECIAL, vds);
 			class_vdevs_nvlist(zhp, cbp, nvroot,
 			    VDEV_ALLOC_CLASS_LOGS, vds);
 			l2cache_nvlist(zhp, cbp, nvroot, vds);
 			spares_nvlist(zhp, cbp, nvroot, vds);
 
 			fnvlist_add_nvlist(item, "vdevs", vds);
 			fnvlist_free(vds);
 		} else {
 			fnvlist_add_nvlist(item, "vdevs", vds);
 			fnvlist_free(vds);
 
 			class_vdevs_nvlist(zhp, cbp, nvroot,
 			    VDEV_ALLOC_BIAS_DEDUP, item);
 			class_vdevs_nvlist(zhp, cbp, nvroot,
 			    VDEV_ALLOC_BIAS_SPECIAL, item);
 			class_vdevs_nvlist(zhp, cbp, nvroot,
 			    VDEV_ALLOC_CLASS_LOGS, item);
 			l2cache_nvlist(zhp, cbp, nvroot, item);
 			spares_nvlist(zhp, cbp, nvroot, item);
 		}
 		dedup_stats_nvlist(zhp, cbp, item);
 		errors_nvlist(zhp, cbp, item);
 	}
 	if (cbp->cb_json_pool_key_guid) {
 		fnvlist_add_nvlist(d, pool_guid, item);
 	} else {
 		fnvlist_add_nvlist(d, zpool_get_name(zhp),
 		    item);
 	}
 	fnvlist_free(item);
 	return (0);
 }
 
 /*
  * 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;
 	const char *msgid;
 	zpool_status_t reason;
 	zpool_errata_t errata;
 	const char *health;
 	uint_t c;
 	vdev_stat_t *vs;
 
 	/* If dedup stats were requested, also fetch dedupcached. */
 	if (cbp->cb_dedup_stats > 1)
 		zpool_add_propname(zhp, ZPOOL_DEDUPCACHED_PROP_NAME);
 
 	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));
 	fputc(' ', stdout);
 	printf_color(ANSI_BOLD, gettext("state: "));
 
 	printf_color(health_str_to_color(health), "%s", health);
 
 	fputc('\n', stdout);
 	print_status_reason(zhp, cbp, reason, errata, NULL);
 
 	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;
 
 		print_scan_status(zhp, nvroot);
 
 		pool_removal_stat_t *prs = NULL;
 		(void) nvlist_lookup_uint64_array(nvroot,
 		    ZPOOL_CONFIG_REMOVAL_STATS, (uint64_t **)&prs, &c);
 		print_removal_status(zhp, prs);
 
 		pool_checkpoint_stat_t *pcs = NULL;
 		(void) nvlist_lookup_uint64_array(nvroot,
 		    ZPOOL_CONFIG_CHECKPOINT_STATS, (uint64_t **)&pcs, &c);
 		print_checkpoint_status(pcs);
 
 		pool_raidz_expand_stat_t *pres = NULL;
 		(void) nvlist_lookup_uint64_array(nvroot,
 		    ZPOOL_CONFIG_RAIDZ_EXPAND_STATS, (uint64_t **)&pres, &c);
 		print_raidz_expand_status(zhp, pres);
 
 		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->cb_print_power) {
 			printf_color(ANSI_BOLD, " %5s", gettext("POWER"));
 		}
 
 		if (cbp->cb_print_dio_verify) {
 			printf_color(ANSI_BOLD, " %5s", gettext("DIO"));
 		}
 
 		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) {
 			(void) printf("\n");
 			if (nerr == 0) {
 				(void) printf(gettext(
 				    "errors: No known data errors\n"));
 			} else if (!cbp->cb_verbose) {
 				color_start(ANSI_RED);
 				(void) printf(gettext("errors: %llu data "
 				    "errors, use '-v' for a list\n"),
 				    (u_longlong_t)nerr);
 				color_end();
 			} else {
 				print_error_log(zhp);
 			}
 		}
 
 		if (cbp->cb_dedup_stats)
 			print_dedup_stats(zhp, config, cbp->cb_literal);
 	} else {
 		(void) printf(gettext("config: The configuration cannot be "
 		    "determined.\n"));
 	}
 
 	return (0);
 }
 
 /*
  * zpool status [-c [script1,script2,...]] [-dDegiLpPstvx] [--power] ...
  *              [-T d|u] [pool] [interval [count]]
  *
  *	-c CMD	For each vdev, run command CMD
  *	-d	Display Direct I/O write verify errors
  *	-D	Display dedup status (undocumented)
  *	-e	Display only unhealthy vdevs
  *	-g	Display guid for individual vdev name.
  *	-i	Display vdev initialization status.
  *	-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.
  *	-t	Display vdev TRIM status.
  *	-T	Display a timestamp in date(1) or Unix format
  *	-v	Display complete error logs
  *	-x	Display only pools with potential problems
  *	-j	Display output in JSON format
  *	--power	Display vdev enclosure slot power status
  *	--json-int Display numbers in inteeger format instead of string
  *	--json-flat-vdevs Display vdevs in flat hierarchy
  *	--json-pool-key-guid Use pool GUID as key for pool objects
  *
  * 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 };
 	nvlist_t *data;
 	char *cmd = NULL;
 
 	struct option long_options[] = {
 		{"power", no_argument, NULL, ZPOOL_OPTION_POWER},
+		{"json", no_argument, NULL, 'j'},
 		{"json-int", no_argument, NULL, ZPOOL_OPTION_JSON_NUMS_AS_INT},
 		{"json-flat-vdevs", no_argument, NULL,
 		    ZPOOL_OPTION_JSON_FLAT_VDEVS},
 		{"json-pool-key-guid", no_argument, NULL,
 		    ZPOOL_OPTION_POOL_KEY_GUID},
 		{0, 0, 0, 0}
 	};
 
 	/* check options */
 	while ((c = getopt_long(argc, argv, "c:jdDegiLpPstT:vx", long_options,
 	    NULL)) != -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 'd':
 			cb.cb_print_dio_verify = B_TRUE;
 			break;
 		case 'D':
 			if (++cb.cb_dedup_stats  > 2)
 				cb.cb_dedup_stats = 2;
 			break;
 		case 'e':
 			cb.cb_print_unhealthy = B_TRUE;
 			break;
 		case 'g':
 			cb.cb_name_flags |= VDEV_NAME_GUID;
 			break;
 		case 'i':
 			cb.cb_print_vdev_init = B_TRUE;
 			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 't':
 			cb.cb_print_vdev_trim = B_TRUE;
 			break;
 		case 'T':
 			get_timestamp_arg(*optarg);
 			break;
 		case 'v':
 			cb.cb_verbose = B_TRUE;
 			break;
 		case 'j':
 			cb.cb_json = B_TRUE;
 			break;
 		case 'x':
 			cb.cb_explain = B_TRUE;
 			break;
 		case ZPOOL_OPTION_POWER:
 			cb.cb_print_power = B_TRUE;
 			break;
 		case ZPOOL_OPTION_JSON_FLAT_VDEVS:
 			cb.cb_flat_vdevs = B_TRUE;
 			break;
 		case ZPOOL_OPTION_JSON_NUMS_AS_INT:
 			cb.cb_json_as_int = B_TRUE;
 			cb.cb_literal = B_TRUE;
 			break;
 		case ZPOOL_OPTION_POOL_KEY_GUID:
 			cb.cb_json_pool_key_guid = B_TRUE;
 			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;
 
 	if (cb.cb_flat_vdevs && !cb.cb_json) {
 		fprintf(stderr, gettext("'--json-flat-vdevs' only works with"
 		    " '-j' option\n"));
 		usage(B_FALSE);
 	}
 
 	if (cb.cb_json_as_int && !cb.cb_json) {
 		(void) fprintf(stderr, gettext("'--json-int' only works with"
 		    " '-j' option\n"));
 		usage(B_FALSE);
 	}
 
 	if (!cb.cb_json && cb.cb_json_pool_key_guid) {
 		(void) fprintf(stderr, gettext("'json-pool-key-guid' only"
 		    " works with '-j' option\n"));
 		usage(B_FALSE);
 	}
 
 	for (;;) {
 		if (cb.cb_json) {
 			cb.cb_jsobj = zpool_json_schema(0, 1);
 			data = fnvlist_alloc();
 			fnvlist_add_nvlist(cb.cb_jsobj, "pools", data);
 			fnvlist_free(data);
 		}
 
 		if (timestamp_fmt != NODATE) {
 			if (cb.cb_json) {
 				if (cb.cb_json_as_int) {
 					fnvlist_add_uint64(cb.cb_jsobj, "time",
 					    time(NULL));
 				} else {
 					char ts[128];
 					get_timestamp(timestamp_fmt, ts, 128);
 					fnvlist_add_string(cb.cb_jsobj, "time",
 					    ts);
 				}
 			} else
 				print_timestamp(timestamp_fmt);
 		}
 
 		if (cmd != NULL)
 			cb.vcdl = all_pools_for_each_vdev_run(argc, argv, cmd,
 			    NULL, NULL, 0, 0);
 
 		if (cb.cb_json) {
 			ret = for_each_pool(argc, argv, B_TRUE, NULL,
 			    ZFS_TYPE_POOL, cb.cb_literal,
 			    status_callback_json, &cb);
 		} else {
 			ret = for_each_pool(argc, argv, B_TRUE, NULL,
 			    ZFS_TYPE_POOL, cb.cb_literal,
 			    status_callback, &cb);
 		}
 
 		if (cb.vcdl != NULL)
 			free_vdev_cmd_data_list(cb.vcdl);
 
 		if (cb.cb_json) {
 			if (ret == 0)
 				zcmd_print_json(cb.cb_jsobj);
 			else
 				nvlist_free(cb.cb_jsobj);
 		} else {
 			if (argc == 0 && cb.cb_count == 0) {
 				(void) fprintf(stderr, "%s",
 				    gettext("no pools available\n"));
 			} else if (cb.cb_explain && cb.cb_first &&
 			    cb.cb_allpools) {
 				(void) printf("%s",
 				    gettext("all pools are healthy\n"));
 			}
 		}
 
 		if (ret != 0)
 			return (ret);
 
 		if (interval == 0)
 			break;
 
 		if (count != 0 && --count == 0)
 			break;
 
 		(void) fflush(stdout);
 		(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_v2(zhp, 0, 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);
 }
 
 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("%s", 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, ZFS_TYPE_POOL,
 		    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, ZFS_TYPE_POOL,
 	    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];
 	const char *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;
 	static char flagstr[256];
 
 	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;
 		const 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);
 			if (strcmp(name,
 			    FM_EREPORT_PAYLOAD_ZFS_ZIO_STAGE) == 0 ||
 			    strcmp(name,
 			    FM_EREPORT_PAYLOAD_ZFS_ZIO_PIPELINE) == 0) {
 				zfs_valstr_zio_stage(i32, flagstr,
 				    sizeof (flagstr));
 				printf(gettext("0x%x [%s]"), i32, flagstr);
 			} else if (strcmp(name,
 			    FM_EREPORT_PAYLOAD_ZFS_ZIO_PRIORITY) == 0) {
 				zfs_valstr_zio_priority(i32, flagstr,
 				    sizeof (flagstr));
 				printf(gettext("0x%x [%s]"), i32, flagstr);
 			} else {
 				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 if (strcmp(name,
 			    FM_EREPORT_PAYLOAD_ZFS_ZIO_FLAGS) == 0) {
 				zfs_valstr_zio_flag(i64, flagstr,
 				    sizeof (flagstr));
 				printf(gettext("0x%llx [%s]"),
 				    (u_longlong_t)i64, flagstr);
 			} 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: {
 			const 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;
 	const 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(void)
 {
 	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();
 	else
 		ret = zpool_do_events_next(&opts);
 
 	return (ret);
 }
 
 static int
 get_callback_vdev(zpool_handle_t *zhp, char *vdevname, void *data)
 {
 	zprop_get_cbdata_t *cbp = (zprop_get_cbdata_t *)data;
 	char value[ZFS_MAXPROPLEN];
 	zprop_source_t srctype;
 	nvlist_t *props, *item, *d;
 	props = item = d = NULL;
 
 	if (cbp->cb_json) {
 		d = fnvlist_lookup_nvlist(cbp->cb_jsobj, "vdevs");
 		if (d == NULL) {
 			fprintf(stderr, "vdevs obj not found.\n");
 			exit(1);
 		}
 		props = fnvlist_alloc();
 	}
 
 	for (zprop_list_t *pl = cbp->cb_proplist; pl != NULL;
 	    pl = pl->pl_next) {
 		char *prop_name;
 		/*
 		 * If the first property is pool name, it is a special
 		 * placeholder that we can skip. 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) {
 			prop_name = pl->pl_user_prop;
 		} else {
 			prop_name = (char *)vdev_prop_to_name(pl->pl_prop);
 		}
 		if (zpool_get_vdev_prop(zhp, vdevname, pl->pl_prop,
 		    prop_name, value, sizeof (value), &srctype,
 		    cbp->cb_literal) == 0) {
 			zprop_collect_property(vdevname, cbp, prop_name,
 			    value, srctype, NULL, NULL, props);
 		}
 	}
 
 	if (cbp->cb_json) {
 		if (!nvlist_empty(props)) {
 			item = fnvlist_alloc();
 			fill_vdev_info(item, zhp, vdevname, B_TRUE,
 			    cbp->cb_json_as_int);
 			fnvlist_add_nvlist(item, "properties", props);
 			fnvlist_add_nvlist(d, vdevname, item);
 			fnvlist_add_nvlist(cbp->cb_jsobj, "vdevs", d);
 			fnvlist_free(item);
 		}
 		fnvlist_free(props);
 	}
 
 	return (0);
 }
 
 static int
 get_callback_vdev_cb(void *zhp_data, nvlist_t *nv, void *data)
 {
 	zpool_handle_t *zhp = zhp_data;
 	zprop_get_cbdata_t *cbp = (zprop_get_cbdata_t *)data;
 	char *vdevname;
 	const char *type;
 	int ret;
 
 	/*
 	 * zpool_vdev_name() transforms the root vdev name (i.e., root-0) to the
 	 * pool name for display purposes, which is not desired. Fallback to
 	 * zpool_vdev_name() when not dealing with the root vdev.
 	 */
 	type = fnvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE);
 	if (zhp != NULL && strcmp(type, "root") == 0)
 		vdevname = strdup("root-0");
 	else
 		vdevname = zpool_vdev_name(g_zfs, zhp, nv,
 		    cbp->cb_vdevs.cb_name_flags);
 
 	(void) vdev_expand_proplist(zhp, vdevname, &cbp->cb_proplist);
 
 	ret = get_callback_vdev(zhp, vdevname, data);
 
 	free(vdevname);
 
 	return (ret);
 }
 
 static int
 get_callback(zpool_handle_t *zhp, void *data)
 {
 	zprop_get_cbdata_t *cbp = (zprop_get_cbdata_t *)data;
 	char value[ZFS_MAXPROPLEN];
 	zprop_source_t srctype;
 	zprop_list_t *pl;
 	int vid;
 	int err = 0;
 	nvlist_t *props, *item, *d;
 	props = item = d = NULL;
 
 	if (cbp->cb_type == ZFS_TYPE_VDEV) {
 		if (cbp->cb_json) {
 			nvlist_t *pool = fnvlist_alloc();
 			fill_pool_info(pool, zhp, B_FALSE, cbp->cb_json_as_int);
 			fnvlist_add_nvlist(cbp->cb_jsobj, "pool", pool);
 			fnvlist_free(pool);
 		}
 
 		if (strcmp(cbp->cb_vdevs.cb_names[0], "all-vdevs") == 0) {
 			for_each_vdev(zhp, get_callback_vdev_cb, data);
 		} else {
 			/* Adjust column widths for vdev properties */
 			for (vid = 0; vid < cbp->cb_vdevs.cb_names_count;
 			    vid++) {
 				vdev_expand_proplist(zhp,
 				    cbp->cb_vdevs.cb_names[vid],
 				    &cbp->cb_proplist);
 			}
 			/* Display the properties */
 			for (vid = 0; vid < cbp->cb_vdevs.cb_names_count;
 			    vid++) {
 				get_callback_vdev(zhp,
 				    cbp->cb_vdevs.cb_names[vid], data);
 			}
 		}
 	} else {
 		assert(cbp->cb_type == ZFS_TYPE_POOL);
 		if (cbp->cb_json) {
 			d = fnvlist_lookup_nvlist(cbp->cb_jsobj, "pools");
 			if (d == NULL) {
 				fprintf(stderr, "pools obj not found.\n");
 				exit(1);
 			}
 			props = fnvlist_alloc();
 		}
 		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 &&
 			    zfs_prop_user(pl->pl_user_prop)) {
 				srctype = ZPROP_SRC_LOCAL;
 
 				if (zpool_get_userprop(zhp, pl->pl_user_prop,
 				    value, sizeof (value), &srctype) != 0)
 					continue;
 
 				err = zprop_collect_property(
 				    zpool_get_name(zhp), cbp, pl->pl_user_prop,
 				    value, srctype, NULL, NULL, props);
 			} else 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) {
 					err = zprop_collect_property(
 					    zpool_get_name(zhp), cbp,
 					    pl->pl_user_prop, value, srctype,
 					    NULL, NULL, props);
 				}
 			} else {
 				if (zpool_get_prop(zhp, pl->pl_prop, value,
 				    sizeof (value), &srctype,
 				    cbp->cb_literal) != 0)
 					continue;
 
 				err = zprop_collect_property(
 				    zpool_get_name(zhp), cbp,
 				    zpool_prop_to_name(pl->pl_prop),
 				    value, srctype, NULL, NULL, props);
 			}
 			if (err != 0)
 				return (err);
 		}
 
 		if (cbp->cb_json) {
 			if (!nvlist_empty(props)) {
 				item = fnvlist_alloc();
 				fill_pool_info(item, zhp, B_TRUE,
 				    cbp->cb_json_as_int);
 				fnvlist_add_nvlist(item, "properties", props);
 				if (cbp->cb_json_pool_key_guid) {
 					char buf[256];
 					uint64_t guid = fnvlist_lookup_uint64(
 					    zpool_get_config(zhp, NULL),
 					    ZPOOL_CONFIG_POOL_GUID);
 					snprintf(buf, 256, "%llu",
 					    (u_longlong_t)guid);
 					fnvlist_add_nvlist(d, buf, item);
 				} else {
 					const char *name = zpool_get_name(zhp);
 					fnvlist_add_nvlist(d, name, item);
 				}
 				fnvlist_add_nvlist(cbp->cb_jsobj, "pools", d);
 				fnvlist_free(item);
 			}
 			fnvlist_free(props);
 		}
 	}
 
 	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.
  * 	-j	Display output in JSON format.
  * 	--json-int	Display numbers as integers instead of strings.
  * 	--json-pool-key-guid	Set pool GUID as key for pool objects.
  *
  * 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 *propstr = NULL;
 	char *vdev = NULL;
 	nvlist_t *data = NULL;
 
 	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;
 	cb.cb_vdevs.cb_name_flags |= VDEV_NAME_TYPE_ID;
 	current_prop_type = cb.cb_type;
 
 	struct option long_options[] = {
+		{"json", no_argument, NULL, 'j'},
 		{"json-int", no_argument, NULL, ZPOOL_OPTION_JSON_NUMS_AS_INT},
 		{"json-pool-key-guid", no_argument, NULL,
 		    ZPOOL_OPTION_POOL_KEY_GUID},
 		{0, 0, 0, 0}
 	};
 
 	/* check options */
 	while ((c = getopt_long(argc, argv, ":jHpo:", long_options,
 	    NULL)) != -1) {
 		switch (c) {
 		case 'p':
 			cb.cb_literal = B_TRUE;
 			break;
 		case 'H':
 			cb.cb_scripted = B_TRUE;
 			break;
 		case 'j':
 			cb.cb_json = B_TRUE;
 			cb.cb_jsobj = zpool_json_schema(0, 1);
 			data = fnvlist_alloc();
 			break;
 		case ZPOOL_OPTION_POOL_KEY_GUID:
 			cb.cb_json_pool_key_guid = B_TRUE;
 			break;
 		case ZPOOL_OPTION_JSON_NUMS_AS_INT:
 			cb.cb_json_as_int = B_TRUE;
 			cb.cb_literal = B_TRUE;
 			break;
 		case 'o':
 			memset(&cb.cb_columns, 0, sizeof (cb.cb_columns));
 			i = 0;
 
 			for (char *tok; (tok = strsep(&optarg, ",")); ) {
 				static const char *const col_opts[] =
 				{ "name", "property", "value", "source",
 				    "all" };
 				static const zfs_get_column_t col_cols[] =
 				{ GET_COL_NAME, GET_COL_PROPERTY, GET_COL_VALUE,
 				    GET_COL_SOURCE };
 
 				if (i == ZFS_GET_NCOLS - 1) {
 					(void) fprintf(stderr, gettext("too "
 					"many fields given to -o "
 					"option\n"));
 					usage(B_FALSE);
 				}
 
 				for (c = 0; c < ARRAY_SIZE(col_opts); ++c)
 					if (strcmp(tok, col_opts[c]) == 0)
 						goto found;
 
 				(void) fprintf(stderr,
 				    gettext("invalid column name '%s'\n"), tok);
 				usage(B_FALSE);
 
 found:
 				if (c >= 4) {
 					if (i > 0) {
 						(void) fprintf(stderr,
 						    gettext("\"all\" conflicts "
 						    "with specific fields "
 						    "given to -o option\n"));
 						usage(B_FALSE);
 					}
 
 					memcpy(cb.cb_columns, col_cols,
 					    sizeof (col_cols));
 					i = ZFS_GET_NCOLS - 1;
 				} else
 					cb.cb_columns[i++] = col_cols[c];
 			}
 			break;
 		case '?':
 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
 			    optopt);
 			usage(B_FALSE);
 		}
 	}
 
 	argc -= optind;
 	argv += optind;
 
 	if (!cb.cb_json && cb.cb_json_as_int) {
 		(void) fprintf(stderr, gettext("'--json-int' only works with"
 		    " '-j' option\n"));
 		usage(B_FALSE);
 	}
 
 	if (!cb.cb_json && cb.cb_json_pool_key_guid) {
 		(void) fprintf(stderr, gettext("'json-pool-key-guid' only"
 		    " works with '-j' option\n"));
 		usage(B_FALSE);
 	}
 
 	if (argc < 1) {
 		(void) fprintf(stderr, gettext("missing property "
 		    "argument\n"));
 		usage(B_FALSE);
 	}
 
 	/* Properties list is needed later by zprop_get_list() */
 	propstr = argv[0];
 
 	argc--;
 	argv++;
 
 	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_all_pools(1, argv)) {
 		/* The first arg is a pool name */
 		if ((argc == 2 && strcmp(argv[1], "all-vdevs") == 0) ||
 		    (argc == 2 && strcmp(argv[1], "root") == 0) ||
 		    are_vdevs_in_pool(argc - 1, argv + 1, argv[0],
 		    &cb.cb_vdevs)) {
 
 			if (strcmp(argv[1], "root") == 0)
 				vdev = strdup("root-0");
 			else
 				vdev = strdup(argv[1]);
 
 			/* ... and the rest are vdev names */
 			cb.cb_vdevs.cb_names = &vdev;
 			cb.cb_vdevs.cb_names_count = argc - 1;
 			cb.cb_type = ZFS_TYPE_VDEV;
 			argc = 1; /* One pool to process */
 		} else {
 			if (cb.cb_json) {
 				nvlist_free(cb.cb_jsobj);
 				nvlist_free(data);
 			}
 			fprintf(stderr, gettext("Expected a list of vdevs in"
 			    " \"%s\", but got:\n"), argv[0]);
 			error_list_unresolved_vdevs(argc - 1, argv + 1,
 			    argv[0], &cb.cb_vdevs);
 			fprintf(stderr, "\n");
 			usage(B_FALSE);
 			return (1);
 		}
 	} else {
 		if (cb.cb_json) {
 			nvlist_free(cb.cb_jsobj);
 			nvlist_free(data);
 		}
 		/*
 		 * The first arg isn't the name of a valid pool.
 		 */
 		fprintf(stderr, gettext("Cannot get properties of %s: "
 		    "no such pool available.\n"), argv[0]);
 		return (1);
 	}
 
 	if (zprop_get_list(g_zfs, propstr, &cb.cb_proplist,
 	    cb.cb_type) != 0) {
 		/* Use correct list of valid properties (pool or vdev) */
 		current_prop_type = cb.cb_type;
 		usage(B_FALSE);
 	}
 
 	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;
 	}
 
 	if (cb.cb_json) {
 		if (cb.cb_type == ZFS_TYPE_VDEV)
 			fnvlist_add_nvlist(cb.cb_jsobj, "vdevs", data);
 		else
 			fnvlist_add_nvlist(cb.cb_jsobj, "pools", data);
 		fnvlist_free(data);
 	}
 
 	ret = for_each_pool(argc, argv, B_TRUE, &cb.cb_proplist, cb.cb_type,
 	    cb.cb_literal, get_callback, &cb);
 
 	if (ret == 0 && cb.cb_json)
 		zcmd_print_json(cb.cb_jsobj);
 	else if (ret != 0 && cb.cb_json)
 		nvlist_free(cb.cb_jsobj);
 
 	if (cb.cb_proplist == &fake_name)
 		zprop_free_list(fake_name.pl_next);
 	else
 		zprop_free_list(cb.cb_proplist);
 
 	if (vdev != NULL)
 		free(vdev);
 
 	return (ret);
 }
 
 typedef struct set_cbdata {
 	char *cb_propname;
 	char *cb_value;
 	zfs_type_t cb_type;
 	vdev_cbdata_t cb_vdevs;
 	boolean_t cb_any_successful;
 } set_cbdata_t;
 
 static int
 set_pool_callback(zpool_handle_t *zhp, set_cbdata_t *cb)
 {
 	int error;
 
 	/* 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);
 
 	return (error);
 }
 
 static int
 set_callback(zpool_handle_t *zhp, void *data)
 {
 	int error;
 	set_cbdata_t *cb = (set_cbdata_t *)data;
 
 	if (cb->cb_type == ZFS_TYPE_VDEV) {
 		error = zpool_set_vdev_prop(zhp, *cb->cb_vdevs.cb_names,
 		    cb->cb_propname, cb->cb_value);
 	} else {
 		assert(cb->cb_type == ZFS_TYPE_POOL);
 		error = set_pool_callback(zhp, cb);
 	}
 
 	cb->cb_any_successful = !error;
 	return (error);
 }
 
 int
 zpool_do_set(int argc, char **argv)
 {
 	set_cbdata_t cb = { 0 };
 	int error;
 	char *vdev = NULL;
 
 	current_prop_type = ZFS_TYPE_POOL;
 	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 > 4) {
 		(void) fprintf(stderr, gettext("too many pool names\n"));
 		usage(B_FALSE);
 	}
 
 	cb.cb_propname = argv[1];
 	cb.cb_type = ZFS_TYPE_POOL;
 	cb.cb_vdevs.cb_name_flags |= VDEV_NAME_TYPE_ID;
 	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++;
 	argc -= 2;
 	argv += 2;
 
 	/* argv[0] is pool name */
 	if (!is_pool(argv[0])) {
 		(void) fprintf(stderr,
 		    gettext("cannot open '%s': is not a pool\n"), argv[0]);
 		return (EINVAL);
 	}
 
 	/* argv[1], when supplied, is vdev name */
 	if (argc == 2) {
 
 		if (strcmp(argv[1], "root") == 0)
 			vdev = strdup("root-0");
 		else
 			vdev = strdup(argv[1]);
 
 		if (!are_vdevs_in_pool(1, &vdev, argv[0], &cb.cb_vdevs)) {
 			(void) fprintf(stderr, gettext(
 			    "cannot find '%s' in '%s': device not in pool\n"),
 			    vdev, argv[0]);
 			free(vdev);
 			return (EINVAL);
 		}
 		cb.cb_vdevs.cb_names = &vdev;
 		cb.cb_vdevs.cb_names_count = 1;
 		cb.cb_type = ZFS_TYPE_VDEV;
 	}
 
 	error = for_each_pool(1, argv, B_TRUE, NULL, ZFS_TYPE_POOL,
 	    B_FALSE, set_callback, &cb);
 
 	if (vdev != NULL)
 		free(vdev);
 
 	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;
 	const 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;
 	pool_raidz_expand_stat_t *pres = NULL;
 	const char *const headers[] = {"DISCARD", "FREE", "INITIALIZE",
 	    "REPLACE", "REMOVE", "RESILVER", "SCRUB", "TRIM", "RAIDZ_EXPAND"};
 	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;
 	}
 
 	if (timestamp_fmt != NODATE)
 		print_timestamp(timestamp_fmt);
 
 	/* 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) fputc('\n', stdout);
 	}
 
 	/* 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);
 	}
 
 	(void) nvlist_lookup_uint64_array(nvroot,
 	    ZPOOL_CONFIG_RAIDZ_EXPAND_STATS, (uint64_t **)&pres, &c);
 	if (pres != NULL && pres->pres_state == DSS_SCANNING) {
 		int64_t rem = pres->pres_to_reflow - pres->pres_reflowed;
 		bytes_rem[ZPOOL_WAIT_RAIDZ_EXPAND] = rem;
 	}
 
 	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];
 
 	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, 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':
 			/* Reset activities array */
 			memset(&wd.wd_enabled, 0, sizeof (wd.wd_enabled));
 
 			for (char *tok; (tok = strsep(&optarg, ",")); ) {
 				static const char *const col_opts[] = {
 				    "discard", "free", "initialize", "replace",
 				    "remove", "resilver", "scrub", "trim",
 				    "raidz_expand" };
 
 				for (i = 0; i < ARRAY_SIZE(col_opts); ++i)
 					if (strcmp(tok, col_opts[i]) == 0) {
 						wd.wd_enabled[i] = B_TRUE;
 						goto found;
 					}
 
 				(void) fprintf(stderr,
 				    gettext("invalid activity '%s'\n"), tok);
 				usage(B_FALSE);
 found:;
 			}
 			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);
 }
 
 /*
  * zpool ddtprune -d|-p <amount> <pool>
  *
  *       -d <days>	Prune entries <days> old and older
  *       -p <percent>	Prune <percent> amount of entries
  *
  * Prune single reference entries from DDT to satisfy the amount specified.
  */
 int
 zpool_do_ddt_prune(int argc, char **argv)
 {
 	zpool_ddt_prune_unit_t unit = ZPOOL_DDT_PRUNE_NONE;
 	uint64_t amount = 0;
 	zpool_handle_t *zhp;
 	char *endptr;
 	int c;
 
 	while ((c = getopt(argc, argv, "d:p:")) != -1) {
 		switch (c) {
 		case 'd':
 			if (unit == ZPOOL_DDT_PRUNE_PERCENTAGE) {
 				(void) fprintf(stderr, gettext("-d cannot be "
 				    "combined with -p option\n"));
 				usage(B_FALSE);
 			}
 			errno = 0;
 			amount = strtoull(optarg, &endptr, 0);
 			if (errno != 0 || *endptr != '\0' || amount == 0) {
 				(void) fprintf(stderr,
 				    gettext("invalid days value\n"));
 				usage(B_FALSE);
 			}
 			amount *= 86400;	/* convert days to seconds */
 			unit = ZPOOL_DDT_PRUNE_AGE;
 			break;
 		case 'p':
 			if (unit == ZPOOL_DDT_PRUNE_AGE) {
 				(void) fprintf(stderr, gettext("-p cannot be "
 				    "combined with -d option\n"));
 				usage(B_FALSE);
 			}
 			errno = 0;
 			amount = strtoull(optarg, &endptr, 0);
 			if (errno != 0 || *endptr != '\0' ||
 			    amount == 0 || amount > 100) {
 				(void) fprintf(stderr,
 				    gettext("invalid percentage value\n"));
 				usage(B_FALSE);
 			}
 			unit = ZPOOL_DDT_PRUNE_PERCENTAGE;
 			break;
 		case '?':
 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
 			    optopt);
 			usage(B_FALSE);
 		}
 	}
 	argc -= optind;
 	argv += optind;
 
 	if (unit == ZPOOL_DDT_PRUNE_NONE) {
 		(void) fprintf(stderr,
 		    gettext("missing amount option (-d|-p <value>)\n"));
 		usage(B_FALSE);
 	} else if (argc < 1) {
 		(void) fprintf(stderr, gettext("missing pool argument\n"));
 		usage(B_FALSE);
 	} else if (argc > 1) {
 		(void) fprintf(stderr, gettext("too many arguments\n"));
 		usage(B_FALSE);
 	}
 	zhp = zpool_open(g_zfs, argv[0]);
 	if (zhp == NULL)
 		return (-1);
 
 	int error = zpool_ddt_prune(zhp, unit, amount);
 
 	zpool_close(zhp);
 
 	return (error);
 }
 
 static int
 find_command_idx(const char *command, int *idx)
 {
 	for (int 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)
 {
 	int c;
 	nvlist_t *jsobj = NULL, *zfs_ver = NULL;
 	boolean_t json = B_FALSE;
-	while ((c = getopt(argc, argv, "j")) != -1) {
+
+	struct option long_options[] = {
+		{"json", no_argument, NULL, 'j'},
+	};
+
+	while ((c = getopt_long(argc, argv, "j", long_options, NULL)) != -1) {
 		switch (c) {
 		case 'j':
 			json = B_TRUE;
 			jsobj = zpool_json_schema(0, 1);
 			break;
 		case '?':
 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
 			    optopt);
 			usage(B_FALSE);
 		}
 	}
 
 	argc -= optind;
 	if (argc != 0) {
 		(void) fprintf(stderr, "too many arguments\n");
 		usage(B_FALSE);
 	}
 
 	if (json) {
 		zfs_ver = zfs_version_nvlist();
 		if (zfs_ver) {
 			fnvlist_add_nvlist(jsobj, "zfs_version", zfs_ver);
 			zcmd_print_json(jsobj);
 			fnvlist_free(zfs_ver);
 			return (0);
 		} else
 			return (-1);
 	} else
 		return (zfs_version_print() != 0);
 }
 
 /* Display documentation */
 static int
 zpool_do_help(int argc, char **argv)
 {
 	char page[MAXNAMELEN];
 	if (argc < 3 || strcmp(argv[2], "zpool") == 0)
 		strcpy(page, "zpool");
 	else if (strcmp(argv[2], "concepts") == 0 ||
 	    strcmp(argv[2], "props") == 0)
 		snprintf(page, sizeof (page), "zpool%s", argv[2]);
 	else
 		snprintf(page, sizeof (page), "zpool-%s", argv[2]);
 
 	execlp("man", "man", page, NULL);
 
 	fprintf(stderr, "couldn't run man program: %s", strerror(errno));
 	return (-1);
 }
 
 /*
  * 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));
+		return (zfs_version_print() != 0);
 
 	/*
 	 * Special case 'help'
 	 */
 	if (strcmp(cmdname, "help") == 0)
 		return (zpool_do_help(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 = safe_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/ztest.c b/sys/contrib/openzfs/cmd/ztest.c
index 523f280aae1a..4a7959ebfca5 100644
--- a/sys/contrib/openzfs/cmd/ztest.c
+++ b/sys/contrib/openzfs/cmd/ztest.c
@@ -1,9120 +1,9137 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2011, 2024 by Delphix. All rights reserved.
  * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
  * Copyright (c) 2013 Steven Hartland. All rights reserved.
  * Copyright (c) 2014 Integros [integros.com]
  * Copyright 2017 Joyent, Inc.
  * Copyright (c) 2017, Intel Corporation.
  * Copyright (c) 2023, Klara, Inc.
  */
 
 /*
  * The objective of this program is to provide a DMU/ZAP/SPA stress test
  * that runs entirely in userland, is easy to use, and easy to extend.
  *
  * The overall design of the ztest program is as follows:
  *
  * (1) For each major functional area (e.g. adding vdevs to a pool,
  *     creating and destroying datasets, reading and writing objects, etc)
  *     we have a simple routine to test that functionality.  These
  *     individual routines do not have to do anything "stressful".
  *
  * (2) We turn these simple functionality tests into a stress test by
  *     running them all in parallel, with as many threads as desired,
  *     and spread across as many datasets, objects, and vdevs as desired.
  *
  * (3) While all this is happening, we inject faults into the pool to
  *     verify that self-healing data really works.
  *
  * (4) Every time we open a dataset, we change its checksum and compression
  *     functions.  Thus even individual objects vary from block to block
  *     in which checksum they use and whether they're compressed.
  *
  * (5) To verify that we never lose on-disk consistency after a crash,
  *     we run the entire test in a child of the main process.
  *     At random times, the child self-immolates with a SIGKILL.
  *     This is the software equivalent of pulling the power cord.
  *     The parent then runs the test again, using the existing
  *     storage pool, as many times as desired. If backwards compatibility
  *     testing is enabled ztest will sometimes run the "older" version
  *     of ztest after a SIGKILL.
  *
  * (6) To verify that we don't have future leaks or temporal incursions,
  *     many of the functional tests record the transaction group number
  *     as part of their data.  When reading old data, they verify that
  *     the transaction group number is less than the current, open txg.
  *     If you add a new test, please do this if applicable.
  *
  * (7) Threads are created with a reduced stack size, for sanity checking.
  *     Therefore, it's important not to allocate huge buffers on the stack.
  *
  * When run with no arguments, ztest runs for about five minutes and
  * produces no output if successful.  To get a little bit of information,
  * specify -V.  To get more information, specify -VV, and so on.
  *
  * To turn this into an overnight stress test, use -T to specify run time.
  *
  * You can ask more vdevs [-v], datasets [-d], or threads [-t]
  * to increase the pool capacity, fanout, and overall stress level.
  *
  * Use the -k option to set the desired frequency of kills.
  *
  * When ztest invokes itself it passes all relevant information through a
  * temporary file which is mmap-ed in the child process. This allows shared
  * memory to survive the exec syscall. The ztest_shared_hdr_t struct is always
  * stored at offset 0 of this file and contains information on the size and
  * number of shared structures in the file. The information stored in this file
  * must remain backwards compatible with older versions of ztest so that
  * ztest can invoke them during backwards compatibility testing (-B).
  */
 
 #include <sys/zfs_context.h>
 #include <sys/spa.h>
 #include <sys/dmu.h>
 #include <sys/txg.h>
 #include <sys/dbuf.h>
 #include <sys/zap.h>
 #include <sys/dmu_objset.h>
 #include <sys/poll.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/wait.h>
 #include <sys/mman.h>
 #include <sys/resource.h>
 #include <sys/zio.h>
 #include <sys/zil.h>
 #include <sys/zil_impl.h>
 #include <sys/vdev_draid.h>
 #include <sys/vdev_impl.h>
 #include <sys/vdev_file.h>
 #include <sys/vdev_initialize.h>
 #include <sys/vdev_raidz.h>
 #include <sys/vdev_trim.h>
 #include <sys/spa_impl.h>
 #include <sys/metaslab_impl.h>
 #include <sys/dsl_prop.h>
 #include <sys/dsl_dataset.h>
 #include <sys/dsl_destroy.h>
 #include <sys/dsl_scan.h>
 #include <sys/zio_checksum.h>
 #include <sys/zfs_refcount.h>
 #include <sys/zfeature.h>
 #include <sys/dsl_userhold.h>
 #include <sys/abd.h>
 #include <sys/blake3.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <getopt.h>
 #include <signal.h>
 #include <umem.h>
 #include <ctype.h>
 #include <math.h>
 #include <sys/fs/zfs.h>
 #include <zfs_fletcher.h>
 #include <libnvpair.h>
 #include <libzutil.h>
 #include <sys/crypto/icp.h>
 #include <sys/zfs_impl.h>
 #include <sys/backtrace.h>
 
 static int ztest_fd_data = -1;
 static int ztest_fd_rand = -1;
 
 typedef struct ztest_shared_hdr {
 	uint64_t	zh_hdr_size;
 	uint64_t	zh_opts_size;
 	uint64_t	zh_size;
 	uint64_t	zh_stats_size;
 	uint64_t	zh_stats_count;
 	uint64_t	zh_ds_size;
 	uint64_t	zh_ds_count;
 	uint64_t	zh_scratch_state_size;
 } ztest_shared_hdr_t;
 
 static ztest_shared_hdr_t *ztest_shared_hdr;
 
 enum ztest_class_state {
 	ZTEST_VDEV_CLASS_OFF,
 	ZTEST_VDEV_CLASS_ON,
 	ZTEST_VDEV_CLASS_RND
 };
 
 /* Dedicated RAIDZ Expansion test states */
 typedef enum {
 	RAIDZ_EXPAND_NONE,		/* Default is none, must opt-in	*/
 	RAIDZ_EXPAND_REQUESTED,		/* The '-X' option was used	*/
 	RAIDZ_EXPAND_STARTED,		/* Testing has commenced	*/
 	RAIDZ_EXPAND_KILLED,		/* Reached the proccess kill	*/
 	RAIDZ_EXPAND_CHECKED,		/* Pool scrub verification done	*/
 } raidz_expand_test_state_t;
 
 
 #define	ZO_GVARS_MAX_ARGLEN	((size_t)64)
 #define	ZO_GVARS_MAX_COUNT	((size_t)10)
 
 typedef struct ztest_shared_opts {
 	char zo_pool[ZFS_MAX_DATASET_NAME_LEN];
 	char zo_dir[ZFS_MAX_DATASET_NAME_LEN];
 	char zo_alt_ztest[MAXNAMELEN];
 	char zo_alt_libpath[MAXNAMELEN];
 	uint64_t zo_vdevs;
 	uint64_t zo_vdevtime;
 	size_t zo_vdev_size;
 	int zo_ashift;
 	int zo_mirrors;
 	int zo_raid_do_expand;
 	int zo_raid_children;
 	int zo_raid_parity;
 	char zo_raid_type[8];
 	int zo_draid_data;
 	int zo_draid_spares;
 	int zo_datasets;
 	int zo_threads;
 	uint64_t zo_passtime;
 	uint64_t zo_killrate;
 	int zo_verbose;
 	int zo_init;
 	uint64_t zo_time;
 	uint64_t zo_maxloops;
 	uint64_t zo_metaslab_force_ganging;
 	raidz_expand_test_state_t zo_raidz_expand_test;
 	int zo_mmp_test;
 	int zo_special_vdevs;
 	int zo_dump_dbgmsg;
 	int zo_gvars_count;
 	char zo_gvars[ZO_GVARS_MAX_COUNT][ZO_GVARS_MAX_ARGLEN];
 } ztest_shared_opts_t;
 
 /* Default values for command line options. */
 #define	DEFAULT_POOL "ztest"
 #define	DEFAULT_VDEV_DIR "/tmp"
 #define	DEFAULT_VDEV_COUNT 5
 #define	DEFAULT_VDEV_SIZE (SPA_MINDEVSIZE * 4)	/* 256m default size */
 #define	DEFAULT_VDEV_SIZE_STR "256M"
 #define	DEFAULT_ASHIFT SPA_MINBLOCKSHIFT
 #define	DEFAULT_MIRRORS 2
 #define	DEFAULT_RAID_CHILDREN 4
 #define	DEFAULT_RAID_PARITY 1
 #define	DEFAULT_DRAID_DATA 4
 #define	DEFAULT_DRAID_SPARES 1
 #define	DEFAULT_DATASETS_COUNT 7
 #define	DEFAULT_THREADS 23
 #define	DEFAULT_RUN_TIME 300 /* 300 seconds */
 #define	DEFAULT_RUN_TIME_STR "300 sec"
 #define	DEFAULT_PASS_TIME 60 /* 60 seconds */
 #define	DEFAULT_PASS_TIME_STR "60 sec"
 #define	DEFAULT_KILL_RATE 70 /* 70% kill rate */
 #define	DEFAULT_KILLRATE_STR "70%"
 #define	DEFAULT_INITS 1
 #define	DEFAULT_MAX_LOOPS 50 /* 5 minutes */
 #define	DEFAULT_FORCE_GANGING (64 << 10)
 #define	DEFAULT_FORCE_GANGING_STR "64K"
 
 /* Simplifying assumption: -1 is not a valid default. */
 #define	NO_DEFAULT -1
 
 static const ztest_shared_opts_t ztest_opts_defaults = {
 	.zo_pool = DEFAULT_POOL,
 	.zo_dir = DEFAULT_VDEV_DIR,
 	.zo_alt_ztest = { '\0' },
 	.zo_alt_libpath = { '\0' },
 	.zo_vdevs = DEFAULT_VDEV_COUNT,
 	.zo_ashift = DEFAULT_ASHIFT,
 	.zo_mirrors = DEFAULT_MIRRORS,
 	.zo_raid_children = DEFAULT_RAID_CHILDREN,
 	.zo_raid_parity = DEFAULT_RAID_PARITY,
 	.zo_raid_type = VDEV_TYPE_RAIDZ,
 	.zo_vdev_size = DEFAULT_VDEV_SIZE,
 	.zo_draid_data = DEFAULT_DRAID_DATA,	/* data drives */
 	.zo_draid_spares = DEFAULT_DRAID_SPARES, /* distributed spares */
 	.zo_datasets = DEFAULT_DATASETS_COUNT,
 	.zo_threads = DEFAULT_THREADS,
 	.zo_passtime = DEFAULT_PASS_TIME,
 	.zo_killrate = DEFAULT_KILL_RATE,
 	.zo_verbose = 0,
 	.zo_mmp_test = 0,
 	.zo_init = DEFAULT_INITS,
 	.zo_time = DEFAULT_RUN_TIME,
 	.zo_maxloops = DEFAULT_MAX_LOOPS, /* max loops during spa_freeze() */
 	.zo_metaslab_force_ganging = DEFAULT_FORCE_GANGING,
 	.zo_special_vdevs = ZTEST_VDEV_CLASS_RND,
 	.zo_gvars_count = 0,
 	.zo_raidz_expand_test = RAIDZ_EXPAND_NONE,
 };
 
 extern uint64_t metaslab_force_ganging;
 extern uint64_t metaslab_df_alloc_threshold;
 extern uint64_t zfs_deadman_synctime_ms;
 extern uint_t metaslab_preload_limit;
 extern int zfs_compressed_arc_enabled;
 extern int zfs_abd_scatter_enabled;
 extern uint_t dmu_object_alloc_chunk_shift;
 extern boolean_t zfs_force_some_double_word_sm_entries;
 extern unsigned long zio_decompress_fail_fraction;
 extern unsigned long zfs_reconstruct_indirect_damage_fraction;
 extern uint64_t raidz_expand_max_reflow_bytes;
 extern uint_t raidz_expand_pause_point;
 extern boolean_t ddt_prune_artificial_age;
 extern boolean_t ddt_dump_prune_histogram;
 
 
 static ztest_shared_opts_t *ztest_shared_opts;
 static ztest_shared_opts_t ztest_opts;
 static const char *const ztest_wkeydata = "abcdefghijklmnopqrstuvwxyz012345";
 
 typedef struct ztest_shared_ds {
 	uint64_t	zd_seq;
 } ztest_shared_ds_t;
 
 static ztest_shared_ds_t *ztest_shared_ds;
 #define	ZTEST_GET_SHARED_DS(d) (&ztest_shared_ds[d])
 
 typedef struct ztest_scratch_state {
 	uint64_t	zs_raidz_scratch_verify_pause;
 } ztest_shared_scratch_state_t;
 
 static ztest_shared_scratch_state_t *ztest_scratch_state;
 
 #define	BT_MAGIC	0x123456789abcdefULL
 #define	MAXFAULTS(zs) \
 	(MAX((zs)->zs_mirrors, 1) * (ztest_opts.zo_raid_parity + 1) - 1)
 
 enum ztest_io_type {
 	ZTEST_IO_WRITE_TAG,
 	ZTEST_IO_WRITE_PATTERN,
 	ZTEST_IO_WRITE_ZEROES,
 	ZTEST_IO_TRUNCATE,
 	ZTEST_IO_SETATTR,
 	ZTEST_IO_REWRITE,
 	ZTEST_IO_TYPES
 };
 
 typedef struct ztest_block_tag {
 	uint64_t	bt_magic;
 	uint64_t	bt_objset;
 	uint64_t	bt_object;
 	uint64_t	bt_dnodesize;
 	uint64_t	bt_offset;
 	uint64_t	bt_gen;
 	uint64_t	bt_txg;
 	uint64_t	bt_crtxg;
 } ztest_block_tag_t;
 
 typedef struct bufwad {
 	uint64_t	bw_index;
 	uint64_t	bw_txg;
 	uint64_t	bw_data;
 } bufwad_t;
 
 /*
  * It would be better to use a rangelock_t per object.  Unfortunately
  * the rangelock_t is not a drop-in replacement for rl_t, because we
  * still need to map from object ID to rangelock_t.
  */
 typedef enum {
 	ZTRL_READER,
 	ZTRL_WRITER,
 	ZTRL_APPEND
 } rl_type_t;
 
 typedef struct rll {
 	void		*rll_writer;
 	int		rll_readers;
 	kmutex_t	rll_lock;
 	kcondvar_t	rll_cv;
 } rll_t;
 
 typedef struct rl {
 	uint64_t	rl_object;
 	uint64_t	rl_offset;
 	uint64_t	rl_size;
 	rll_t		*rl_lock;
 } rl_t;
 
 #define	ZTEST_RANGE_LOCKS	64
 #define	ZTEST_OBJECT_LOCKS	64
 
 /*
  * Object descriptor.  Used as a template for object lookup/create/remove.
  */
 typedef struct ztest_od {
 	uint64_t	od_dir;
 	uint64_t	od_object;
 	dmu_object_type_t od_type;
 	dmu_object_type_t od_crtype;
 	uint64_t	od_blocksize;
 	uint64_t	od_crblocksize;
 	uint64_t	od_crdnodesize;
 	uint64_t	od_gen;
 	uint64_t	od_crgen;
 	char		od_name[ZFS_MAX_DATASET_NAME_LEN];
 } ztest_od_t;
 
 /*
  * Per-dataset state.
  */
 typedef struct ztest_ds {
 	ztest_shared_ds_t *zd_shared;
 	objset_t	*zd_os;
 	pthread_rwlock_t zd_zilog_lock;
 	zilog_t		*zd_zilog;
 	ztest_od_t	*zd_od;		/* debugging aid */
 	char		zd_name[ZFS_MAX_DATASET_NAME_LEN];
 	kmutex_t	zd_dirobj_lock;
 	rll_t		zd_object_lock[ZTEST_OBJECT_LOCKS];
 	rll_t		zd_range_lock[ZTEST_RANGE_LOCKS];
 } ztest_ds_t;
 
 /*
  * Per-iteration state.
  */
 typedef void ztest_func_t(ztest_ds_t *zd, uint64_t id);
 
 typedef struct ztest_info {
 	ztest_func_t	*zi_func;	/* test function */
 	uint64_t	zi_iters;	/* iterations per execution */
 	uint64_t	*zi_interval;	/* execute every <interval> seconds */
 	const char	*zi_funcname;	/* name of test function */
 } ztest_info_t;
 
 typedef struct ztest_shared_callstate {
 	uint64_t	zc_count;	/* per-pass count */
 	uint64_t	zc_time;	/* per-pass time */
 	uint64_t	zc_next;	/* next time to call this function */
 } ztest_shared_callstate_t;
 
 static ztest_shared_callstate_t *ztest_shared_callstate;
 #define	ZTEST_GET_SHARED_CALLSTATE(c) (&ztest_shared_callstate[c])
 
 ztest_func_t ztest_dmu_read_write;
 ztest_func_t ztest_dmu_write_parallel;
 ztest_func_t ztest_dmu_object_alloc_free;
 ztest_func_t ztest_dmu_object_next_chunk;
 ztest_func_t ztest_dmu_commit_callbacks;
 ztest_func_t ztest_zap;
 ztest_func_t ztest_zap_parallel;
 ztest_func_t ztest_zil_commit;
 ztest_func_t ztest_zil_remount;
 ztest_func_t ztest_dmu_read_write_zcopy;
 ztest_func_t ztest_dmu_objset_create_destroy;
 ztest_func_t ztest_dmu_prealloc;
 ztest_func_t ztest_fzap;
 ztest_func_t ztest_dmu_snapshot_create_destroy;
 ztest_func_t ztest_dsl_prop_get_set;
 ztest_func_t ztest_spa_prop_get_set;
 ztest_func_t ztest_spa_create_destroy;
 ztest_func_t ztest_fault_inject;
 ztest_func_t ztest_dmu_snapshot_hold;
 ztest_func_t ztest_mmp_enable_disable;
 ztest_func_t ztest_scrub;
 ztest_func_t ztest_dsl_dataset_promote_busy;
 ztest_func_t ztest_vdev_attach_detach;
 ztest_func_t ztest_vdev_raidz_attach;
 ztest_func_t ztest_vdev_LUN_growth;
 ztest_func_t ztest_vdev_add_remove;
 ztest_func_t ztest_vdev_class_add;
 ztest_func_t ztest_vdev_aux_add_remove;
 ztest_func_t ztest_split_pool;
 ztest_func_t ztest_reguid;
 ztest_func_t ztest_spa_upgrade;
 ztest_func_t ztest_device_removal;
 ztest_func_t ztest_spa_checkpoint_create_discard;
 ztest_func_t ztest_initialize;
 ztest_func_t ztest_trim;
 ztest_func_t ztest_blake3;
 ztest_func_t ztest_fletcher;
 ztest_func_t ztest_fletcher_incr;
 ztest_func_t ztest_verify_dnode_bt;
 ztest_func_t ztest_pool_prefetch_ddt;
 ztest_func_t ztest_ddt_prune;
 
 static uint64_t zopt_always = 0ULL * NANOSEC;		/* all the time */
 static uint64_t zopt_incessant = 1ULL * NANOSEC / 10;	/* every 1/10 second */
 static uint64_t zopt_often = 1ULL * NANOSEC;		/* every second */
 static uint64_t zopt_sometimes = 10ULL * NANOSEC;	/* every 10 seconds */
 static uint64_t zopt_rarely = 60ULL * NANOSEC;		/* every 60 seconds */
 
 #define	ZTI_INIT(func, iters, interval) \
 	{   .zi_func = (func), \
 	    .zi_iters = (iters), \
 	    .zi_interval = (interval), \
 	    .zi_funcname = # func }
 
 static ztest_info_t ztest_info[] = {
 	ZTI_INIT(ztest_dmu_read_write, 1, &zopt_always),
 	ZTI_INIT(ztest_dmu_write_parallel, 10, &zopt_always),
 	ZTI_INIT(ztest_dmu_object_alloc_free, 1, &zopt_always),
 	ZTI_INIT(ztest_dmu_object_next_chunk, 1, &zopt_sometimes),
 	ZTI_INIT(ztest_dmu_commit_callbacks, 1, &zopt_always),
 	ZTI_INIT(ztest_zap, 30, &zopt_always),
 	ZTI_INIT(ztest_zap_parallel, 100, &zopt_always),
 	ZTI_INIT(ztest_split_pool, 1, &zopt_sometimes),
 	ZTI_INIT(ztest_zil_commit, 1, &zopt_incessant),
 	ZTI_INIT(ztest_zil_remount, 1, &zopt_sometimes),
 	ZTI_INIT(ztest_dmu_read_write_zcopy, 1, &zopt_often),
 	ZTI_INIT(ztest_dmu_objset_create_destroy, 1, &zopt_often),
 	ZTI_INIT(ztest_dsl_prop_get_set, 1, &zopt_often),
 	ZTI_INIT(ztest_spa_prop_get_set, 1, &zopt_sometimes),
 #if 0
 	ZTI_INIT(ztest_dmu_prealloc, 1, &zopt_sometimes),
 #endif
 	ZTI_INIT(ztest_fzap, 1, &zopt_sometimes),
 	ZTI_INIT(ztest_dmu_snapshot_create_destroy, 1, &zopt_sometimes),
 	ZTI_INIT(ztest_spa_create_destroy, 1, &zopt_sometimes),
 	ZTI_INIT(ztest_fault_inject, 1, &zopt_sometimes),
 	ZTI_INIT(ztest_dmu_snapshot_hold, 1, &zopt_sometimes),
 	ZTI_INIT(ztest_mmp_enable_disable, 1, &zopt_sometimes),
 	ZTI_INIT(ztest_reguid, 1, &zopt_rarely),
 	ZTI_INIT(ztest_scrub, 1, &zopt_rarely),
 	ZTI_INIT(ztest_spa_upgrade, 1, &zopt_rarely),
 	ZTI_INIT(ztest_dsl_dataset_promote_busy, 1, &zopt_rarely),
 	ZTI_INIT(ztest_vdev_attach_detach, 1, &zopt_sometimes),
 	ZTI_INIT(ztest_vdev_raidz_attach, 1, &zopt_sometimes),
 	ZTI_INIT(ztest_vdev_LUN_growth, 1, &zopt_rarely),
 	ZTI_INIT(ztest_vdev_add_remove, 1, &ztest_opts.zo_vdevtime),
 	ZTI_INIT(ztest_vdev_class_add, 1, &ztest_opts.zo_vdevtime),
 	ZTI_INIT(ztest_vdev_aux_add_remove, 1, &ztest_opts.zo_vdevtime),
 	ZTI_INIT(ztest_device_removal, 1, &zopt_sometimes),
 	ZTI_INIT(ztest_spa_checkpoint_create_discard, 1, &zopt_rarely),
 	ZTI_INIT(ztest_initialize, 1, &zopt_sometimes),
 	ZTI_INIT(ztest_trim, 1, &zopt_sometimes),
 	ZTI_INIT(ztest_blake3, 1, &zopt_rarely),
 	ZTI_INIT(ztest_fletcher, 1, &zopt_rarely),
 	ZTI_INIT(ztest_fletcher_incr, 1, &zopt_rarely),
 	ZTI_INIT(ztest_verify_dnode_bt, 1, &zopt_sometimes),
 	ZTI_INIT(ztest_pool_prefetch_ddt, 1, &zopt_rarely),
 	ZTI_INIT(ztest_ddt_prune, 1, &zopt_rarely),
 };
 
 #define	ZTEST_FUNCS	(sizeof (ztest_info) / sizeof (ztest_info_t))
 
 /*
  * The following struct is used to hold a list of uncalled commit callbacks.
  * The callbacks are ordered by txg number.
  */
 typedef struct ztest_cb_list {
 	kmutex_t	zcl_callbacks_lock;
 	list_t		zcl_callbacks;
 } ztest_cb_list_t;
 
 /*
  * Stuff we need to share writably between parent and child.
  */
 typedef struct ztest_shared {
 	boolean_t	zs_do_init;
 	hrtime_t	zs_proc_start;
 	hrtime_t	zs_proc_stop;
 	hrtime_t	zs_thread_start;
 	hrtime_t	zs_thread_stop;
 	hrtime_t	zs_thread_kill;
 	uint64_t	zs_enospc_count;
 	uint64_t	zs_vdev_next_leaf;
 	uint64_t	zs_vdev_aux;
 	uint64_t	zs_alloc;
 	uint64_t	zs_space;
 	uint64_t	zs_splits;
 	uint64_t	zs_mirrors;
 	uint64_t	zs_metaslab_sz;
 	uint64_t	zs_metaslab_df_alloc_threshold;
 	uint64_t	zs_guid;
 } ztest_shared_t;
 
 #define	ID_PARALLEL	-1ULL
 
 static char ztest_dev_template[] = "%s/%s.%llua";
 static char ztest_aux_template[] = "%s/%s.%s.%llu";
 static ztest_shared_t *ztest_shared;
 
 static spa_t *ztest_spa = NULL;
 static ztest_ds_t *ztest_ds;
 
 static kmutex_t ztest_vdev_lock;
 static boolean_t ztest_device_removal_active = B_FALSE;
 static boolean_t ztest_pool_scrubbed = B_FALSE;
 static kmutex_t ztest_checkpoint_lock;
 
 /*
  * The ztest_name_lock protects the pool and dataset namespace used by
  * the individual tests. To modify the namespace, consumers must grab
  * this lock as writer. Grabbing the lock as reader will ensure that the
  * namespace does not change while the lock is held.
  */
 static pthread_rwlock_t ztest_name_lock;
 
 static boolean_t ztest_dump_core = B_TRUE;
 static boolean_t ztest_exiting;
 
 /* Global commit callback list */
 static ztest_cb_list_t zcl;
 /* Commit cb delay */
 static uint64_t zc_min_txg_delay = UINT64_MAX;
 static int zc_cb_counter = 0;
 
 /*
  * Minimum number of commit callbacks that need to be registered for us to check
  * whether the minimum txg delay is acceptable.
  */
 #define	ZTEST_COMMIT_CB_MIN_REG	100
 
 /*
  * If a number of txgs equal to this threshold have been created after a commit
  * callback has been registered but not called, then we assume there is an
  * implementation bug.
  */
 #define	ZTEST_COMMIT_CB_THRESH	(TXG_CONCURRENT_STATES + 1000)
 
 enum ztest_object {
 	ZTEST_META_DNODE = 0,
 	ZTEST_DIROBJ,
 	ZTEST_OBJECTS
 };
 
 static __attribute__((noreturn)) void usage(boolean_t requested);
 static int ztest_scrub_impl(spa_t *spa);
 
 /*
  * These libumem hooks provide a reasonable set of defaults for the allocator's
  * debugging facilities.
  */
 const char *
 _umem_debug_init(void)
 {
 	return ("default,verbose"); /* $UMEM_DEBUG setting */
 }
 
 const char *
 _umem_logging_init(void)
 {
 	return ("fail,contents"); /* $UMEM_LOGGING setting */
 }
 
 static void
 dump_debug_buffer(void)
 {
 	ssize_t ret __attribute__((unused));
 
 	if (!ztest_opts.zo_dump_dbgmsg)
 		return;
 
 	/*
 	 * We use write() instead of printf() so that this function
 	 * is safe to call from a signal handler.
 	 */
 	ret = write(STDERR_FILENO, "\n", 1);
 	zfs_dbgmsg_print(STDERR_FILENO, "ztest");
 }
 
 static void sig_handler(int signo)
 {
 	struct sigaction action;
 
 	libspl_backtrace(STDERR_FILENO);
 	dump_debug_buffer();
 
 	/*
 	 * Restore default action and re-raise signal so SIGSEGV and
 	 * SIGABRT can trigger a core dump.
 	 */
 	action.sa_handler = SIG_DFL;
 	sigemptyset(&action.sa_mask);
 	action.sa_flags = 0;
 	(void) sigaction(signo, &action, NULL);
 	raise(signo);
 }
 
 #define	FATAL_MSG_SZ	1024
 
 static const char *fatal_msg;
 
 static __attribute__((format(printf, 2, 3))) __attribute__((noreturn)) void
 fatal(int do_perror, const char *message, ...)
 {
 	va_list args;
 	int save_errno = errno;
 	char *buf;
 
 	(void) fflush(stdout);
 	buf = umem_alloc(FATAL_MSG_SZ, UMEM_NOFAIL);
 	if (buf == NULL)
 		goto out;
 
 	va_start(args, message);
 	(void) sprintf(buf, "ztest: ");
 	/* LINTED */
 	(void) vsprintf(buf + strlen(buf), message, args);
 	va_end(args);
 	if (do_perror) {
 		(void) snprintf(buf + strlen(buf), FATAL_MSG_SZ - strlen(buf),
 		    ": %s", strerror(save_errno));
 	}
 	(void) fprintf(stderr, "%s\n", buf);
 	fatal_msg = buf;			/* to ease debugging */
 
 out:
 	if (ztest_dump_core)
 		abort();
 	else
 		dump_debug_buffer();
 
 	exit(3);
 }
 
 static int
 str2shift(const char *buf)
 {
 	const char *ends = "BKMGTPEZ";
 	int i, len;
 
 	if (buf[0] == '\0')
 		return (0);
 
 	len = strlen(ends);
 	for (i = 0; i < len; i++) {
 		if (toupper(buf[0]) == ends[i])
 			break;
 	}
 	if (i == len) {
 		(void) fprintf(stderr, "ztest: invalid bytes suffix: %s\n",
 		    buf);
 		usage(B_FALSE);
 	}
 	if (buf[1] == '\0' || (toupper(buf[1]) == 'B' && buf[2] == '\0')) {
 		return (10*i);
 	}
 	(void) fprintf(stderr, "ztest: invalid bytes suffix: %s\n", buf);
 	usage(B_FALSE);
 }
 
 static uint64_t
 nicenumtoull(const char *buf)
 {
 	char *end;
 	uint64_t val;
 
 	val = strtoull(buf, &end, 0);
 	if (end == buf) {
 		(void) fprintf(stderr, "ztest: bad numeric value: %s\n", buf);
 		usage(B_FALSE);
 	} else if (end[0] == '.') {
 		double fval = strtod(buf, &end);
 		fval *= pow(2, str2shift(end));
 		/*
 		 * UINT64_MAX is not exactly representable as a double.
 		 * The closest representation is UINT64_MAX + 1, so we
 		 * use a >= comparison instead of > for the bounds check.
 		 */
 		if (fval >= (double)UINT64_MAX) {
 			(void) fprintf(stderr, "ztest: value too large: %s\n",
 			    buf);
 			usage(B_FALSE);
 		}
 		val = (uint64_t)fval;
 	} else {
 		int shift = str2shift(end);
 		if (shift >= 64 || (val << shift) >> shift != val) {
 			(void) fprintf(stderr, "ztest: value too large: %s\n",
 			    buf);
 			usage(B_FALSE);
 		}
 		val <<= shift;
 	}
 	return (val);
 }
 
 typedef struct ztest_option {
 	const char	short_opt;
 	const char	*long_opt;
 	const char	*long_opt_param;
 	const char	*comment;
 	unsigned int	default_int;
 	const char	*default_str;
 } ztest_option_t;
 
 /*
  * The following option_table is used for generating the usage info as well as
  * the long and short option information for calling getopt_long().
  */
 static ztest_option_t option_table[] = {
 	{ 'v',	"vdevs", "INTEGER", "Number of vdevs", DEFAULT_VDEV_COUNT,
 	    NULL},
 	{ 's',	"vdev-size", "INTEGER", "Size of each vdev",
 	    NO_DEFAULT, DEFAULT_VDEV_SIZE_STR},
 	{ 'a',	"alignment-shift", "INTEGER",
 	    "Alignment shift; use 0 for random", DEFAULT_ASHIFT, NULL},
 	{ 'm',	"mirror-copies", "INTEGER", "Number of mirror copies",
 	    DEFAULT_MIRRORS, NULL},
 	{ 'r',	"raid-disks", "INTEGER", "Number of raidz/draid disks",
 	    DEFAULT_RAID_CHILDREN, NULL},
 	{ 'R',	"raid-parity", "INTEGER", "Raid parity",
 	    DEFAULT_RAID_PARITY, NULL},
 	{ 'K',  "raid-kind", "raidz|eraidz|draid|random", "Raid kind",
 	    NO_DEFAULT, "random"},
 	{ 'D',	"draid-data", "INTEGER", "Number of draid data drives",
 	    DEFAULT_DRAID_DATA, NULL},
 	{ 'S',	"draid-spares", "INTEGER", "Number of draid spares",
 	    DEFAULT_DRAID_SPARES, NULL},
 	{ 'd',	"datasets", "INTEGER", "Number of datasets",
 	    DEFAULT_DATASETS_COUNT, NULL},
 	{ 't',	"threads", "INTEGER", "Number of ztest threads",
 	    DEFAULT_THREADS, NULL},
 	{ 'g',	"gang-block-threshold", "INTEGER",
 	    "Metaslab gang block threshold",
 	    NO_DEFAULT, DEFAULT_FORCE_GANGING_STR},
 	{ 'i',	"init-count", "INTEGER", "Number of times to initialize pool",
 	    DEFAULT_INITS, NULL},
 	{ 'k',	"kill-percentage", "INTEGER", "Kill percentage",
 	    NO_DEFAULT, DEFAULT_KILLRATE_STR},
 	{ 'p',	"pool-name", "STRING", "Pool name",
 	    NO_DEFAULT, DEFAULT_POOL},
 	{ 'f',	"vdev-file-directory", "PATH", "File directory for vdev files",
 	    NO_DEFAULT, DEFAULT_VDEV_DIR},
 	{ 'M',	"multi-host", NULL,
 	    "Multi-host; simulate pool imported on remote host",
 	    NO_DEFAULT, NULL},
 	{ 'E',	"use-existing-pool", NULL,
 	    "Use existing pool instead of creating new one", NO_DEFAULT, NULL},
 	{ 'T',	"run-time", "INTEGER", "Total run time",
 	    NO_DEFAULT, DEFAULT_RUN_TIME_STR},
 	{ 'P',	"pass-time", "INTEGER", "Time per pass",
 	    NO_DEFAULT, DEFAULT_PASS_TIME_STR},
 	{ 'F',	"freeze-loops", "INTEGER", "Max loops in spa_freeze()",
 	    DEFAULT_MAX_LOOPS, NULL},
 	{ 'B',	"alt-ztest", "PATH", "Alternate ztest path",
 	    NO_DEFAULT, NULL},
 	{ 'C',	"vdev-class-state", "on|off|random", "vdev class state",
 	    NO_DEFAULT, "random"},
 	{ 'X', "raidz-expansion", NULL,
 	    "Perform a dedicated raidz expansion test",
 	    NO_DEFAULT, NULL},
 	{ 'o',	"option", "\"OPTION=INTEGER\"",
 	    "Set global variable to an unsigned 32-bit integer value",
 	    NO_DEFAULT, NULL},
 	{ 'G',	"dump-debug-msg", NULL,
 	    "Dump zfs_dbgmsg buffer before exiting due to an error",
 	    NO_DEFAULT, NULL},
 	{ 'V',	"verbose", NULL,
 	    "Verbose (use multiple times for ever more verbosity)",
 	    NO_DEFAULT, NULL},
 	{ 'h',	"help",	NULL, "Show this help",
 	    NO_DEFAULT, NULL},
 	{0, 0, 0, 0, 0, 0}
 };
 
 static struct option *long_opts = NULL;
 static char *short_opts = NULL;
 
 static void
 init_options(void)
 {
 	ASSERT3P(long_opts, ==, NULL);
 	ASSERT3P(short_opts, ==, NULL);
 
 	int count = sizeof (option_table) / sizeof (option_table[0]);
 	long_opts = umem_alloc(sizeof (struct option) * count, UMEM_NOFAIL);
 
 	short_opts = umem_alloc(sizeof (char) * 2 * count, UMEM_NOFAIL);
 	int short_opt_index = 0;
 
 	for (int i = 0; i < count; i++) {
 		long_opts[i].val = option_table[i].short_opt;
 		long_opts[i].name = option_table[i].long_opt;
 		long_opts[i].has_arg = option_table[i].long_opt_param != NULL
 		    ? required_argument : no_argument;
 		long_opts[i].flag = NULL;
 		short_opts[short_opt_index++] = option_table[i].short_opt;
 		if (option_table[i].long_opt_param != NULL) {
 			short_opts[short_opt_index++] = ':';
 		}
 	}
 }
 
 static void
 fini_options(void)
 {
 	int count = sizeof (option_table) / sizeof (option_table[0]);
 
 	umem_free(long_opts, sizeof (struct option) * count);
 	umem_free(short_opts, sizeof (char) * 2 * count);
 
 	long_opts = NULL;
 	short_opts = NULL;
 }
 
 static __attribute__((noreturn)) void
 usage(boolean_t requested)
 {
 	char option[80];
 	FILE *fp = requested ? stdout : stderr;
 
 	(void) fprintf(fp, "Usage: %s [OPTIONS...]\n", DEFAULT_POOL);
 	for (int i = 0; option_table[i].short_opt != 0; i++) {
 		if (option_table[i].long_opt_param != NULL) {
 			(void) sprintf(option, "  -%c --%s=%s",
 			    option_table[i].short_opt,
 			    option_table[i].long_opt,
 			    option_table[i].long_opt_param);
 		} else {
 			(void) sprintf(option, "  -%c --%s",
 			    option_table[i].short_opt,
 			    option_table[i].long_opt);
 		}
 		(void) fprintf(fp, "  %-43s%s", option,
 		    option_table[i].comment);
 
 		if (option_table[i].long_opt_param != NULL) {
 			if (option_table[i].default_str != NULL) {
 				(void) fprintf(fp, " (default: %s)",
 				    option_table[i].default_str);
 			} else if (option_table[i].default_int != NO_DEFAULT) {
 				(void) fprintf(fp, " (default: %u)",
 				    option_table[i].default_int);
 			}
 		}
 		(void) fprintf(fp, "\n");
 	}
 	exit(requested ? 0 : 1);
 }
 
 static uint64_t
 ztest_random(uint64_t range)
 {
 	uint64_t r;
 
 	ASSERT3S(ztest_fd_rand, >=, 0);
 
 	if (range == 0)
 		return (0);
 
 	if (read(ztest_fd_rand, &r, sizeof (r)) != sizeof (r))
 		fatal(B_TRUE, "short read from /dev/urandom");
 
 	return (r % range);
 }
 
 static void
 ztest_parse_name_value(const char *input, ztest_shared_opts_t *zo)
 {
 	char name[32];
 	char *value;
 	int state = ZTEST_VDEV_CLASS_RND;
 
 	(void) strlcpy(name, input, sizeof (name));
 
 	value = strchr(name, '=');
 	if (value == NULL) {
 		(void) fprintf(stderr, "missing value in property=value "
 		    "'-C' argument (%s)\n", input);
 		usage(B_FALSE);
 	}
 	*(value) = '\0';
 	value++;
 
 	if (strcmp(value, "on") == 0) {
 		state = ZTEST_VDEV_CLASS_ON;
 	} else if (strcmp(value, "off") == 0) {
 		state = ZTEST_VDEV_CLASS_OFF;
 	} else if (strcmp(value, "random") == 0) {
 		state = ZTEST_VDEV_CLASS_RND;
 	} else {
 		(void) fprintf(stderr, "invalid property value '%s'\n", value);
 		usage(B_FALSE);
 	}
 
 	if (strcmp(name, "special") == 0) {
 		zo->zo_special_vdevs = state;
 	} else {
 		(void) fprintf(stderr, "invalid property name '%s'\n", name);
 		usage(B_FALSE);
 	}
 	if (zo->zo_verbose >= 3)
 		(void) printf("%s vdev state is '%s'\n", name, value);
 }
 
 static void
 process_options(int argc, char **argv)
 {
 	char *path;
 	ztest_shared_opts_t *zo = &ztest_opts;
 
 	int opt;
 	uint64_t value;
 	const char *raid_kind = "random";
 
 	memcpy(zo, &ztest_opts_defaults, sizeof (*zo));
 
 	init_options();
 
 	while ((opt = getopt_long(argc, argv, short_opts, long_opts,
 	    NULL)) != EOF) {
 		value = 0;
 		switch (opt) {
 		case 'v':
 		case 's':
 		case 'a':
 		case 'm':
 		case 'r':
 		case 'R':
 		case 'D':
 		case 'S':
 		case 'd':
 		case 't':
 		case 'g':
 		case 'i':
 		case 'k':
 		case 'T':
 		case 'P':
 		case 'F':
 			value = nicenumtoull(optarg);
 		}
 		switch (opt) {
 		case 'v':
 			zo->zo_vdevs = value;
 			break;
 		case 's':
 			zo->zo_vdev_size = MAX(SPA_MINDEVSIZE, value);
 			break;
 		case 'a':
 			zo->zo_ashift = value;
 			break;
 		case 'm':
 			zo->zo_mirrors = value;
 			break;
 		case 'r':
 			zo->zo_raid_children = MAX(1, value);
 			break;
 		case 'R':
 			zo->zo_raid_parity = MIN(MAX(value, 1), 3);
 			break;
 		case 'K':
 			raid_kind = optarg;
 			break;
 		case 'D':
 			zo->zo_draid_data = MAX(1, value);
 			break;
 		case 'S':
 			zo->zo_draid_spares = MAX(1, value);
 			break;
 		case 'd':
 			zo->zo_datasets = MAX(1, value);
 			break;
 		case 't':
 			zo->zo_threads = MAX(1, value);
 			break;
 		case 'g':
 			zo->zo_metaslab_force_ganging =
 			    MAX(SPA_MINBLOCKSIZE << 1, value);
 			break;
 		case 'i':
 			zo->zo_init = value;
 			break;
 		case 'k':
 			zo->zo_killrate = value;
 			break;
 		case 'p':
 			(void) strlcpy(zo->zo_pool, optarg,
 			    sizeof (zo->zo_pool));
 			break;
 		case 'f':
 			path = realpath(optarg, NULL);
 			if (path == NULL) {
 				(void) fprintf(stderr, "error: %s: %s\n",
 				    optarg, strerror(errno));
 				usage(B_FALSE);
 			} else {
 				(void) strlcpy(zo->zo_dir, path,
 				    sizeof (zo->zo_dir));
 				free(path);
 			}
 			break;
 		case 'M':
 			zo->zo_mmp_test = 1;
 			break;
 		case 'V':
 			zo->zo_verbose++;
 			break;
 		case 'X':
 			zo->zo_raidz_expand_test = RAIDZ_EXPAND_REQUESTED;
 			break;
 		case 'E':
 			zo->zo_init = 0;
 			break;
 		case 'T':
 			zo->zo_time = value;
 			break;
 		case 'P':
 			zo->zo_passtime = MAX(1, value);
 			break;
 		case 'F':
 			zo->zo_maxloops = MAX(1, value);
 			break;
 		case 'B':
 			(void) strlcpy(zo->zo_alt_ztest, optarg,
 			    sizeof (zo->zo_alt_ztest));
 			break;
 		case 'C':
 			ztest_parse_name_value(optarg, zo);
 			break;
 		case 'o':
 			if (zo->zo_gvars_count >= ZO_GVARS_MAX_COUNT) {
 				(void) fprintf(stderr,
 				    "max global var count (%zu) exceeded\n",
 				    ZO_GVARS_MAX_COUNT);
 				usage(B_FALSE);
 			}
 			char *v = zo->zo_gvars[zo->zo_gvars_count];
 			if (strlcpy(v, optarg, ZO_GVARS_MAX_ARGLEN) >=
 			    ZO_GVARS_MAX_ARGLEN) {
 				(void) fprintf(stderr,
 				    "global var option '%s' is too long\n",
 				    optarg);
 				usage(B_FALSE);
 			}
 			zo->zo_gvars_count++;
 			break;
 		case 'G':
 			zo->zo_dump_dbgmsg = 1;
 			break;
 		case 'h':
 			usage(B_TRUE);
 			break;
 		case '?':
 		default:
 			usage(B_FALSE);
 			break;
 		}
 	}
 
 	fini_options();
 
 	/* Force compatible options for raidz expansion run */
 	if (zo->zo_raidz_expand_test == RAIDZ_EXPAND_REQUESTED) {
 		zo->zo_mmp_test = 0;
 		zo->zo_mirrors = 0;
 		zo->zo_vdevs = 1;
 		zo->zo_vdev_size = DEFAULT_VDEV_SIZE * 2;
 		zo->zo_raid_do_expand = B_FALSE;
 		raid_kind = "raidz";
 	}
 
 	if (strcmp(raid_kind, "random") == 0) {
 		switch (ztest_random(3)) {
 		case 0:
 			raid_kind = "raidz";
 			break;
 		case 1:
 			raid_kind = "eraidz";
 			break;
 		case 2:
 			raid_kind = "draid";
 			break;
 		}
 
 		if (ztest_opts.zo_verbose >= 3)
 			(void) printf("choosing RAID type '%s'\n", raid_kind);
 	}
 
 	if (strcmp(raid_kind, "draid") == 0) {
 		uint64_t min_devsize;
 
 		/* With fewer disk use 256M, otherwise 128M is OK */
 		min_devsize = (ztest_opts.zo_raid_children < 16) ?
 		    (256ULL << 20) : (128ULL << 20);
 
 		/* No top-level mirrors with dRAID for now */
 		zo->zo_mirrors = 0;
 
 		/* Use more appropriate defaults for dRAID */
 		if (zo->zo_vdevs == ztest_opts_defaults.zo_vdevs)
 			zo->zo_vdevs = 1;
 		if (zo->zo_raid_children ==
 		    ztest_opts_defaults.zo_raid_children)
 			zo->zo_raid_children = 16;
 		if (zo->zo_ashift < 12)
 			zo->zo_ashift = 12;
 		if (zo->zo_vdev_size < min_devsize)
 			zo->zo_vdev_size = min_devsize;
 
 		if (zo->zo_draid_data + zo->zo_raid_parity >
 		    zo->zo_raid_children - zo->zo_draid_spares) {
 			(void) fprintf(stderr, "error: too few draid "
 			    "children (%d) for stripe width (%d)\n",
 			    zo->zo_raid_children,
 			    zo->zo_draid_data + zo->zo_raid_parity);
 			usage(B_FALSE);
 		}
 
 		(void) strlcpy(zo->zo_raid_type, VDEV_TYPE_DRAID,
 		    sizeof (zo->zo_raid_type));
 
 	} else if (strcmp(raid_kind, "eraidz") == 0) {
 		/* using eraidz (expandable raidz) */
 		zo->zo_raid_do_expand = B_TRUE;
 
 		/* tests expect top-level to be raidz */
 		zo->zo_mirrors = 0;
 		zo->zo_vdevs = 1;
 
 		/* Make sure parity is less than data columns */
 		zo->zo_raid_parity = MIN(zo->zo_raid_parity,
 		    zo->zo_raid_children - 1);
 
 	} else /* using raidz */ {
 		ASSERT0(strcmp(raid_kind, "raidz"));
 
 		zo->zo_raid_parity = MIN(zo->zo_raid_parity,
 		    zo->zo_raid_children - 1);
 	}
 
 	zo->zo_vdevtime =
 	    (zo->zo_vdevs > 0 ? zo->zo_time * NANOSEC / zo->zo_vdevs :
 	    UINT64_MAX >> 2);
 
 	if (*zo->zo_alt_ztest) {
 		const char *invalid_what = "ztest";
 		char *val = zo->zo_alt_ztest;
 		if (0 != access(val, X_OK) ||
 		    (strrchr(val, '/') == NULL && (errno == EINVAL)))
 			goto invalid;
 
 		int dirlen = strrchr(val, '/') - val;
 		strlcpy(zo->zo_alt_libpath, val,
 		    MIN(sizeof (zo->zo_alt_libpath), dirlen + 1));
 		invalid_what = "library path", val = zo->zo_alt_libpath;
 		if (strrchr(val, '/') == NULL && (errno == EINVAL))
 			goto invalid;
 		*strrchr(val, '/') = '\0';
 		strlcat(val, "/lib", sizeof (zo->zo_alt_libpath));
 
 		if (0 != access(zo->zo_alt_libpath, X_OK))
 			goto invalid;
 		return;
 
 invalid:
 		ztest_dump_core = B_FALSE;
 		fatal(B_TRUE, "invalid alternate %s %s", invalid_what, val);
 	}
 }
 
 static void
 ztest_kill(ztest_shared_t *zs)
 {
 	zs->zs_alloc = metaslab_class_get_alloc(spa_normal_class(ztest_spa));
 	zs->zs_space = metaslab_class_get_space(spa_normal_class(ztest_spa));
 
 	/*
 	 * Before we kill ourselves, make sure that the config is updated.
 	 * See comment above spa_write_cachefile().
 	 */
 	if (raidz_expand_pause_point != RAIDZ_EXPAND_PAUSE_NONE) {
 		if (mutex_tryenter(&spa_namespace_lock)) {
 			spa_write_cachefile(ztest_spa, B_FALSE, B_FALSE,
 			    B_FALSE);
 			mutex_exit(&spa_namespace_lock);
 
 			ztest_scratch_state->zs_raidz_scratch_verify_pause =
 			    raidz_expand_pause_point;
 		} else {
 			/*
 			 * Do not verify scratch object in case if
 			 * spa_namespace_lock cannot be acquired,
 			 * it can cause deadlock in spa_config_update().
 			 */
 			raidz_expand_pause_point = RAIDZ_EXPAND_PAUSE_NONE;
 
 			return;
 		}
 	} else {
 		mutex_enter(&spa_namespace_lock);
 		spa_write_cachefile(ztest_spa, B_FALSE, B_FALSE, B_FALSE);
 		mutex_exit(&spa_namespace_lock);
 	}
 
 	(void) raise(SIGKILL);
 }
 
 static void
 ztest_record_enospc(const char *s)
 {
 	(void) s;
 	ztest_shared->zs_enospc_count++;
 }
 
 static uint64_t
 ztest_get_ashift(void)
 {
 	if (ztest_opts.zo_ashift == 0)
 		return (SPA_MINBLOCKSHIFT + ztest_random(5));
 	return (ztest_opts.zo_ashift);
 }
 
 static boolean_t
 ztest_is_draid_spare(const char *name)
 {
 	uint64_t spare_id = 0, parity = 0, vdev_id = 0;
 
 	if (sscanf(name, VDEV_TYPE_DRAID "%"PRIu64"-%"PRIu64"-%"PRIu64"",
 	    &parity, &vdev_id, &spare_id) == 3) {
 		return (B_TRUE);
 	}
 
 	return (B_FALSE);
 }
 
 static nvlist_t *
 make_vdev_file(const char *path, const char *aux, const char *pool,
     size_t size, uint64_t ashift)
 {
 	char *pathbuf = NULL;
 	uint64_t vdev;
 	nvlist_t *file;
 	boolean_t draid_spare = B_FALSE;
 
 
 	if (ashift == 0)
 		ashift = ztest_get_ashift();
 
 	if (path == NULL) {
 		pathbuf = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
 		path = pathbuf;
 
 		if (aux != NULL) {
 			vdev = ztest_shared->zs_vdev_aux;
 			(void) snprintf(pathbuf, MAXPATHLEN,
 			    ztest_aux_template, ztest_opts.zo_dir,
 			    pool == NULL ? ztest_opts.zo_pool : pool,
 			    aux, vdev);
 		} else {
 			vdev = ztest_shared->zs_vdev_next_leaf++;
 			(void) snprintf(pathbuf, MAXPATHLEN,
 			    ztest_dev_template, ztest_opts.zo_dir,
 			    pool == NULL ? ztest_opts.zo_pool : pool, vdev);
 		}
 	} else {
 		draid_spare = ztest_is_draid_spare(path);
 	}
 
 	if (size != 0 && !draid_spare) {
 		int fd = open(path, O_RDWR | O_CREAT | O_TRUNC, 0666);
 		if (fd == -1)
 			fatal(B_TRUE, "can't open %s", path);
 		if (ftruncate(fd, size) != 0)
 			fatal(B_TRUE, "can't ftruncate %s", path);
 		(void) close(fd);
 	}
 
 	file = fnvlist_alloc();
 	fnvlist_add_string(file, ZPOOL_CONFIG_TYPE,
 	    draid_spare ? VDEV_TYPE_DRAID_SPARE : VDEV_TYPE_FILE);
 	fnvlist_add_string(file, ZPOOL_CONFIG_PATH, path);
 	fnvlist_add_uint64(file, ZPOOL_CONFIG_ASHIFT, ashift);
 	umem_free(pathbuf, MAXPATHLEN);
 
 	return (file);
 }
 
 static nvlist_t *
 make_vdev_raid(const char *path, const char *aux, const char *pool, size_t size,
     uint64_t ashift, int r)
 {
 	nvlist_t *raid, **child;
 	int c;
 
 	if (r < 2)
 		return (make_vdev_file(path, aux, pool, size, ashift));
 	child = umem_alloc(r * sizeof (nvlist_t *), UMEM_NOFAIL);
 
 	for (c = 0; c < r; c++)
 		child[c] = make_vdev_file(path, aux, pool, size, ashift);
 
 	raid = fnvlist_alloc();
 	fnvlist_add_string(raid, ZPOOL_CONFIG_TYPE,
 	    ztest_opts.zo_raid_type);
 	fnvlist_add_uint64(raid, ZPOOL_CONFIG_NPARITY,
 	    ztest_opts.zo_raid_parity);
 	fnvlist_add_nvlist_array(raid, ZPOOL_CONFIG_CHILDREN,
 	    (const nvlist_t **)child, r);
 
 	if (strcmp(ztest_opts.zo_raid_type, VDEV_TYPE_DRAID) == 0) {
 		uint64_t ndata = ztest_opts.zo_draid_data;
 		uint64_t nparity = ztest_opts.zo_raid_parity;
 		uint64_t nspares = ztest_opts.zo_draid_spares;
 		uint64_t children = ztest_opts.zo_raid_children;
 		uint64_t ngroups = 1;
 
 		/*
 		 * Calculate the minimum number of groups required to fill a
 		 * slice. This is the LCM of the stripe width (data + parity)
 		 * and the number of data drives (children - spares).
 		 */
 		while (ngroups * (ndata + nparity) % (children - nspares) != 0)
 			ngroups++;
 
 		/* Store the basic dRAID configuration. */
 		fnvlist_add_uint64(raid, ZPOOL_CONFIG_DRAID_NDATA, ndata);
 		fnvlist_add_uint64(raid, ZPOOL_CONFIG_DRAID_NSPARES, nspares);
 		fnvlist_add_uint64(raid, ZPOOL_CONFIG_DRAID_NGROUPS, ngroups);
 	}
 
 	for (c = 0; c < r; c++)
 		fnvlist_free(child[c]);
 
 	umem_free(child, r * sizeof (nvlist_t *));
 
 	return (raid);
 }
 
 static nvlist_t *
 make_vdev_mirror(const char *path, const char *aux, const char *pool,
     size_t size, uint64_t ashift, int r, int m)
 {
 	nvlist_t *mirror, **child;
 	int c;
 
 	if (m < 1)
 		return (make_vdev_raid(path, aux, pool, size, ashift, r));
 
 	child = umem_alloc(m * sizeof (nvlist_t *), UMEM_NOFAIL);
 
 	for (c = 0; c < m; c++)
 		child[c] = make_vdev_raid(path, aux, pool, size, ashift, r);
 
 	mirror = fnvlist_alloc();
 	fnvlist_add_string(mirror, ZPOOL_CONFIG_TYPE, VDEV_TYPE_MIRROR);
 	fnvlist_add_nvlist_array(mirror, ZPOOL_CONFIG_CHILDREN,
 	    (const nvlist_t **)child, m);
 
 	for (c = 0; c < m; c++)
 		fnvlist_free(child[c]);
 
 	umem_free(child, m * sizeof (nvlist_t *));
 
 	return (mirror);
 }
 
 static nvlist_t *
 make_vdev_root(const char *path, const char *aux, const char *pool, size_t size,
     uint64_t ashift, const char *class, int r, int m, int t)
 {
 	nvlist_t *root, **child;
 	int c;
 	boolean_t log;
 
 	ASSERT3S(t, >, 0);
 
 	log = (class != NULL && strcmp(class, "log") == 0);
 
 	child = umem_alloc(t * sizeof (nvlist_t *), UMEM_NOFAIL);
 
 	for (c = 0; c < t; c++) {
 		child[c] = make_vdev_mirror(path, aux, pool, size, ashift,
 		    r, m);
 		fnvlist_add_uint64(child[c], ZPOOL_CONFIG_IS_LOG, log);
 
 		if (class != NULL && class[0] != '\0') {
 			ASSERT(m > 1 || log);   /* expecting a mirror */
 			fnvlist_add_string(child[c],
 			    ZPOOL_CONFIG_ALLOCATION_BIAS, class);
 		}
 	}
 
 	root = fnvlist_alloc();
 	fnvlist_add_string(root, ZPOOL_CONFIG_TYPE, VDEV_TYPE_ROOT);
 	fnvlist_add_nvlist_array(root, aux ? aux : ZPOOL_CONFIG_CHILDREN,
 	    (const nvlist_t **)child, t);
 
 	for (c = 0; c < t; c++)
 		fnvlist_free(child[c]);
 
 	umem_free(child, t * sizeof (nvlist_t *));
 
 	return (root);
 }
 
 /*
  * Find a random spa version. Returns back a random spa version in the
  * range [initial_version, SPA_VERSION_FEATURES].
  */
 static uint64_t
 ztest_random_spa_version(uint64_t initial_version)
 {
 	uint64_t version = initial_version;
 
 	if (version <= SPA_VERSION_BEFORE_FEATURES) {
 		version = version +
 		    ztest_random(SPA_VERSION_BEFORE_FEATURES - version + 1);
 	}
 
 	if (version > SPA_VERSION_BEFORE_FEATURES)
 		version = SPA_VERSION_FEATURES;
 
 	ASSERT(SPA_VERSION_IS_SUPPORTED(version));
 	return (version);
 }
 
 static int
 ztest_random_blocksize(void)
 {
 	ASSERT3U(ztest_spa->spa_max_ashift, !=, 0);
 
 	/*
 	 * Choose a block size >= the ashift.
 	 * If the SPA supports new MAXBLOCKSIZE, test up to 1MB blocks.
 	 */
 	int maxbs = SPA_OLD_MAXBLOCKSHIFT;
 	if (spa_maxblocksize(ztest_spa) == SPA_MAXBLOCKSIZE)
 		maxbs = 20;
 	uint64_t block_shift =
 	    ztest_random(maxbs - ztest_spa->spa_max_ashift + 1);
 	return (1 << (SPA_MINBLOCKSHIFT + block_shift));
 }
 
 static int
 ztest_random_dnodesize(void)
 {
 	int slots;
 	int max_slots = spa_maxdnodesize(ztest_spa) >> DNODE_SHIFT;
 
 	if (max_slots == DNODE_MIN_SLOTS)
 		return (DNODE_MIN_SIZE);
 
 	/*
 	 * Weight the random distribution more heavily toward smaller
 	 * dnode sizes since that is more likely to reflect real-world
 	 * usage.
 	 */
 	ASSERT3U(max_slots, >, 4);
 	switch (ztest_random(10)) {
 	case 0:
 		slots = 5 + ztest_random(max_slots - 4);
 		break;
 	case 1 ... 4:
 		slots = 2 + ztest_random(3);
 		break;
 	default:
 		slots = 1;
 		break;
 	}
 
 	return (slots << DNODE_SHIFT);
 }
 
 static int
 ztest_random_ibshift(void)
 {
 	return (DN_MIN_INDBLKSHIFT +
 	    ztest_random(DN_MAX_INDBLKSHIFT - DN_MIN_INDBLKSHIFT + 1));
 }
 
 static uint64_t
 ztest_random_vdev_top(spa_t *spa, boolean_t log_ok)
 {
 	uint64_t top;
 	vdev_t *rvd = spa->spa_root_vdev;
 	vdev_t *tvd;
 
 	ASSERT3U(spa_config_held(spa, SCL_ALL, RW_READER), !=, 0);
 
 	do {
 		top = ztest_random(rvd->vdev_children);
 		tvd = rvd->vdev_child[top];
 	} while (!vdev_is_concrete(tvd) || (tvd->vdev_islog && !log_ok) ||
 	    tvd->vdev_mg == NULL || tvd->vdev_mg->mg_class == NULL);
 
 	return (top);
 }
 
 static uint64_t
 ztest_random_dsl_prop(zfs_prop_t prop)
 {
 	uint64_t value;
 
 	do {
 		value = zfs_prop_random_value(prop, ztest_random(-1ULL));
 	} while (prop == ZFS_PROP_CHECKSUM && value == ZIO_CHECKSUM_OFF);
 
 	return (value);
 }
 
 static int
 ztest_dsl_prop_set_uint64(char *osname, zfs_prop_t prop, uint64_t value,
     boolean_t inherit)
 {
 	const char *propname = zfs_prop_to_name(prop);
 	const char *valname;
 	char *setpoint;
 	uint64_t curval;
 	int error;
 
 	error = dsl_prop_set_int(osname, propname,
 	    (inherit ? ZPROP_SRC_NONE : ZPROP_SRC_LOCAL), value);
 
 	if (error == ENOSPC) {
 		ztest_record_enospc(FTAG);
 		return (error);
 	}
 	ASSERT0(error);
 
 	setpoint = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
 	VERIFY0(dsl_prop_get_integer(osname, propname, &curval, setpoint));
 
 	if (ztest_opts.zo_verbose >= 6) {
 		int err;
 
 		err = zfs_prop_index_to_string(prop, curval, &valname);
 		if (err)
 			(void) printf("%s %s = %llu at '%s'\n", osname,
 			    propname, (unsigned long long)curval, setpoint);
 		else
 			(void) printf("%s %s = %s at '%s'\n",
 			    osname, propname, valname, setpoint);
 	}
 	umem_free(setpoint, MAXPATHLEN);
 
 	return (error);
 }
 
 static int
 ztest_spa_prop_set_uint64(zpool_prop_t prop, uint64_t value)
 {
 	spa_t *spa = ztest_spa;
 	nvlist_t *props = NULL;
 	int error;
 
 	props = fnvlist_alloc();
 	fnvlist_add_uint64(props, zpool_prop_to_name(prop), value);
 
 	error = spa_prop_set(spa, props);
 
 	fnvlist_free(props);
 
 	if (error == ENOSPC) {
 		ztest_record_enospc(FTAG);
 		return (error);
 	}
 	ASSERT0(error);
 
 	return (error);
 }
 
 static int
 ztest_dmu_objset_own(const char *name, dmu_objset_type_t type,
     boolean_t readonly, boolean_t decrypt, const void *tag, objset_t **osp)
 {
 	int err;
 	char *cp = NULL;
 	char ddname[ZFS_MAX_DATASET_NAME_LEN];
 
 	strlcpy(ddname, name, sizeof (ddname));
 	cp = strchr(ddname, '@');
 	if (cp != NULL)
 		*cp = '\0';
 
 	err = dmu_objset_own(name, type, readonly, decrypt, tag, osp);
 	while (decrypt && err == EACCES) {
 		dsl_crypto_params_t *dcp;
 		nvlist_t *crypto_args = fnvlist_alloc();
 
 		fnvlist_add_uint8_array(crypto_args, "wkeydata",
 		    (uint8_t *)ztest_wkeydata, WRAPPING_KEY_LEN);
 		VERIFY0(dsl_crypto_params_create_nvlist(DCP_CMD_NONE, NULL,
 		    crypto_args, &dcp));
 		err = spa_keystore_load_wkey(ddname, dcp, B_FALSE);
 		/*
 		 * Note: if there was an error loading, the wkey was not
 		 * consumed, and needs to be freed.
 		 */
 		dsl_crypto_params_free(dcp, (err != 0));
 		fnvlist_free(crypto_args);
 
 		if (err == EINVAL) {
 			/*
 			 * We couldn't load a key for this dataset so try
 			 * the parent. This loop will eventually hit the
 			 * encryption root since ztest only makes clones
 			 * as children of their origin datasets.
 			 */
 			cp = strrchr(ddname, '/');
 			if (cp == NULL)
 				return (err);
 
 			*cp = '\0';
 			err = EACCES;
 			continue;
 		} else if (err != 0) {
 			break;
 		}
 
 		err = dmu_objset_own(name, type, readonly, decrypt, tag, osp);
 		break;
 	}
 
 	return (err);
 }
 
 static void
 ztest_rll_init(rll_t *rll)
 {
 	rll->rll_writer = NULL;
 	rll->rll_readers = 0;
 	mutex_init(&rll->rll_lock, NULL, MUTEX_DEFAULT, NULL);
 	cv_init(&rll->rll_cv, NULL, CV_DEFAULT, NULL);
 }
 
 static void
 ztest_rll_destroy(rll_t *rll)
 {
 	ASSERT3P(rll->rll_writer, ==, NULL);
 	ASSERT0(rll->rll_readers);
 	mutex_destroy(&rll->rll_lock);
 	cv_destroy(&rll->rll_cv);
 }
 
 static void
 ztest_rll_lock(rll_t *rll, rl_type_t type)
 {
 	mutex_enter(&rll->rll_lock);
 
 	if (type == ZTRL_READER) {
 		while (rll->rll_writer != NULL)
 			(void) cv_wait(&rll->rll_cv, &rll->rll_lock);
 		rll->rll_readers++;
 	} else {
 		while (rll->rll_writer != NULL || rll->rll_readers)
 			(void) cv_wait(&rll->rll_cv, &rll->rll_lock);
 		rll->rll_writer = curthread;
 	}
 
 	mutex_exit(&rll->rll_lock);
 }
 
 static void
 ztest_rll_unlock(rll_t *rll)
 {
 	mutex_enter(&rll->rll_lock);
 
 	if (rll->rll_writer) {
 		ASSERT0(rll->rll_readers);
 		rll->rll_writer = NULL;
 	} else {
 		ASSERT3S(rll->rll_readers, >, 0);
 		ASSERT3P(rll->rll_writer, ==, NULL);
 		rll->rll_readers--;
 	}
 
 	if (rll->rll_writer == NULL && rll->rll_readers == 0)
 		cv_broadcast(&rll->rll_cv);
 
 	mutex_exit(&rll->rll_lock);
 }
 
 static void
 ztest_object_lock(ztest_ds_t *zd, uint64_t object, rl_type_t type)
 {
 	rll_t *rll = &zd->zd_object_lock[object & (ZTEST_OBJECT_LOCKS - 1)];
 
 	ztest_rll_lock(rll, type);
 }
 
 static void
 ztest_object_unlock(ztest_ds_t *zd, uint64_t object)
 {
 	rll_t *rll = &zd->zd_object_lock[object & (ZTEST_OBJECT_LOCKS - 1)];
 
 	ztest_rll_unlock(rll);
 }
 
 static rl_t *
 ztest_range_lock(ztest_ds_t *zd, uint64_t object, uint64_t offset,
     uint64_t size, rl_type_t type)
 {
 	uint64_t hash = object ^ (offset % (ZTEST_RANGE_LOCKS + 1));
 	rll_t *rll = &zd->zd_range_lock[hash & (ZTEST_RANGE_LOCKS - 1)];
 	rl_t *rl;
 
 	rl = umem_alloc(sizeof (*rl), UMEM_NOFAIL);
 	rl->rl_object = object;
 	rl->rl_offset = offset;
 	rl->rl_size = size;
 	rl->rl_lock = rll;
 
 	ztest_rll_lock(rll, type);
 
 	return (rl);
 }
 
 static void
 ztest_range_unlock(rl_t *rl)
 {
 	rll_t *rll = rl->rl_lock;
 
 	ztest_rll_unlock(rll);
 
 	umem_free(rl, sizeof (*rl));
 }
 
 static void
 ztest_zd_init(ztest_ds_t *zd, ztest_shared_ds_t *szd, objset_t *os)
 {
 	zd->zd_os = os;
 	zd->zd_zilog = dmu_objset_zil(os);
 	zd->zd_shared = szd;
 	dmu_objset_name(os, zd->zd_name);
 	int l;
 
 	if (zd->zd_shared != NULL)
 		zd->zd_shared->zd_seq = 0;
 
 	VERIFY0(pthread_rwlock_init(&zd->zd_zilog_lock, NULL));
 	mutex_init(&zd->zd_dirobj_lock, NULL, MUTEX_DEFAULT, NULL);
 
 	for (l = 0; l < ZTEST_OBJECT_LOCKS; l++)
 		ztest_rll_init(&zd->zd_object_lock[l]);
 
 	for (l = 0; l < ZTEST_RANGE_LOCKS; l++)
 		ztest_rll_init(&zd->zd_range_lock[l]);
 }
 
 static void
 ztest_zd_fini(ztest_ds_t *zd)
 {
 	int l;
 
 	mutex_destroy(&zd->zd_dirobj_lock);
 	(void) pthread_rwlock_destroy(&zd->zd_zilog_lock);
 
 	for (l = 0; l < ZTEST_OBJECT_LOCKS; l++)
 		ztest_rll_destroy(&zd->zd_object_lock[l]);
 
 	for (l = 0; l < ZTEST_RANGE_LOCKS; l++)
 		ztest_rll_destroy(&zd->zd_range_lock[l]);
 }
 
 #define	TXG_MIGHTWAIT	(ztest_random(10) == 0 ? TXG_NOWAIT : TXG_WAIT)
 
 static uint64_t
 ztest_tx_assign(dmu_tx_t *tx, uint64_t txg_how, const char *tag)
 {
 	uint64_t txg;
 	int error;
 
 	/*
 	 * Attempt to assign tx to some transaction group.
 	 */
 	error = dmu_tx_assign(tx, txg_how);
 	if (error) {
 		if (error == ERESTART) {
 			ASSERT3U(txg_how, ==, TXG_NOWAIT);
 			dmu_tx_wait(tx);
 		} else {
 			ASSERT3U(error, ==, ENOSPC);
 			ztest_record_enospc(tag);
 		}
 		dmu_tx_abort(tx);
 		return (0);
 	}
 	txg = dmu_tx_get_txg(tx);
 	ASSERT3U(txg, !=, 0);
 	return (txg);
 }
 
 static void
 ztest_bt_generate(ztest_block_tag_t *bt, objset_t *os, uint64_t object,
     uint64_t dnodesize, uint64_t offset, uint64_t gen, uint64_t txg,
     uint64_t crtxg)
 {
 	bt->bt_magic = BT_MAGIC;
 	bt->bt_objset = dmu_objset_id(os);
 	bt->bt_object = object;
 	bt->bt_dnodesize = dnodesize;
 	bt->bt_offset = offset;
 	bt->bt_gen = gen;
 	bt->bt_txg = txg;
 	bt->bt_crtxg = crtxg;
 }
 
 static void
 ztest_bt_verify(ztest_block_tag_t *bt, objset_t *os, uint64_t object,
     uint64_t dnodesize, uint64_t offset, uint64_t gen, uint64_t txg,
     uint64_t crtxg)
 {
 	ASSERT3U(bt->bt_magic, ==, BT_MAGIC);
 	ASSERT3U(bt->bt_objset, ==, dmu_objset_id(os));
 	ASSERT3U(bt->bt_object, ==, object);
 	ASSERT3U(bt->bt_dnodesize, ==, dnodesize);
 	ASSERT3U(bt->bt_offset, ==, offset);
 	ASSERT3U(bt->bt_gen, <=, gen);
 	ASSERT3U(bt->bt_txg, <=, txg);
 	ASSERT3U(bt->bt_crtxg, ==, crtxg);
 }
 
 static ztest_block_tag_t *
 ztest_bt_bonus(dmu_buf_t *db)
 {
 	dmu_object_info_t doi;
 	ztest_block_tag_t *bt;
 
 	dmu_object_info_from_db(db, &doi);
 	ASSERT3U(doi.doi_bonus_size, <=, db->db_size);
 	ASSERT3U(doi.doi_bonus_size, >=, sizeof (*bt));
 	bt = (void *)((char *)db->db_data + doi.doi_bonus_size - sizeof (*bt));
 
 	return (bt);
 }
 
 /*
  * Generate a token to fill up unused bonus buffer space.  Try to make
  * it unique to the object, generation, and offset to verify that data
  * is not getting overwritten by data from other dnodes.
  */
 #define	ZTEST_BONUS_FILL_TOKEN(obj, ds, gen, offset) \
 	(((ds) << 48) | ((gen) << 32) | ((obj) << 8) | (offset))
 
 /*
  * Fill up the unused bonus buffer region before the block tag with a
  * verifiable pattern. Filling the whole bonus area with non-zero data
  * helps ensure that all dnode traversal code properly skips the
  * interior regions of large dnodes.
  */
 static void
 ztest_fill_unused_bonus(dmu_buf_t *db, void *end, uint64_t obj,
     objset_t *os, uint64_t gen)
 {
 	uint64_t *bonusp;
 
 	ASSERT(IS_P2ALIGNED((char *)end - (char *)db->db_data, 8));
 
 	for (bonusp = db->db_data; bonusp < (uint64_t *)end; bonusp++) {
 		uint64_t token = ZTEST_BONUS_FILL_TOKEN(obj, dmu_objset_id(os),
 		    gen, bonusp - (uint64_t *)db->db_data);
 		*bonusp = token;
 	}
 }
 
 /*
  * Verify that the unused area of a bonus buffer is filled with the
  * expected tokens.
  */
 static void
 ztest_verify_unused_bonus(dmu_buf_t *db, void *end, uint64_t obj,
     objset_t *os, uint64_t gen)
 {
 	uint64_t *bonusp;
 
 	for (bonusp = db->db_data; bonusp < (uint64_t *)end; bonusp++) {
 		uint64_t token = ZTEST_BONUS_FILL_TOKEN(obj, dmu_objset_id(os),
 		    gen, bonusp - (uint64_t *)db->db_data);
 		VERIFY3U(*bonusp, ==, token);
 	}
 }
 
 /*
  * ZIL logging ops
  */
 
 #define	lrz_type	lr_mode
 #define	lrz_blocksize	lr_uid
 #define	lrz_ibshift	lr_gid
 #define	lrz_bonustype	lr_rdev
 #define	lrz_dnodesize	lr_crtime[1]
 
 static void
 ztest_log_create(ztest_ds_t *zd, dmu_tx_t *tx, lr_create_t *lr)
 {
 	char *name = (char *)&lr->lr_data[0];		/* name follows lr */
 	size_t namesize = strlen(name) + 1;
 	itx_t *itx;
 
 	if (zil_replaying(zd->zd_zilog, tx))
 		return;
 
 	itx = zil_itx_create(TX_CREATE, sizeof (*lr) + namesize);
 	memcpy(&itx->itx_lr + 1, &lr->lr_create.lr_common + 1,
 	    sizeof (*lr) + namesize - sizeof (lr_t));
 
 	zil_itx_assign(zd->zd_zilog, itx, tx);
 }
 
 static void
 ztest_log_remove(ztest_ds_t *zd, dmu_tx_t *tx, lr_remove_t *lr, uint64_t object)
 {
 	char *name = (char *)&lr->lr_data[0];		/* name follows lr */
 	size_t namesize = strlen(name) + 1;
 	itx_t *itx;
 
 	if (zil_replaying(zd->zd_zilog, tx))
 		return;
 
 	itx = zil_itx_create(TX_REMOVE, sizeof (*lr) + namesize);
 	memcpy(&itx->itx_lr + 1, &lr->lr_common + 1,
 	    sizeof (*lr) + namesize - sizeof (lr_t));
 
 	itx->itx_oid = object;
 	zil_itx_assign(zd->zd_zilog, itx, tx);
 }
 
 static void
 ztest_log_write(ztest_ds_t *zd, dmu_tx_t *tx, lr_write_t *lr)
 {
 	itx_t *itx;
 	itx_wr_state_t write_state = ztest_random(WR_NUM_STATES);
 
 	if (zil_replaying(zd->zd_zilog, tx))
 		return;
 
 	if (lr->lr_length > zil_max_log_data(zd->zd_zilog, sizeof (lr_write_t)))
 		write_state = WR_INDIRECT;
 
 	itx = zil_itx_create(TX_WRITE,
 	    sizeof (*lr) + (write_state == WR_COPIED ? lr->lr_length : 0));
 
 	if (write_state == WR_COPIED &&
 	    dmu_read(zd->zd_os, lr->lr_foid, lr->lr_offset, lr->lr_length,
 	    ((lr_write_t *)&itx->itx_lr) + 1, DMU_READ_NO_PREFETCH) != 0) {
 		zil_itx_destroy(itx);
 		itx = zil_itx_create(TX_WRITE, sizeof (*lr));
 		write_state = WR_NEED_COPY;
 	}
 	itx->itx_private = zd;
 	itx->itx_wr_state = write_state;
 	itx->itx_sync = (ztest_random(8) == 0);
 
 	memcpy(&itx->itx_lr + 1, &lr->lr_common + 1,
 	    sizeof (*lr) - sizeof (lr_t));
 
 	zil_itx_assign(zd->zd_zilog, itx, tx);
 }
 
 static void
 ztest_log_truncate(ztest_ds_t *zd, dmu_tx_t *tx, lr_truncate_t *lr)
 {
 	itx_t *itx;
 
 	if (zil_replaying(zd->zd_zilog, tx))
 		return;
 
 	itx = zil_itx_create(TX_TRUNCATE, sizeof (*lr));
 	memcpy(&itx->itx_lr + 1, &lr->lr_common + 1,
 	    sizeof (*lr) - sizeof (lr_t));
 
 	itx->itx_sync = B_FALSE;
 	zil_itx_assign(zd->zd_zilog, itx, tx);
 }
 
 static void
 ztest_log_setattr(ztest_ds_t *zd, dmu_tx_t *tx, lr_setattr_t *lr)
 {
 	itx_t *itx;
 
 	if (zil_replaying(zd->zd_zilog, tx))
 		return;
 
 	itx = zil_itx_create(TX_SETATTR, sizeof (*lr));
 	memcpy(&itx->itx_lr + 1, &lr->lr_common + 1,
 	    sizeof (*lr) - sizeof (lr_t));
 
 	itx->itx_sync = B_FALSE;
 	zil_itx_assign(zd->zd_zilog, itx, tx);
 }
 
 /*
  * ZIL replay ops
  */
 static int
 ztest_replay_create(void *arg1, void *arg2, boolean_t byteswap)
 {
 	ztest_ds_t *zd = arg1;
 	lr_create_t *lrc = arg2;
 	_lr_create_t *lr = &lrc->lr_create;
 	char *name = (char *)&lrc->lr_data[0];		/* name follows lr */
 	objset_t *os = zd->zd_os;
 	ztest_block_tag_t *bbt;
 	dmu_buf_t *db;
 	dmu_tx_t *tx;
 	uint64_t txg;
 	int error = 0;
 	int bonuslen;
 
 	if (byteswap)
 		byteswap_uint64_array(lr, sizeof (*lr));
 
 	ASSERT3U(lr->lr_doid, ==, ZTEST_DIROBJ);
 	ASSERT3S(name[0], !=, '\0');
 
 	tx = dmu_tx_create(os);
 
 	dmu_tx_hold_zap(tx, lr->lr_doid, B_TRUE, name);
 
 	if (lr->lrz_type == DMU_OT_ZAP_OTHER) {
 		dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, B_TRUE, NULL);
 	} else {
 		dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT);
 	}
 
 	txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
 	if (txg == 0)
 		return (ENOSPC);
 
 	ASSERT3U(dmu_objset_zil(os)->zl_replay, ==, !!lr->lr_foid);
 	bonuslen = DN_BONUS_SIZE(lr->lrz_dnodesize);
 
 	if (lr->lrz_type == DMU_OT_ZAP_OTHER) {
 		if (lr->lr_foid == 0) {
 			lr->lr_foid = zap_create_dnsize(os,
 			    lr->lrz_type, lr->lrz_bonustype,
 			    bonuslen, lr->lrz_dnodesize, tx);
 		} else {
 			error = zap_create_claim_dnsize(os, lr->lr_foid,
 			    lr->lrz_type, lr->lrz_bonustype,
 			    bonuslen, lr->lrz_dnodesize, tx);
 		}
 	} else {
 		if (lr->lr_foid == 0) {
 			lr->lr_foid = dmu_object_alloc_dnsize(os,
 			    lr->lrz_type, 0, lr->lrz_bonustype,
 			    bonuslen, lr->lrz_dnodesize, tx);
 		} else {
 			error = dmu_object_claim_dnsize(os, lr->lr_foid,
 			    lr->lrz_type, 0, lr->lrz_bonustype,
 			    bonuslen, lr->lrz_dnodesize, tx);
 		}
 	}
 
 	if (error) {
 		ASSERT3U(error, ==, EEXIST);
 		ASSERT(zd->zd_zilog->zl_replay);
 		dmu_tx_commit(tx);
 		return (error);
 	}
 
 	ASSERT3U(lr->lr_foid, !=, 0);
 
 	if (lr->lrz_type != DMU_OT_ZAP_OTHER)
 		VERIFY0(dmu_object_set_blocksize(os, lr->lr_foid,
 		    lr->lrz_blocksize, lr->lrz_ibshift, tx));
 
 	VERIFY0(dmu_bonus_hold(os, lr->lr_foid, FTAG, &db));
 	bbt = ztest_bt_bonus(db);
 	dmu_buf_will_dirty(db, tx);
 	ztest_bt_generate(bbt, os, lr->lr_foid, lr->lrz_dnodesize, -1ULL,
 	    lr->lr_gen, txg, txg);
 	ztest_fill_unused_bonus(db, bbt, lr->lr_foid, os, lr->lr_gen);
 	dmu_buf_rele(db, FTAG);
 
 	VERIFY0(zap_add(os, lr->lr_doid, name, sizeof (uint64_t), 1,
 	    &lr->lr_foid, tx));
 
 	(void) ztest_log_create(zd, tx, lrc);
 
 	dmu_tx_commit(tx);
 
 	return (0);
 }
 
 static int
 ztest_replay_remove(void *arg1, void *arg2, boolean_t byteswap)
 {
 	ztest_ds_t *zd = arg1;
 	lr_remove_t *lr = arg2;
 	char *name = (char *)&lr->lr_data[0];		/* name follows lr */
 	objset_t *os = zd->zd_os;
 	dmu_object_info_t doi;
 	dmu_tx_t *tx;
 	uint64_t object, txg;
 
 	if (byteswap)
 		byteswap_uint64_array(lr, sizeof (*lr));
 
 	ASSERT3U(lr->lr_doid, ==, ZTEST_DIROBJ);
 	ASSERT3S(name[0], !=, '\0');
 
 	VERIFY0(
 	    zap_lookup(os, lr->lr_doid, name, sizeof (object), 1, &object));
 	ASSERT3U(object, !=, 0);
 
 	ztest_object_lock(zd, object, ZTRL_WRITER);
 
 	VERIFY0(dmu_object_info(os, object, &doi));
 
 	tx = dmu_tx_create(os);
 
 	dmu_tx_hold_zap(tx, lr->lr_doid, B_FALSE, name);
 	dmu_tx_hold_free(tx, object, 0, DMU_OBJECT_END);
 
 	txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
 	if (txg == 0) {
 		ztest_object_unlock(zd, object);
 		return (ENOSPC);
 	}
 
 	if (doi.doi_type == DMU_OT_ZAP_OTHER) {
 		VERIFY0(zap_destroy(os, object, tx));
 	} else {
 		VERIFY0(dmu_object_free(os, object, tx));
 	}
 
 	VERIFY0(zap_remove(os, lr->lr_doid, name, tx));
 
 	(void) ztest_log_remove(zd, tx, lr, object);
 
 	dmu_tx_commit(tx);
 
 	ztest_object_unlock(zd, object);
 
 	return (0);
 }
 
 static int
 ztest_replay_write(void *arg1, void *arg2, boolean_t byteswap)
 {
 	ztest_ds_t *zd = arg1;
 	lr_write_t *lr = arg2;
 	objset_t *os = zd->zd_os;
 	uint8_t *data = &lr->lr_data[0];		/* data follows lr */
 	uint64_t offset, length;
 	ztest_block_tag_t *bt = (ztest_block_tag_t *)data;
 	ztest_block_tag_t *bbt;
 	uint64_t gen, txg, lrtxg, crtxg;
 	dmu_object_info_t doi;
 	dmu_tx_t *tx;
 	dmu_buf_t *db;
 	arc_buf_t *abuf = NULL;
 	rl_t *rl;
 
 	if (byteswap)
 		byteswap_uint64_array(lr, sizeof (*lr));
 
 	offset = lr->lr_offset;
 	length = lr->lr_length;
 
 	/* If it's a dmu_sync() block, write the whole block */
 	if (lr->lr_common.lrc_reclen == sizeof (lr_write_t)) {
 		uint64_t blocksize = BP_GET_LSIZE(&lr->lr_blkptr);
 		if (length < blocksize) {
 			offset -= offset % blocksize;
 			length = blocksize;
 		}
 	}
 
 	if (bt->bt_magic == BSWAP_64(BT_MAGIC))
 		byteswap_uint64_array(bt, sizeof (*bt));
 
 	if (bt->bt_magic != BT_MAGIC)
 		bt = NULL;
 
 	ztest_object_lock(zd, lr->lr_foid, ZTRL_READER);
 	rl = ztest_range_lock(zd, lr->lr_foid, offset, length, ZTRL_WRITER);
 
 	VERIFY0(dmu_bonus_hold(os, lr->lr_foid, FTAG, &db));
 
 	dmu_object_info_from_db(db, &doi);
 
 	bbt = ztest_bt_bonus(db);
 	ASSERT3U(bbt->bt_magic, ==, BT_MAGIC);
 	gen = bbt->bt_gen;
 	crtxg = bbt->bt_crtxg;
 	lrtxg = lr->lr_common.lrc_txg;
 
 	tx = dmu_tx_create(os);
 
 	dmu_tx_hold_write(tx, lr->lr_foid, offset, length);
 
 	if (ztest_random(8) == 0 && length == doi.doi_data_block_size &&
 	    P2PHASE(offset, length) == 0)
 		abuf = dmu_request_arcbuf(db, length);
 
 	txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
 	if (txg == 0) {
 		if (abuf != NULL)
 			dmu_return_arcbuf(abuf);
 		dmu_buf_rele(db, FTAG);
 		ztest_range_unlock(rl);
 		ztest_object_unlock(zd, lr->lr_foid);
 		return (ENOSPC);
 	}
 
 	if (bt != NULL) {
 		/*
 		 * Usually, verify the old data before writing new data --
 		 * but not always, because we also want to verify correct
 		 * behavior when the data was not recently read into cache.
 		 */
 		ASSERT(doi.doi_data_block_size);
 		ASSERT0(offset % doi.doi_data_block_size);
 		if (ztest_random(4) != 0) {
 			int prefetch = ztest_random(2) ?
 			    DMU_READ_PREFETCH : DMU_READ_NO_PREFETCH;
 
 			/*
 			 * We will randomly set when to do O_DIRECT on a read.
 			 */
 			if (ztest_random(4) == 0)
 				prefetch |= DMU_DIRECTIO;
 
 			ztest_block_tag_t rbt;
 
 			VERIFY(dmu_read(os, lr->lr_foid, offset,
 			    sizeof (rbt), &rbt, prefetch) == 0);
 			if (rbt.bt_magic == BT_MAGIC) {
 				ztest_bt_verify(&rbt, os, lr->lr_foid, 0,
 				    offset, gen, txg, crtxg);
 			}
 		}
 
 		/*
 		 * Writes can appear to be newer than the bonus buffer because
 		 * the ztest_get_data() callback does a dmu_read() of the
 		 * open-context data, which may be different than the data
 		 * as it was when the write was generated.
 		 */
 		if (zd->zd_zilog->zl_replay) {
 			ztest_bt_verify(bt, os, lr->lr_foid, 0, offset,
 			    MAX(gen, bt->bt_gen), MAX(txg, lrtxg),
 			    bt->bt_crtxg);
 		}
 
 		/*
 		 * Set the bt's gen/txg to the bonus buffer's gen/txg
 		 * so that all of the usual ASSERTs will work.
 		 */
 		ztest_bt_generate(bt, os, lr->lr_foid, 0, offset, gen, txg,
 		    crtxg);
 	}
 
 	if (abuf == NULL) {
 		dmu_write(os, lr->lr_foid, offset, length, data, tx);
 	} else {
 		memcpy(abuf->b_data, data, length);
 		VERIFY0(dmu_assign_arcbuf_by_dbuf(db, offset, abuf, tx));
 	}
 
 	(void) ztest_log_write(zd, tx, lr);
 
 	dmu_buf_rele(db, FTAG);
 
 	dmu_tx_commit(tx);
 
 	ztest_range_unlock(rl);
 	ztest_object_unlock(zd, lr->lr_foid);
 
 	return (0);
 }
 
 static int
 ztest_replay_truncate(void *arg1, void *arg2, boolean_t byteswap)
 {
 	ztest_ds_t *zd = arg1;
 	lr_truncate_t *lr = arg2;
 	objset_t *os = zd->zd_os;
 	dmu_tx_t *tx;
 	uint64_t txg;
 	rl_t *rl;
 
 	if (byteswap)
 		byteswap_uint64_array(lr, sizeof (*lr));
 
 	ztest_object_lock(zd, lr->lr_foid, ZTRL_READER);
 	rl = ztest_range_lock(zd, lr->lr_foid, lr->lr_offset, lr->lr_length,
 	    ZTRL_WRITER);
 
 	tx = dmu_tx_create(os);
 
 	dmu_tx_hold_free(tx, lr->lr_foid, lr->lr_offset, lr->lr_length);
 
 	txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
 	if (txg == 0) {
 		ztest_range_unlock(rl);
 		ztest_object_unlock(zd, lr->lr_foid);
 		return (ENOSPC);
 	}
 
 	VERIFY0(dmu_free_range(os, lr->lr_foid, lr->lr_offset,
 	    lr->lr_length, tx));
 
 	(void) ztest_log_truncate(zd, tx, lr);
 
 	dmu_tx_commit(tx);
 
 	ztest_range_unlock(rl);
 	ztest_object_unlock(zd, lr->lr_foid);
 
 	return (0);
 }
 
 static int
 ztest_replay_setattr(void *arg1, void *arg2, boolean_t byteswap)
 {
 	ztest_ds_t *zd = arg1;
 	lr_setattr_t *lr = arg2;
 	objset_t *os = zd->zd_os;
 	dmu_tx_t *tx;
 	dmu_buf_t *db;
 	ztest_block_tag_t *bbt;
 	uint64_t txg, lrtxg, crtxg, dnodesize;
 
 	if (byteswap)
 		byteswap_uint64_array(lr, sizeof (*lr));
 
 	ztest_object_lock(zd, lr->lr_foid, ZTRL_WRITER);
 
 	VERIFY0(dmu_bonus_hold(os, lr->lr_foid, FTAG, &db));
 
 	tx = dmu_tx_create(os);
 	dmu_tx_hold_bonus(tx, lr->lr_foid);
 
 	txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
 	if (txg == 0) {
 		dmu_buf_rele(db, FTAG);
 		ztest_object_unlock(zd, lr->lr_foid);
 		return (ENOSPC);
 	}
 
 	bbt = ztest_bt_bonus(db);
 	ASSERT3U(bbt->bt_magic, ==, BT_MAGIC);
 	crtxg = bbt->bt_crtxg;
 	lrtxg = lr->lr_common.lrc_txg;
 	dnodesize = bbt->bt_dnodesize;
 
 	if (zd->zd_zilog->zl_replay) {
 		ASSERT3U(lr->lr_size, !=, 0);
 		ASSERT3U(lr->lr_mode, !=, 0);
 		ASSERT3U(lrtxg, !=, 0);
 	} else {
 		/*
 		 * Randomly change the size and increment the generation.
 		 */
 		lr->lr_size = (ztest_random(db->db_size / sizeof (*bbt)) + 1) *
 		    sizeof (*bbt);
 		lr->lr_mode = bbt->bt_gen + 1;
 		ASSERT0(lrtxg);
 	}
 
 	/*
 	 * Verify that the current bonus buffer is not newer than our txg.
 	 */
 	ztest_bt_verify(bbt, os, lr->lr_foid, dnodesize, -1ULL, lr->lr_mode,
 	    MAX(txg, lrtxg), crtxg);
 
 	dmu_buf_will_dirty(db, tx);
 
 	ASSERT3U(lr->lr_size, >=, sizeof (*bbt));
 	ASSERT3U(lr->lr_size, <=, db->db_size);
 	VERIFY0(dmu_set_bonus(db, lr->lr_size, tx));
 	bbt = ztest_bt_bonus(db);
 
 	ztest_bt_generate(bbt, os, lr->lr_foid, dnodesize, -1ULL, lr->lr_mode,
 	    txg, crtxg);
 	ztest_fill_unused_bonus(db, bbt, lr->lr_foid, os, bbt->bt_gen);
 	dmu_buf_rele(db, FTAG);
 
 	(void) ztest_log_setattr(zd, tx, lr);
 
 	dmu_tx_commit(tx);
 
 	ztest_object_unlock(zd, lr->lr_foid);
 
 	return (0);
 }
 
 static zil_replay_func_t *ztest_replay_vector[TX_MAX_TYPE] = {
 	NULL,			/* 0 no such transaction type */
 	ztest_replay_create,	/* TX_CREATE */
 	NULL,			/* TX_MKDIR */
 	NULL,			/* TX_MKXATTR */
 	NULL,			/* TX_SYMLINK */
 	ztest_replay_remove,	/* TX_REMOVE */
 	NULL,			/* TX_RMDIR */
 	NULL,			/* TX_LINK */
 	NULL,			/* TX_RENAME */
 	ztest_replay_write,	/* TX_WRITE */
 	ztest_replay_truncate,	/* TX_TRUNCATE */
 	ztest_replay_setattr,	/* TX_SETATTR */
 	NULL,			/* TX_ACL */
 	NULL,			/* TX_CREATE_ACL */
 	NULL,			/* TX_CREATE_ATTR */
 	NULL,			/* TX_CREATE_ACL_ATTR */
 	NULL,			/* TX_MKDIR_ACL */
 	NULL,			/* TX_MKDIR_ATTR */
 	NULL,			/* TX_MKDIR_ACL_ATTR */
 	NULL,			/* TX_WRITE2 */
 	NULL,			/* TX_SETSAXATTR */
 	NULL,			/* TX_RENAME_EXCHANGE */
 	NULL,			/* TX_RENAME_WHITEOUT */
 };
 
 /*
  * ZIL get_data callbacks
  */
 
 static void
 ztest_get_done(zgd_t *zgd, int error)
 {
 	(void) error;
 	ztest_ds_t *zd = zgd->zgd_private;
 	uint64_t object = ((rl_t *)zgd->zgd_lr)->rl_object;
 
 	if (zgd->zgd_db)
 		dmu_buf_rele(zgd->zgd_db, zgd);
 
 	ztest_range_unlock((rl_t *)zgd->zgd_lr);
 	ztest_object_unlock(zd, object);
 
 	umem_free(zgd, sizeof (*zgd));
 }
 
 static int
 ztest_get_data(void *arg, uint64_t arg2, lr_write_t *lr, char *buf,
     struct lwb *lwb, zio_t *zio)
 {
 	(void) arg2;
 	ztest_ds_t *zd = arg;
 	objset_t *os = zd->zd_os;
 	uint64_t object = lr->lr_foid;
 	uint64_t offset = lr->lr_offset;
 	uint64_t size = lr->lr_length;
 	uint64_t txg = lr->lr_common.lrc_txg;
 	uint64_t crtxg;
 	dmu_object_info_t doi;
 	dmu_buf_t *db;
 	zgd_t *zgd;
 	int error;
 
 	ASSERT3P(lwb, !=, NULL);
 	ASSERT3U(size, !=, 0);
 
 	ztest_object_lock(zd, object, ZTRL_READER);
 	error = dmu_bonus_hold(os, object, FTAG, &db);
 	if (error) {
 		ztest_object_unlock(zd, object);
 		return (error);
 	}
 
 	crtxg = ztest_bt_bonus(db)->bt_crtxg;
 
 	if (crtxg == 0 || crtxg > txg) {
 		dmu_buf_rele(db, FTAG);
 		ztest_object_unlock(zd, object);
 		return (ENOENT);
 	}
 
 	dmu_object_info_from_db(db, &doi);
 	dmu_buf_rele(db, FTAG);
 	db = NULL;
 
 	zgd = umem_zalloc(sizeof (*zgd), UMEM_NOFAIL);
 	zgd->zgd_lwb = lwb;
 	zgd->zgd_private = zd;
 
 	if (buf != NULL) {	/* immediate write */
 		zgd->zgd_lr = (struct zfs_locked_range *)ztest_range_lock(zd,
 		    object, offset, size, ZTRL_READER);
 
 		error = dmu_read(os, object, offset, size, buf,
 		    DMU_READ_NO_PREFETCH);
 		ASSERT0(error);
 	} else {
 		ASSERT3P(zio, !=, NULL);
 		size = doi.doi_data_block_size;
 		if (ISP2(size)) {
 			offset = P2ALIGN_TYPED(offset, size, uint64_t);
 		} else {
 			ASSERT3U(offset, <, size);
 			offset = 0;
 		}
 
 		zgd->zgd_lr = (struct zfs_locked_range *)ztest_range_lock(zd,
 		    object, offset, size, ZTRL_READER);
 
 		error = dmu_buf_hold_noread(os, object, offset, zgd, &db);
 
 		if (error == 0) {
 			blkptr_t *bp = &lr->lr_blkptr;
 
 			zgd->zgd_db = db;
 			zgd->zgd_bp = bp;
 
 			ASSERT3U(db->db_offset, ==, offset);
 			ASSERT3U(db->db_size, ==, size);
 
 			error = dmu_sync(zio, lr->lr_common.lrc_txg,
 			    ztest_get_done, zgd);
 
 			if (error == 0)
 				return (0);
 		}
 	}
 
 	ztest_get_done(zgd, error);
 
 	return (error);
 }
 
 static void *
 ztest_lr_alloc(size_t lrsize, char *name)
 {
 	char *lr;
 	size_t namesize = name ? strlen(name) + 1 : 0;
 
 	lr = umem_zalloc(lrsize + namesize, UMEM_NOFAIL);
 
 	if (name)
 		memcpy(lr + lrsize, name, namesize);
 
 	return (lr);
 }
 
 static void
 ztest_lr_free(void *lr, size_t lrsize, char *name)
 {
 	size_t namesize = name ? strlen(name) + 1 : 0;
 
 	umem_free(lr, lrsize + namesize);
 }
 
 /*
  * Lookup a bunch of objects.  Returns the number of objects not found.
  */
 static int
 ztest_lookup(ztest_ds_t *zd, ztest_od_t *od, int count)
 {
 	int missing = 0;
 	int error;
 	int i;
 
 	ASSERT(MUTEX_HELD(&zd->zd_dirobj_lock));
 
 	for (i = 0; i < count; i++, od++) {
 		od->od_object = 0;
 		error = zap_lookup(zd->zd_os, od->od_dir, od->od_name,
 		    sizeof (uint64_t), 1, &od->od_object);
 		if (error) {
 			ASSERT3S(error, ==, ENOENT);
 			ASSERT0(od->od_object);
 			missing++;
 		} else {
 			dmu_buf_t *db;
 			ztest_block_tag_t *bbt;
 			dmu_object_info_t doi;
 
 			ASSERT3U(od->od_object, !=, 0);
 			ASSERT0(missing);	/* there should be no gaps */
 
 			ztest_object_lock(zd, od->od_object, ZTRL_READER);
 			VERIFY0(dmu_bonus_hold(zd->zd_os, od->od_object,
 			    FTAG, &db));
 			dmu_object_info_from_db(db, &doi);
 			bbt = ztest_bt_bonus(db);
 			ASSERT3U(bbt->bt_magic, ==, BT_MAGIC);
 			od->od_type = doi.doi_type;
 			od->od_blocksize = doi.doi_data_block_size;
 			od->od_gen = bbt->bt_gen;
 			dmu_buf_rele(db, FTAG);
 			ztest_object_unlock(zd, od->od_object);
 		}
 	}
 
 	return (missing);
 }
 
 static int
 ztest_create(ztest_ds_t *zd, ztest_od_t *od, int count)
 {
 	int missing = 0;
 	int i;
 
 	ASSERT(MUTEX_HELD(&zd->zd_dirobj_lock));
 
 	for (i = 0; i < count; i++, od++) {
 		if (missing) {
 			od->od_object = 0;
 			missing++;
 			continue;
 		}
 
 		lr_create_t *lrc = ztest_lr_alloc(sizeof (*lrc), od->od_name);
 		_lr_create_t *lr = &lrc->lr_create;
 
 		lr->lr_doid = od->od_dir;
 		lr->lr_foid = 0;	/* 0 to allocate, > 0 to claim */
 		lr->lrz_type = od->od_crtype;
 		lr->lrz_blocksize = od->od_crblocksize;
 		lr->lrz_ibshift = ztest_random_ibshift();
 		lr->lrz_bonustype = DMU_OT_UINT64_OTHER;
 		lr->lrz_dnodesize = od->od_crdnodesize;
 		lr->lr_gen = od->od_crgen;
 		lr->lr_crtime[0] = time(NULL);
 
 		if (ztest_replay_create(zd, lr, B_FALSE) != 0) {
 			ASSERT0(missing);
 			od->od_object = 0;
 			missing++;
 		} else {
 			od->od_object = lr->lr_foid;
 			od->od_type = od->od_crtype;
 			od->od_blocksize = od->od_crblocksize;
 			od->od_gen = od->od_crgen;
 			ASSERT3U(od->od_object, !=, 0);
 		}
 
 		ztest_lr_free(lr, sizeof (*lr), od->od_name);
 	}
 
 	return (missing);
 }
 
 static int
 ztest_remove(ztest_ds_t *zd, ztest_od_t *od, int count)
 {
 	int missing = 0;
 	int error;
 	int i;
 
 	ASSERT(MUTEX_HELD(&zd->zd_dirobj_lock));
 
 	od += count - 1;
 
 	for (i = count - 1; i >= 0; i--, od--) {
 		if (missing) {
 			missing++;
 			continue;
 		}
 
 		/*
 		 * No object was found.
 		 */
 		if (od->od_object == 0)
 			continue;
 
 		lr_remove_t *lr = ztest_lr_alloc(sizeof (*lr), od->od_name);
 
 		lr->lr_doid = od->od_dir;
 
 		if ((error = ztest_replay_remove(zd, lr, B_FALSE)) != 0) {
 			ASSERT3U(error, ==, ENOSPC);
 			missing++;
 		} else {
 			od->od_object = 0;
 		}
 		ztest_lr_free(lr, sizeof (*lr), od->od_name);
 	}
 
 	return (missing);
 }
 
 static int
 ztest_write(ztest_ds_t *zd, uint64_t object, uint64_t offset, uint64_t size,
     const void *data)
 {
 	lr_write_t *lr;
 	int error;
 
 	lr = ztest_lr_alloc(sizeof (*lr) + size, NULL);
 
 	lr->lr_foid = object;
 	lr->lr_offset = offset;
 	lr->lr_length = size;
 	lr->lr_blkoff = 0;
 	BP_ZERO(&lr->lr_blkptr);
 
 	memcpy(&lr->lr_data[0], data, size);
 
 	error = ztest_replay_write(zd, lr, B_FALSE);
 
 	ztest_lr_free(lr, sizeof (*lr) + size, NULL);
 
 	return (error);
 }
 
 static int
 ztest_truncate(ztest_ds_t *zd, uint64_t object, uint64_t offset, uint64_t size)
 {
 	lr_truncate_t *lr;
 	int error;
 
 	lr = ztest_lr_alloc(sizeof (*lr), NULL);
 
 	lr->lr_foid = object;
 	lr->lr_offset = offset;
 	lr->lr_length = size;
 
 	error = ztest_replay_truncate(zd, lr, B_FALSE);
 
 	ztest_lr_free(lr, sizeof (*lr), NULL);
 
 	return (error);
 }
 
 static int
 ztest_setattr(ztest_ds_t *zd, uint64_t object)
 {
 	lr_setattr_t *lr;
 	int error;
 
 	lr = ztest_lr_alloc(sizeof (*lr), NULL);
 
 	lr->lr_foid = object;
 	lr->lr_size = 0;
 	lr->lr_mode = 0;
 
 	error = ztest_replay_setattr(zd, lr, B_FALSE);
 
 	ztest_lr_free(lr, sizeof (*lr), NULL);
 
 	return (error);
 }
 
 static void
 ztest_prealloc(ztest_ds_t *zd, uint64_t object, uint64_t offset, uint64_t size)
 {
 	objset_t *os = zd->zd_os;
 	dmu_tx_t *tx;
 	uint64_t txg;
 	rl_t *rl;
 
 	txg_wait_synced(dmu_objset_pool(os), 0);
 
 	ztest_object_lock(zd, object, ZTRL_READER);
 	rl = ztest_range_lock(zd, object, offset, size, ZTRL_WRITER);
 
 	tx = dmu_tx_create(os);
 
 	dmu_tx_hold_write(tx, object, offset, size);
 
 	txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
 
 	if (txg != 0) {
 		dmu_prealloc(os, object, offset, size, tx);
 		dmu_tx_commit(tx);
 		txg_wait_synced(dmu_objset_pool(os), txg);
 	} else {
 		(void) dmu_free_long_range(os, object, offset, size);
 	}
 
 	ztest_range_unlock(rl);
 	ztest_object_unlock(zd, object);
 }
 
 static void
 ztest_io(ztest_ds_t *zd, uint64_t object, uint64_t offset)
 {
 	int err;
 	ztest_block_tag_t wbt;
 	dmu_object_info_t doi;
 	enum ztest_io_type io_type;
 	uint64_t blocksize;
 	void *data;
 	uint32_t dmu_read_flags = DMU_READ_NO_PREFETCH;
 
 	/*
 	 * We will randomly set when to do O_DIRECT on a read.
 	 */
 	if (ztest_random(4) == 0)
 		dmu_read_flags |= DMU_DIRECTIO;
 
 	VERIFY0(dmu_object_info(zd->zd_os, object, &doi));
 	blocksize = doi.doi_data_block_size;
 	data = umem_alloc(blocksize, UMEM_NOFAIL);
 
 	/*
 	 * Pick an i/o type at random, biased toward writing block tags.
 	 */
 	io_type = ztest_random(ZTEST_IO_TYPES);
 	if (ztest_random(2) == 0)
 		io_type = ZTEST_IO_WRITE_TAG;
 
 	(void) pthread_rwlock_rdlock(&zd->zd_zilog_lock);
 
 	switch (io_type) {
 
 	case ZTEST_IO_WRITE_TAG:
 		ztest_bt_generate(&wbt, zd->zd_os, object, doi.doi_dnodesize,
 		    offset, 0, 0, 0);
 		(void) ztest_write(zd, object, offset, sizeof (wbt), &wbt);
 		break;
 
 	case ZTEST_IO_WRITE_PATTERN:
 		(void) memset(data, 'a' + (object + offset) % 5, blocksize);
 		if (ztest_random(2) == 0) {
 			/*
 			 * Induce fletcher2 collisions to ensure that
 			 * zio_ddt_collision() detects and resolves them
 			 * when using fletcher2-verify for deduplication.
 			 */
 			((uint64_t *)data)[0] ^= 1ULL << 63;
 			((uint64_t *)data)[4] ^= 1ULL << 63;
 		}
 		(void) ztest_write(zd, object, offset, blocksize, data);
 		break;
 
 	case ZTEST_IO_WRITE_ZEROES:
 		memset(data, 0, blocksize);
 		(void) ztest_write(zd, object, offset, blocksize, data);
 		break;
 
 	case ZTEST_IO_TRUNCATE:
 		(void) ztest_truncate(zd, object, offset, blocksize);
 		break;
 
 	case ZTEST_IO_SETATTR:
 		(void) ztest_setattr(zd, object);
 		break;
 	default:
 		break;
 
 	case ZTEST_IO_REWRITE:
 		(void) pthread_rwlock_rdlock(&ztest_name_lock);
 		err = ztest_dsl_prop_set_uint64(zd->zd_name,
 		    ZFS_PROP_CHECKSUM, spa_dedup_checksum(ztest_spa),
 		    B_FALSE);
 		ASSERT(err == 0 || err == ENOSPC);
 		err = ztest_dsl_prop_set_uint64(zd->zd_name,
 		    ZFS_PROP_COMPRESSION,
 		    ztest_random_dsl_prop(ZFS_PROP_COMPRESSION),
 		    B_FALSE);
 		ASSERT(err == 0 || err == ENOSPC);
 		(void) pthread_rwlock_unlock(&ztest_name_lock);
 
 		VERIFY0(dmu_read(zd->zd_os, object, offset, blocksize, data,
 		    dmu_read_flags));
 
 		(void) ztest_write(zd, object, offset, blocksize, data);
 		break;
 	}
 
 	(void) pthread_rwlock_unlock(&zd->zd_zilog_lock);
 
 	umem_free(data, blocksize);
 }
 
 /*
  * Initialize an object description template.
  */
 static void
 ztest_od_init(ztest_od_t *od, uint64_t id, const char *tag, uint64_t index,
     dmu_object_type_t type, uint64_t blocksize, uint64_t dnodesize,
     uint64_t gen)
 {
 	od->od_dir = ZTEST_DIROBJ;
 	od->od_object = 0;
 
 	od->od_crtype = type;
 	od->od_crblocksize = blocksize ? blocksize : ztest_random_blocksize();
 	od->od_crdnodesize = dnodesize ? dnodesize : ztest_random_dnodesize();
 	od->od_crgen = gen;
 
 	od->od_type = DMU_OT_NONE;
 	od->od_blocksize = 0;
 	od->od_gen = 0;
 
 	(void) snprintf(od->od_name, sizeof (od->od_name),
 	    "%s(%"PRId64")[%"PRIu64"]",
 	    tag, id, index);
 }
 
 /*
  * Lookup or create the objects for a test using the od template.
  * If the objects do not all exist, or if 'remove' is specified,
  * remove any existing objects and create new ones.  Otherwise,
  * use the existing objects.
  */
 static int
 ztest_object_init(ztest_ds_t *zd, ztest_od_t *od, size_t size, boolean_t remove)
 {
 	int count = size / sizeof (*od);
 	int rv = 0;
 
 	mutex_enter(&zd->zd_dirobj_lock);
 	if ((ztest_lookup(zd, od, count) != 0 || remove) &&
 	    (ztest_remove(zd, od, count) != 0 ||
 	    ztest_create(zd, od, count) != 0))
 		rv = -1;
 	zd->zd_od = od;
 	mutex_exit(&zd->zd_dirobj_lock);
 
 	return (rv);
 }
 
 void
 ztest_zil_commit(ztest_ds_t *zd, uint64_t id)
 {
 	(void) id;
 	zilog_t *zilog = zd->zd_zilog;
 
 	(void) pthread_rwlock_rdlock(&zd->zd_zilog_lock);
 
 	zil_commit(zilog, ztest_random(ZTEST_OBJECTS));
 
 	/*
 	 * Remember the committed values in zd, which is in parent/child
 	 * shared memory.  If we die, the next iteration of ztest_run()
 	 * will verify that the log really does contain this record.
 	 */
 	mutex_enter(&zilog->zl_lock);
 	ASSERT3P(zd->zd_shared, !=, NULL);
 	ASSERT3U(zd->zd_shared->zd_seq, <=, zilog->zl_commit_lr_seq);
 	zd->zd_shared->zd_seq = zilog->zl_commit_lr_seq;
 	mutex_exit(&zilog->zl_lock);
 
 	(void) pthread_rwlock_unlock(&zd->zd_zilog_lock);
 }
 
 /*
  * This function is designed to simulate the operations that occur during a
  * mount/unmount operation.  We hold the dataset across these operations in an
  * attempt to expose any implicit assumptions about ZIL management.
  */
 void
 ztest_zil_remount(ztest_ds_t *zd, uint64_t id)
 {
 	(void) id;
 	objset_t *os = zd->zd_os;
 
 	/*
 	 * We hold the ztest_vdev_lock so we don't cause problems with
 	 * other threads that wish to remove a log device, such as
 	 * ztest_device_removal().
 	 */
 	mutex_enter(&ztest_vdev_lock);
 
 	/*
 	 * We grab the zd_dirobj_lock to ensure that no other thread is
 	 * updating the zil (i.e. adding in-memory log records) and the
 	 * zd_zilog_lock to block any I/O.
 	 */
 	mutex_enter(&zd->zd_dirobj_lock);
 	(void) pthread_rwlock_wrlock(&zd->zd_zilog_lock);
 
 	/* zfsvfs_teardown() */
 	zil_close(zd->zd_zilog);
 
 	/* zfsvfs_setup() */
 	VERIFY3P(zil_open(os, ztest_get_data, NULL), ==, zd->zd_zilog);
 	zil_replay(os, zd, ztest_replay_vector);
 
 	(void) pthread_rwlock_unlock(&zd->zd_zilog_lock);
 	mutex_exit(&zd->zd_dirobj_lock);
 	mutex_exit(&ztest_vdev_lock);
 }
 
 /*
  * Verify that we can't destroy an active pool, create an existing pool,
  * or create a pool with a bad vdev spec.
  */
 void
 ztest_spa_create_destroy(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	ztest_shared_opts_t *zo = &ztest_opts;
 	spa_t *spa;
 	nvlist_t *nvroot;
 
 	if (zo->zo_mmp_test)
 		return;
 
 	/*
 	 * Attempt to create using a bad file.
 	 */
 	nvroot = make_vdev_root("/dev/bogus", NULL, NULL, 0, 0, NULL, 0, 0, 1);
 	VERIFY3U(ENOENT, ==,
 	    spa_create("ztest_bad_file", nvroot, NULL, NULL, NULL));
 	fnvlist_free(nvroot);
 
 	/*
 	 * Attempt to create using a bad mirror.
 	 */
 	nvroot = make_vdev_root("/dev/bogus", NULL, NULL, 0, 0, NULL, 0, 2, 1);
 	VERIFY3U(ENOENT, ==,
 	    spa_create("ztest_bad_mirror", nvroot, NULL, NULL, NULL));
 	fnvlist_free(nvroot);
 
 	/*
 	 * Attempt to create an existing pool.  It shouldn't matter
 	 * what's in the nvroot; we should fail with EEXIST.
 	 */
 	(void) pthread_rwlock_rdlock(&ztest_name_lock);
 	nvroot = make_vdev_root("/dev/bogus", NULL, NULL, 0, 0, NULL, 0, 0, 1);
 	VERIFY3U(EEXIST, ==,
 	    spa_create(zo->zo_pool, nvroot, NULL, NULL, NULL));
 	fnvlist_free(nvroot);
 
 	/*
 	 * We open a reference to the spa and then we try to export it
 	 * expecting one of the following errors:
 	 *
 	 * EBUSY
 	 *	Because of the reference we just opened.
 	 *
 	 * ZFS_ERR_EXPORT_IN_PROGRESS
 	 *	For the case that there is another ztest thread doing
 	 *	an export concurrently.
 	 */
 	VERIFY0(spa_open(zo->zo_pool, &spa, FTAG));
 	int error = spa_destroy(zo->zo_pool);
 	if (error != EBUSY && error != ZFS_ERR_EXPORT_IN_PROGRESS) {
 		fatal(B_FALSE, "spa_destroy(%s) returned unexpected value %d",
 		    spa->spa_name, error);
 	}
 	spa_close(spa, FTAG);
 
 	(void) pthread_rwlock_unlock(&ztest_name_lock);
 }
 
 /*
  * Start and then stop the MMP threads to ensure the startup and shutdown code
  * works properly.  Actual protection and property-related code tested via ZTS.
  */
 void
 ztest_mmp_enable_disable(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	ztest_shared_opts_t *zo = &ztest_opts;
 	spa_t *spa = ztest_spa;
 
 	if (zo->zo_mmp_test)
 		return;
 
 	/*
 	 * Since enabling MMP involves setting a property, it could not be done
 	 * while the pool is suspended.
 	 */
 	if (spa_suspended(spa))
 		return;
 
 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
 	mutex_enter(&spa->spa_props_lock);
 
 	zfs_multihost_fail_intervals = 0;
 
 	if (!spa_multihost(spa)) {
 		spa->spa_multihost = B_TRUE;
 		mmp_thread_start(spa);
 	}
 
 	mutex_exit(&spa->spa_props_lock);
 	spa_config_exit(spa, SCL_CONFIG, FTAG);
 
 	txg_wait_synced(spa_get_dsl(spa), 0);
 	mmp_signal_all_threads();
 	txg_wait_synced(spa_get_dsl(spa), 0);
 
 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
 	mutex_enter(&spa->spa_props_lock);
 
 	if (spa_multihost(spa)) {
 		mmp_thread_stop(spa);
 		spa->spa_multihost = B_FALSE;
 	}
 
 	mutex_exit(&spa->spa_props_lock);
 	spa_config_exit(spa, SCL_CONFIG, FTAG);
 }
 
 static int
 ztest_get_raidz_children(spa_t *spa)
 {
 	(void) spa;
 	vdev_t *raidvd;
 
 	ASSERT(MUTEX_HELD(&ztest_vdev_lock));
 
 	if (ztest_opts.zo_raid_do_expand) {
 		raidvd = ztest_spa->spa_root_vdev->vdev_child[0];
 
 		ASSERT(raidvd->vdev_ops == &vdev_raidz_ops);
 
 		return (raidvd->vdev_children);
 	}
 
 	return (ztest_opts.zo_raid_children);
 }
 
 void
 ztest_spa_upgrade(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	spa_t *spa;
 	uint64_t initial_version = SPA_VERSION_INITIAL;
 	uint64_t raidz_children, version, newversion;
 	nvlist_t *nvroot, *props;
 	char *name;
 
 	if (ztest_opts.zo_mmp_test)
 		return;
 
 	/* dRAID added after feature flags, skip upgrade test. */
 	if (strcmp(ztest_opts.zo_raid_type, VDEV_TYPE_DRAID) == 0)
 		return;
 
 	mutex_enter(&ztest_vdev_lock);
 	name = kmem_asprintf("%s_upgrade", ztest_opts.zo_pool);
 
 	/*
 	 * Clean up from previous runs.
 	 */
 	(void) spa_destroy(name);
 
 	raidz_children = ztest_get_raidz_children(ztest_spa);
 
 	nvroot = make_vdev_root(NULL, NULL, name, ztest_opts.zo_vdev_size, 0,
 	    NULL, raidz_children, ztest_opts.zo_mirrors, 1);
 
 	/*
 	 * If we're configuring a RAIDZ device then make sure that the
 	 * initial version is capable of supporting that feature.
 	 */
 	switch (ztest_opts.zo_raid_parity) {
 	case 0:
 	case 1:
 		initial_version = SPA_VERSION_INITIAL;
 		break;
 	case 2:
 		initial_version = SPA_VERSION_RAIDZ2;
 		break;
 	case 3:
 		initial_version = SPA_VERSION_RAIDZ3;
 		break;
 	}
 
 	/*
 	 * Create a pool with a spa version that can be upgraded. Pick
 	 * a value between initial_version and SPA_VERSION_BEFORE_FEATURES.
 	 */
 	do {
 		version = ztest_random_spa_version(initial_version);
 	} while (version > SPA_VERSION_BEFORE_FEATURES);
 
 	props = fnvlist_alloc();
 	fnvlist_add_uint64(props,
 	    zpool_prop_to_name(ZPOOL_PROP_VERSION), version);
 	VERIFY0(spa_create(name, nvroot, props, NULL, NULL));
 	fnvlist_free(nvroot);
 	fnvlist_free(props);
 
 	VERIFY0(spa_open(name, &spa, FTAG));
 	VERIFY3U(spa_version(spa), ==, version);
 	newversion = ztest_random_spa_version(version + 1);
 
 	if (ztest_opts.zo_verbose >= 4) {
 		(void) printf("upgrading spa version from "
 		    "%"PRIu64" to %"PRIu64"\n",
 		    version, newversion);
 	}
 
 	spa_upgrade(spa, newversion);
 	VERIFY3U(spa_version(spa), >, version);
 	VERIFY3U(spa_version(spa), ==, fnvlist_lookup_uint64(spa->spa_config,
 	    zpool_prop_to_name(ZPOOL_PROP_VERSION)));
 	spa_close(spa, FTAG);
 
 	kmem_strfree(name);
 	mutex_exit(&ztest_vdev_lock);
 }
 
 static void
 ztest_spa_checkpoint(spa_t *spa)
 {
 	ASSERT(MUTEX_HELD(&ztest_checkpoint_lock));
 
 	int error = spa_checkpoint(spa->spa_name);
 
 	switch (error) {
 	case 0:
 	case ZFS_ERR_DEVRM_IN_PROGRESS:
 	case ZFS_ERR_DISCARDING_CHECKPOINT:
 	case ZFS_ERR_CHECKPOINT_EXISTS:
 	case ZFS_ERR_RAIDZ_EXPAND_IN_PROGRESS:
 		break;
 	case ENOSPC:
 		ztest_record_enospc(FTAG);
 		break;
 	default:
 		fatal(B_FALSE, "spa_checkpoint(%s) = %d", spa->spa_name, error);
 	}
 }
 
 static void
 ztest_spa_discard_checkpoint(spa_t *spa)
 {
 	ASSERT(MUTEX_HELD(&ztest_checkpoint_lock));
 
 	int error = spa_checkpoint_discard(spa->spa_name);
 
 	switch (error) {
 	case 0:
 	case ZFS_ERR_DISCARDING_CHECKPOINT:
 	case ZFS_ERR_NO_CHECKPOINT:
 		break;
 	default:
 		fatal(B_FALSE, "spa_discard_checkpoint(%s) = %d",
 		    spa->spa_name, error);
 	}
 
 }
 
 void
 ztest_spa_checkpoint_create_discard(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	spa_t *spa = ztest_spa;
 
 	mutex_enter(&ztest_checkpoint_lock);
 	if (ztest_random(2) == 0) {
 		ztest_spa_checkpoint(spa);
 	} else {
 		ztest_spa_discard_checkpoint(spa);
 	}
 	mutex_exit(&ztest_checkpoint_lock);
 }
 
 
 static vdev_t *
 vdev_lookup_by_path(vdev_t *vd, const char *path)
 {
 	vdev_t *mvd;
 	int c;
 
 	if (vd->vdev_path != NULL && strcmp(path, vd->vdev_path) == 0)
 		return (vd);
 
 	for (c = 0; c < vd->vdev_children; c++)
 		if ((mvd = vdev_lookup_by_path(vd->vdev_child[c], path)) !=
 		    NULL)
 			return (mvd);
 
 	return (NULL);
 }
 
 static int
 spa_num_top_vdevs(spa_t *spa)
 {
 	vdev_t *rvd = spa->spa_root_vdev;
 	ASSERT3U(spa_config_held(spa, SCL_VDEV, RW_READER), ==, SCL_VDEV);
 	return (rvd->vdev_children);
 }
 
 /*
  * Verify that vdev_add() works as expected.
  */
 void
 ztest_vdev_add_remove(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	ztest_shared_t *zs = ztest_shared;
 	spa_t *spa = ztest_spa;
 	uint64_t leaves;
 	uint64_t guid;
 	uint64_t raidz_children;
 
 	nvlist_t *nvroot;
 	int error;
 
 	if (ztest_opts.zo_mmp_test)
 		return;
 
 	mutex_enter(&ztest_vdev_lock);
 	raidz_children = ztest_get_raidz_children(spa);
 	leaves = MAX(zs->zs_mirrors + zs->zs_splits, 1) * raidz_children;
 
 	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
 
 	ztest_shared->zs_vdev_next_leaf = spa_num_top_vdevs(spa) * leaves;
 
 	/*
 	 * If we have slogs then remove them 1/4 of the time.
 	 */
 	if (spa_has_slogs(spa) && ztest_random(4) == 0) {
 		metaslab_group_t *mg;
 
 		/*
 		 * find the first real slog in log allocation class
 		 */
 		mg =  spa_log_class(spa)->mc_allocator[0].mca_rotor;
 		while (!mg->mg_vd->vdev_islog)
 			mg = mg->mg_next;
 
 		guid = mg->mg_vd->vdev_guid;
 
 		spa_config_exit(spa, SCL_VDEV, FTAG);
 
 		/*
 		 * We have to grab the zs_name_lock as writer to
 		 * prevent a race between removing a slog (dmu_objset_find)
 		 * and destroying a dataset. Removing the slog will
 		 * grab a reference on the dataset which may cause
 		 * dsl_destroy_head() to fail with EBUSY thus
 		 * leaving the dataset in an inconsistent state.
 		 */
 		pthread_rwlock_wrlock(&ztest_name_lock);
 		error = spa_vdev_remove(spa, guid, B_FALSE);
 		pthread_rwlock_unlock(&ztest_name_lock);
 
 		switch (error) {
 		case 0:
 		case EEXIST:	/* Generic zil_reset() error */
 		case EBUSY:	/* Replay required */
 		case EACCES:	/* Crypto key not loaded */
 		case ZFS_ERR_CHECKPOINT_EXISTS:
 		case ZFS_ERR_DISCARDING_CHECKPOINT:
 			break;
 		default:
 			fatal(B_FALSE, "spa_vdev_remove() = %d", error);
 		}
 	} else {
 		spa_config_exit(spa, SCL_VDEV, FTAG);
 
 		/*
 		 * Make 1/4 of the devices be log devices
 		 */
 		nvroot = make_vdev_root(NULL, NULL, NULL,
 		    ztest_opts.zo_vdev_size, 0, (ztest_random(4) == 0) ?
 		    "log" : NULL, raidz_children, zs->zs_mirrors,
 		    1);
 
 		error = spa_vdev_add(spa, nvroot, B_FALSE);
 		fnvlist_free(nvroot);
 
 		switch (error) {
 		case 0:
 			break;
 		case ENOSPC:
 			ztest_record_enospc("spa_vdev_add");
 			break;
 		default:
 			fatal(B_FALSE, "spa_vdev_add() = %d", error);
 		}
 	}
 
 	mutex_exit(&ztest_vdev_lock);
 }
 
 void
 ztest_vdev_class_add(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	ztest_shared_t *zs = ztest_shared;
 	spa_t *spa = ztest_spa;
 	uint64_t leaves;
 	nvlist_t *nvroot;
 	uint64_t raidz_children;
 	const char *class = (ztest_random(2) == 0) ?
 	    VDEV_ALLOC_BIAS_SPECIAL : VDEV_ALLOC_BIAS_DEDUP;
 	int error;
 
 	/*
 	 * By default add a special vdev 50% of the time
 	 */
 	if ((ztest_opts.zo_special_vdevs == ZTEST_VDEV_CLASS_OFF) ||
 	    (ztest_opts.zo_special_vdevs == ZTEST_VDEV_CLASS_RND &&
 	    ztest_random(2) == 0)) {
 		return;
 	}
 
 	mutex_enter(&ztest_vdev_lock);
 
 	/* Only test with mirrors */
 	if (zs->zs_mirrors < 2) {
 		mutex_exit(&ztest_vdev_lock);
 		return;
 	}
 
 	/* requires feature@allocation_classes */
 	if (!spa_feature_is_enabled(spa, SPA_FEATURE_ALLOCATION_CLASSES)) {
 		mutex_exit(&ztest_vdev_lock);
 		return;
 	}
 
 	raidz_children = ztest_get_raidz_children(spa);
 	leaves = MAX(zs->zs_mirrors + zs->zs_splits, 1) * raidz_children;
 
 	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
 	ztest_shared->zs_vdev_next_leaf = spa_num_top_vdevs(spa) * leaves;
 	spa_config_exit(spa, SCL_VDEV, FTAG);
 
 	nvroot = make_vdev_root(NULL, NULL, NULL, ztest_opts.zo_vdev_size, 0,
 	    class, raidz_children, zs->zs_mirrors, 1);
 
 	error = spa_vdev_add(spa, nvroot, B_FALSE);
 	fnvlist_free(nvroot);
 
 	if (error == ENOSPC)
 		ztest_record_enospc("spa_vdev_add");
 	else if (error != 0)
 		fatal(B_FALSE, "spa_vdev_add() = %d", error);
 
 	/*
 	 * 50% of the time allow small blocks in the special class
 	 */
 	if (error == 0 &&
 	    spa_special_class(spa)->mc_groups == 1 && ztest_random(2) == 0) {
 		if (ztest_opts.zo_verbose >= 3)
 			(void) printf("Enabling special VDEV small blocks\n");
 		error = ztest_dsl_prop_set_uint64(zd->zd_name,
 		    ZFS_PROP_SPECIAL_SMALL_BLOCKS, 32768, B_FALSE);
 		ASSERT(error == 0 || error == ENOSPC);
 	}
 
 	mutex_exit(&ztest_vdev_lock);
 
 	if (ztest_opts.zo_verbose >= 3) {
 		metaslab_class_t *mc;
 
 		if (strcmp(class, VDEV_ALLOC_BIAS_SPECIAL) == 0)
 			mc = spa_special_class(spa);
 		else
 			mc = spa_dedup_class(spa);
 		(void) printf("Added a %s mirrored vdev (of %d)\n",
 		    class, (int)mc->mc_groups);
 	}
 }
 
 /*
  * Verify that adding/removing aux devices (l2arc, hot spare) works as expected.
  */
 void
 ztest_vdev_aux_add_remove(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	ztest_shared_t *zs = ztest_shared;
 	spa_t *spa = ztest_spa;
 	vdev_t *rvd = spa->spa_root_vdev;
 	spa_aux_vdev_t *sav;
 	const char *aux;
 	char *path;
 	uint64_t guid = 0;
 	int error, ignore_err = 0;
 
 	if (ztest_opts.zo_mmp_test)
 		return;
 
 	path = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
 
 	if (ztest_random(2) == 0) {
 		sav = &spa->spa_spares;
 		aux = ZPOOL_CONFIG_SPARES;
 	} else {
 		sav = &spa->spa_l2cache;
 		aux = ZPOOL_CONFIG_L2CACHE;
 	}
 
 	mutex_enter(&ztest_vdev_lock);
 
 	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
 
 	if (sav->sav_count != 0 && ztest_random(4) == 0) {
 		/*
 		 * Pick a random device to remove.
 		 */
 		vdev_t *svd = sav->sav_vdevs[ztest_random(sav->sav_count)];
 
 		/* dRAID spares cannot be removed; try anyways to see ENOTSUP */
 		if (strstr(svd->vdev_path, VDEV_TYPE_DRAID) != NULL)
 			ignore_err = ENOTSUP;
 
 		guid = svd->vdev_guid;
 	} else {
 		/*
 		 * Find an unused device we can add.
 		 */
 		zs->zs_vdev_aux = 0;
 		for (;;) {
 			int c;
 			(void) snprintf(path, MAXPATHLEN, ztest_aux_template,
 			    ztest_opts.zo_dir, ztest_opts.zo_pool, aux,
 			    zs->zs_vdev_aux);
 			for (c = 0; c < sav->sav_count; c++)
 				if (strcmp(sav->sav_vdevs[c]->vdev_path,
 				    path) == 0)
 					break;
 			if (c == sav->sav_count &&
 			    vdev_lookup_by_path(rvd, path) == NULL)
 				break;
 			zs->zs_vdev_aux++;
 		}
 	}
 
 	spa_config_exit(spa, SCL_VDEV, FTAG);
 
 	if (guid == 0) {
 		/*
 		 * Add a new device.
 		 */
 		nvlist_t *nvroot = make_vdev_root(NULL, aux, NULL,
 		    (ztest_opts.zo_vdev_size * 5) / 4, 0, NULL, 0, 0, 1);
 		error = spa_vdev_add(spa, nvroot, B_FALSE);
 
 		switch (error) {
 		case 0:
 			break;
 		default:
 			fatal(B_FALSE, "spa_vdev_add(%p) = %d", nvroot, error);
 		}
 		fnvlist_free(nvroot);
 	} else {
 		/*
 		 * Remove an existing device.  Sometimes, dirty its
 		 * vdev state first to make sure we handle removal
 		 * of devices that have pending state changes.
 		 */
 		if (ztest_random(2) == 0)
 			(void) vdev_online(spa, guid, 0, NULL);
 
 		error = spa_vdev_remove(spa, guid, B_FALSE);
 
 		switch (error) {
 		case 0:
 		case EBUSY:
 		case ZFS_ERR_CHECKPOINT_EXISTS:
 		case ZFS_ERR_DISCARDING_CHECKPOINT:
 			break;
 		default:
 			if (error != ignore_err)
 				fatal(B_FALSE,
 				    "spa_vdev_remove(%"PRIu64") = %d",
 				    guid, error);
 		}
 	}
 
 	mutex_exit(&ztest_vdev_lock);
 
 	umem_free(path, MAXPATHLEN);
 }
 
 /*
  * split a pool if it has mirror tlvdevs
  */
 void
 ztest_split_pool(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	ztest_shared_t *zs = ztest_shared;
 	spa_t *spa = ztest_spa;
 	vdev_t *rvd = spa->spa_root_vdev;
 	nvlist_t *tree, **child, *config, *split, **schild;
 	uint_t c, children, schildren = 0, lastlogid = 0;
 	int error = 0;
 
 	if (ztest_opts.zo_mmp_test)
 		return;
 
 	mutex_enter(&ztest_vdev_lock);
 
 	/* ensure we have a usable config; mirrors of raidz aren't supported */
 	if (zs->zs_mirrors < 3 || ztest_opts.zo_raid_children > 1) {
 		mutex_exit(&ztest_vdev_lock);
 		return;
 	}
 
 	/* clean up the old pool, if any */
 	(void) spa_destroy("splitp");
 
 	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
 
 	/* generate a config from the existing config */
 	mutex_enter(&spa->spa_props_lock);
 	tree = fnvlist_lookup_nvlist(spa->spa_config, ZPOOL_CONFIG_VDEV_TREE);
 	mutex_exit(&spa->spa_props_lock);
 
 	VERIFY0(nvlist_lookup_nvlist_array(tree, ZPOOL_CONFIG_CHILDREN,
 	    &child, &children));
 
 	schild = umem_alloc(rvd->vdev_children * sizeof (nvlist_t *),
 	    UMEM_NOFAIL);
 	for (c = 0; c < children; c++) {
 		vdev_t *tvd = rvd->vdev_child[c];
 		nvlist_t **mchild;
 		uint_t mchildren;
 
 		if (tvd->vdev_islog || tvd->vdev_ops == &vdev_hole_ops) {
 			schild[schildren] = fnvlist_alloc();
 			fnvlist_add_string(schild[schildren],
 			    ZPOOL_CONFIG_TYPE, VDEV_TYPE_HOLE);
 			fnvlist_add_uint64(schild[schildren],
 			    ZPOOL_CONFIG_IS_HOLE, 1);
 			if (lastlogid == 0)
 				lastlogid = schildren;
 			++schildren;
 			continue;
 		}
 		lastlogid = 0;
 		VERIFY0(nvlist_lookup_nvlist_array(child[c],
 		    ZPOOL_CONFIG_CHILDREN, &mchild, &mchildren));
 		schild[schildren++] = fnvlist_dup(mchild[0]);
 	}
 
 	/* OK, create a config that can be used to split */
 	split = fnvlist_alloc();
 	fnvlist_add_string(split, ZPOOL_CONFIG_TYPE, VDEV_TYPE_ROOT);
 	fnvlist_add_nvlist_array(split, ZPOOL_CONFIG_CHILDREN,
 	    (const nvlist_t **)schild, lastlogid != 0 ? lastlogid : schildren);
 
 	config = fnvlist_alloc();
 	fnvlist_add_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, split);
 
 	for (c = 0; c < schildren; c++)
 		fnvlist_free(schild[c]);
 	umem_free(schild, rvd->vdev_children * sizeof (nvlist_t *));
 	fnvlist_free(split);
 
 	spa_config_exit(spa, SCL_VDEV, FTAG);
 
 	(void) pthread_rwlock_wrlock(&ztest_name_lock);
 	error = spa_vdev_split_mirror(spa, "splitp", config, NULL, B_FALSE);
 	(void) pthread_rwlock_unlock(&ztest_name_lock);
 
 	fnvlist_free(config);
 
 	if (error == 0) {
 		(void) printf("successful split - results:\n");
 		mutex_enter(&spa_namespace_lock);
 		show_pool_stats(spa);
 		show_pool_stats(spa_lookup("splitp"));
 		mutex_exit(&spa_namespace_lock);
 		++zs->zs_splits;
 		--zs->zs_mirrors;
 	}
 	mutex_exit(&ztest_vdev_lock);
 }
 
 /*
  * Verify that we can attach and detach devices.
  */
 void
 ztest_vdev_attach_detach(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	ztest_shared_t *zs = ztest_shared;
 	spa_t *spa = ztest_spa;
 	spa_aux_vdev_t *sav = &spa->spa_spares;
 	vdev_t *rvd = spa->spa_root_vdev;
 	vdev_t *oldvd, *newvd, *pvd;
 	nvlist_t *root;
 	uint64_t leaves;
 	uint64_t leaf, top;
 	uint64_t ashift = ztest_get_ashift();
 	uint64_t oldguid, pguid;
 	uint64_t oldsize, newsize;
 	uint64_t raidz_children;
 	char *oldpath, *newpath;
 	int replacing;
 	int oldvd_has_siblings = B_FALSE;
 	int newvd_is_spare = B_FALSE;
 	int newvd_is_dspare = B_FALSE;
 	int oldvd_is_log;
 	int oldvd_is_special;
 	int error, expected_error;
 
 	if (ztest_opts.zo_mmp_test)
 		return;
 
 	oldpath = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
 	newpath = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
 
 	mutex_enter(&ztest_vdev_lock);
 	raidz_children = ztest_get_raidz_children(spa);
 	leaves = MAX(zs->zs_mirrors, 1) * raidz_children;
 
 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
 
 	/*
 	 * If a vdev is in the process of being removed, its removal may
 	 * finish while we are in progress, leading to an unexpected error
 	 * value.  Don't bother trying to attach while we are in the middle
 	 * of removal.
 	 */
 	if (ztest_device_removal_active) {
 		spa_config_exit(spa, SCL_ALL, FTAG);
 		goto out;
 	}
 
 	/*
 	 * RAIDZ leaf VDEV mirrors are not currently supported while a
 	 * RAIDZ expansion is in progress.
 	 */
 	if (ztest_opts.zo_raid_do_expand) {
 		spa_config_exit(spa, SCL_ALL, FTAG);
 		goto out;
 	}
 
 	/*
 	 * Decide whether to do an attach or a replace.
 	 */
 	replacing = ztest_random(2);
 
 	/*
 	 * Pick a random top-level vdev.
 	 */
 	top = ztest_random_vdev_top(spa, B_TRUE);
 
 	/*
 	 * Pick a random leaf within it.
 	 */
 	leaf = ztest_random(leaves);
 
 	/*
 	 * Locate this vdev.
 	 */
 	oldvd = rvd->vdev_child[top];
 
 	/* pick a child from the mirror */
 	if (zs->zs_mirrors >= 1) {
 		ASSERT3P(oldvd->vdev_ops, ==, &vdev_mirror_ops);
 		ASSERT3U(oldvd->vdev_children, >=, zs->zs_mirrors);
 		oldvd = oldvd->vdev_child[leaf / raidz_children];
 	}
 
 	/* pick a child out of the raidz group */
 	if (ztest_opts.zo_raid_children > 1) {
 		if (strcmp(oldvd->vdev_ops->vdev_op_type, "raidz") == 0)
 			ASSERT3P(oldvd->vdev_ops, ==, &vdev_raidz_ops);
 		else
 			ASSERT3P(oldvd->vdev_ops, ==, &vdev_draid_ops);
 		oldvd = oldvd->vdev_child[leaf % raidz_children];
 	}
 
 	/*
 	 * If we're already doing an attach or replace, oldvd may be a
 	 * mirror vdev -- in which case, pick a random child.
 	 */
 	while (oldvd->vdev_children != 0) {
 		oldvd_has_siblings = B_TRUE;
 		ASSERT3U(oldvd->vdev_children, >=, 2);
 		oldvd = oldvd->vdev_child[ztest_random(oldvd->vdev_children)];
 	}
 
 	oldguid = oldvd->vdev_guid;
 	oldsize = vdev_get_min_asize(oldvd);
 	oldvd_is_log = oldvd->vdev_top->vdev_islog;
 	oldvd_is_special =
 	    oldvd->vdev_top->vdev_alloc_bias == VDEV_BIAS_SPECIAL ||
 	    oldvd->vdev_top->vdev_alloc_bias == VDEV_BIAS_DEDUP;
 	(void) strlcpy(oldpath, oldvd->vdev_path, MAXPATHLEN);
 	pvd = oldvd->vdev_parent;
 	pguid = pvd->vdev_guid;
 
 	/*
 	 * If oldvd has siblings, then half of the time, detach it.  Prior
 	 * to the detach the pool is scrubbed in order to prevent creating
 	 * unrepairable blocks as a result of the data corruption injection.
 	 */
 	if (oldvd_has_siblings && ztest_random(2) == 0) {
 		spa_config_exit(spa, SCL_ALL, FTAG);
 
 		error = ztest_scrub_impl(spa);
 		if (error)
 			goto out;
 
 		error = spa_vdev_detach(spa, oldguid, pguid, B_FALSE);
 		if (error != 0 && error != ENODEV && error != EBUSY &&
 		    error != ENOTSUP && error != ZFS_ERR_CHECKPOINT_EXISTS &&
 		    error != ZFS_ERR_DISCARDING_CHECKPOINT)
 			fatal(B_FALSE, "detach (%s) returned %d",
 			    oldpath, error);
 		goto out;
 	}
 
 	/*
 	 * For the new vdev, choose with equal probability between the two
 	 * standard paths (ending in either 'a' or 'b') or a random hot spare.
 	 */
 	if (sav->sav_count != 0 && ztest_random(3) == 0) {
 		newvd = sav->sav_vdevs[ztest_random(sav->sav_count)];
 		newvd_is_spare = B_TRUE;
 
 		if (newvd->vdev_ops == &vdev_draid_spare_ops)
 			newvd_is_dspare = B_TRUE;
 
 		(void) strlcpy(newpath, newvd->vdev_path, MAXPATHLEN);
 	} else {
 		(void) snprintf(newpath, MAXPATHLEN, ztest_dev_template,
 		    ztest_opts.zo_dir, ztest_opts.zo_pool,
 		    top * leaves + leaf);
 		if (ztest_random(2) == 0)
 			newpath[strlen(newpath) - 1] = 'b';
 		newvd = vdev_lookup_by_path(rvd, newpath);
 	}
 
 	if (newvd) {
 		/*
 		 * Reopen to ensure the vdev's asize field isn't stale.
 		 */
 		vdev_reopen(newvd);
 		newsize = vdev_get_min_asize(newvd);
 	} else {
 		/*
 		 * Make newsize a little bigger or smaller than oldsize.
 		 * If it's smaller, the attach should fail.
 		 * If it's larger, and we're doing a replace,
 		 * we should get dynamic LUN growth when we're done.
 		 */
 		newsize = 10 * oldsize / (9 + ztest_random(3));
 	}
 
 	/*
 	 * If pvd is not a mirror or root, the attach should fail with ENOTSUP,
 	 * unless it's a replace; in that case any non-replacing parent is OK.
 	 *
 	 * If newvd is already part of the pool, it should fail with EBUSY.
 	 *
 	 * If newvd is too small, it should fail with EOVERFLOW.
 	 *
 	 * If newvd is a distributed spare and it's being attached to a
 	 * dRAID which is not its parent it should fail with EINVAL.
 	 */
 	if (pvd->vdev_ops != &vdev_mirror_ops &&
 	    pvd->vdev_ops != &vdev_root_ops && (!replacing ||
 	    pvd->vdev_ops == &vdev_replacing_ops ||
 	    pvd->vdev_ops == &vdev_spare_ops))
 		expected_error = ENOTSUP;
 	else if (newvd_is_spare &&
 	    (!replacing || oldvd_is_log || oldvd_is_special))
 		expected_error = ENOTSUP;
 	else if (newvd == oldvd)
 		expected_error = replacing ? 0 : EBUSY;
 	else if (vdev_lookup_by_path(rvd, newpath) != NULL)
 		expected_error = EBUSY;
 	else if (!newvd_is_dspare && newsize < oldsize)
 		expected_error = EOVERFLOW;
 	else if (ashift > oldvd->vdev_top->vdev_ashift)
 		expected_error = EDOM;
 	else if (newvd_is_dspare && pvd != vdev_draid_spare_get_parent(newvd))
 		expected_error = EINVAL;
 	else
 		expected_error = 0;
 
 	spa_config_exit(spa, SCL_ALL, FTAG);
 
 	/*
 	 * Build the nvlist describing newpath.
 	 */
 	root = make_vdev_root(newpath, NULL, NULL, newvd == NULL ? newsize : 0,
 	    ashift, NULL, 0, 0, 1);
 
 	/*
 	 * When supported select either a healing or sequential resilver.
 	 */
 	boolean_t rebuilding = B_FALSE;
 	if (pvd->vdev_ops == &vdev_mirror_ops ||
 	    pvd->vdev_ops ==  &vdev_root_ops) {
 		rebuilding = !!ztest_random(2);
 	}
 
 	error = spa_vdev_attach(spa, oldguid, root, replacing, rebuilding);
 
 	fnvlist_free(root);
 
 	/*
 	 * If our parent was the replacing vdev, but the replace completed,
 	 * then instead of failing with ENOTSUP we may either succeed,
 	 * fail with ENODEV, or fail with EOVERFLOW.
 	 */
 	if (expected_error == ENOTSUP &&
 	    (error == 0 || error == ENODEV || error == EOVERFLOW))
 		expected_error = error;
 
 	/*
 	 * If someone grew the LUN, the replacement may be too small.
 	 */
 	if (error == EOVERFLOW || error == EBUSY)
 		expected_error = error;
 
 	if (error == ZFS_ERR_CHECKPOINT_EXISTS ||
 	    error == ZFS_ERR_DISCARDING_CHECKPOINT ||
 	    error == ZFS_ERR_RESILVER_IN_PROGRESS ||
 	    error == ZFS_ERR_REBUILD_IN_PROGRESS)
 		expected_error = error;
 
 	if (error != expected_error && expected_error != EBUSY) {
 		fatal(B_FALSE, "attach (%s %"PRIu64", %s %"PRIu64", %d) "
 		    "returned %d, expected %d",
 		    oldpath, oldsize, newpath,
 		    newsize, replacing, error, expected_error);
 	}
 out:
 	mutex_exit(&ztest_vdev_lock);
 
 	umem_free(oldpath, MAXPATHLEN);
 	umem_free(newpath, MAXPATHLEN);
 }
 
 static void
 raidz_scratch_verify(void)
 {
 	spa_t *spa;
 	uint64_t write_size, logical_size, offset;
 	raidz_reflow_scratch_state_t state;
 	vdev_raidz_expand_t *vre;
 	vdev_t *raidvd;
 
 	ASSERT(raidz_expand_pause_point == RAIDZ_EXPAND_PAUSE_NONE);
 
 	if (ztest_scratch_state->zs_raidz_scratch_verify_pause == 0)
 		return;
 
 	kernel_init(SPA_MODE_READ);
 
 	mutex_enter(&spa_namespace_lock);
 	spa = spa_lookup(ztest_opts.zo_pool);
 	ASSERT(spa);
 	spa->spa_import_flags |= ZFS_IMPORT_SKIP_MMP;
 	mutex_exit(&spa_namespace_lock);
 
 	VERIFY0(spa_open(ztest_opts.zo_pool, &spa, FTAG));
 
 	ASSERT3U(RRSS_GET_OFFSET(&spa->spa_uberblock), !=, UINT64_MAX);
 
 	mutex_enter(&ztest_vdev_lock);
 
 	spa_config_enter(spa, SCL_ALL, FTAG, RW_READER);
 
 	vre = spa->spa_raidz_expand;
 	if (vre == NULL)
 		goto out;
 
 	raidvd = vdev_lookup_top(spa, vre->vre_vdev_id);
 	offset = RRSS_GET_OFFSET(&spa->spa_uberblock);
 	state = RRSS_GET_STATE(&spa->spa_uberblock);
 	write_size = P2ALIGN_TYPED(VDEV_BOOT_SIZE, 1 << raidvd->vdev_ashift,
 	    uint64_t);
 	logical_size = write_size * raidvd->vdev_children;
 
 	switch (state) {
 		/*
 		 * Initial state of reflow process.  RAIDZ expansion was
 		 * requested by user, but scratch object was not created.
 		 */
 		case RRSS_SCRATCH_NOT_IN_USE:
 			ASSERT3U(offset, ==, 0);
 			break;
 
 		/*
 		 * Scratch object was synced and stored in boot area.
 		 */
 		case RRSS_SCRATCH_VALID:
 
 		/*
 		 * Scratch object was synced back to raidz start offset,
 		 * raidz is ready for sector by sector reflow process.
 		 */
 		case RRSS_SCRATCH_INVALID_SYNCED:
 
 		/*
 		 * Scratch object was synced back to raidz start offset
 		 * on zpool importing, raidz is ready for sector by sector
 		 * reflow process.
 		 */
 		case RRSS_SCRATCH_INVALID_SYNCED_ON_IMPORT:
 			ASSERT3U(offset, ==, logical_size);
 			break;
 
 		/*
 		 * Sector by sector reflow process started.
 		 */
 		case RRSS_SCRATCH_INVALID_SYNCED_REFLOW:
 			ASSERT3U(offset, >=, logical_size);
 			break;
 	}
 
 out:
 	spa_config_exit(spa, SCL_ALL, FTAG);
 
 	mutex_exit(&ztest_vdev_lock);
 
 	ztest_scratch_state->zs_raidz_scratch_verify_pause = 0;
 
 	spa_close(spa, FTAG);
 	kernel_fini();
 }
 
 static void
 ztest_scratch_thread(void *arg)
 {
 	(void) arg;
 
 	/* wait up to 10 seconds */
 	for (int t = 100; t > 0; t -= 1) {
 		if (raidz_expand_pause_point == RAIDZ_EXPAND_PAUSE_NONE)
 			thread_exit();
 
 		(void) poll(NULL, 0, 100);
 	}
 
 	/* killed when the scratch area progress reached a certain point */
 	ztest_kill(ztest_shared);
 }
 
 /*
  * Verify that we can attach raidz device.
  */
 void
 ztest_vdev_raidz_attach(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	ztest_shared_t *zs = ztest_shared;
 	spa_t *spa = ztest_spa;
 	uint64_t leaves, raidz_children, newsize, ashift = ztest_get_ashift();
 	kthread_t *scratch_thread = NULL;
 	vdev_t *newvd, *pvd;
 	nvlist_t *root;
 	char *newpath = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
 	int error, expected_error = 0;
 
 	mutex_enter(&ztest_vdev_lock);
 
 	spa_config_enter(spa, SCL_ALL, FTAG, RW_READER);
 
 	/* Only allow attach when raid-kind = 'eraidz' */
 	if (!ztest_opts.zo_raid_do_expand) {
 		spa_config_exit(spa, SCL_ALL, FTAG);
 		goto out;
 	}
 
 	if (ztest_opts.zo_mmp_test) {
 		spa_config_exit(spa, SCL_ALL, FTAG);
 		goto out;
 	}
 
 	if (ztest_device_removal_active) {
 		spa_config_exit(spa, SCL_ALL, FTAG);
 		goto out;
 	}
 
 	pvd = vdev_lookup_top(spa, 0);
 
 	ASSERT(pvd->vdev_ops == &vdev_raidz_ops);
 
 	/*
 	 * Get size of a child of the raidz group,
 	 * make sure device is a bit bigger
 	 */
 	newvd = pvd->vdev_child[ztest_random(pvd->vdev_children)];
 	newsize = 10 * vdev_get_min_asize(newvd) / (9 + ztest_random(2));
 
 	/*
 	 * Get next attached leaf id
 	 */
 	raidz_children = ztest_get_raidz_children(spa);
 	leaves = MAX(zs->zs_mirrors + zs->zs_splits, 1) * raidz_children;
 	zs->zs_vdev_next_leaf = spa_num_top_vdevs(spa) * leaves;
 
 	if (spa->spa_raidz_expand)
 		expected_error = ZFS_ERR_RAIDZ_EXPAND_IN_PROGRESS;
 
 	spa_config_exit(spa, SCL_ALL, FTAG);
 
 	/*
 	 * Path to vdev to be attached
 	 */
 	(void) snprintf(newpath, MAXPATHLEN, ztest_dev_template,
 	    ztest_opts.zo_dir, ztest_opts.zo_pool, zs->zs_vdev_next_leaf);
 
 	/*
 	 * Build the nvlist describing newpath.
 	 */
 	root = make_vdev_root(newpath, NULL, NULL, newsize, ashift, NULL,
 	    0, 0, 1);
 
 	/*
 	 * 50% of the time, set raidz_expand_pause_point to cause
 	 * raidz_reflow_scratch_sync() to pause at a certain point and
 	 * then kill the test after 10 seconds so raidz_scratch_verify()
 	 * can confirm consistency when the pool is imported.
 	 */
 	if (ztest_random(2) == 0 && expected_error == 0) {
 		raidz_expand_pause_point =
 		    ztest_random(RAIDZ_EXPAND_PAUSE_SCRATCH_POST_REFLOW_2) + 1;
 		scratch_thread = thread_create(NULL, 0, ztest_scratch_thread,
 		    ztest_shared, 0, NULL, TS_RUN | TS_JOINABLE, defclsyspri);
 	}
 
 	error = spa_vdev_attach(spa, pvd->vdev_guid, root, B_FALSE, B_FALSE);
 
 	nvlist_free(root);
 
 	if (error == EOVERFLOW || error == ENXIO ||
 	    error == ZFS_ERR_CHECKPOINT_EXISTS ||
 	    error == ZFS_ERR_DISCARDING_CHECKPOINT)
 		expected_error = error;
 
 	if (error != 0 && error != expected_error) {
 		fatal(0, "raidz attach (%s %"PRIu64") returned %d, expected %d",
 		    newpath, newsize, error, expected_error);
 	}
 
 	if (raidz_expand_pause_point) {
 		if (error != 0) {
 			/*
 			 * Do not verify scratch object in case of error
 			 * returned by vdev attaching.
 			 */
 			raidz_expand_pause_point = RAIDZ_EXPAND_PAUSE_NONE;
 		}
 
 		VERIFY0(thread_join(scratch_thread));
 	}
 out:
 	mutex_exit(&ztest_vdev_lock);
 
 	umem_free(newpath, MAXPATHLEN);
 }
 
 void
 ztest_device_removal(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	spa_t *spa = ztest_spa;
 	vdev_t *vd;
 	uint64_t guid;
 	int error;
 
 	mutex_enter(&ztest_vdev_lock);
 
 	if (ztest_device_removal_active) {
 		mutex_exit(&ztest_vdev_lock);
 		return;
 	}
 
 	/*
 	 * Remove a random top-level vdev and wait for removal to finish.
 	 */
 	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
 	vd = vdev_lookup_top(spa, ztest_random_vdev_top(spa, B_FALSE));
 	guid = vd->vdev_guid;
 	spa_config_exit(spa, SCL_VDEV, FTAG);
 
 	error = spa_vdev_remove(spa, guid, B_FALSE);
 	if (error == 0) {
 		ztest_device_removal_active = B_TRUE;
 		mutex_exit(&ztest_vdev_lock);
 
 		/*
 		 * spa->spa_vdev_removal is created in a sync task that
 		 * is initiated via dsl_sync_task_nowait(). Since the
 		 * task may not run before spa_vdev_remove() returns, we
 		 * must wait at least 1 txg to ensure that the removal
 		 * struct has been created.
 		 */
 		txg_wait_synced(spa_get_dsl(spa), 0);
 
 		while (spa->spa_removing_phys.sr_state == DSS_SCANNING)
 			txg_wait_synced(spa_get_dsl(spa), 0);
 	} else {
 		mutex_exit(&ztest_vdev_lock);
 		return;
 	}
 
 	/*
 	 * The pool needs to be scrubbed after completing device removal.
 	 * Failure to do so may result in checksum errors due to the
 	 * strategy employed by ztest_fault_inject() when selecting which
 	 * offset are redundant and can be damaged.
 	 */
 	error = spa_scan(spa, POOL_SCAN_SCRUB);
 	if (error == 0) {
 		while (dsl_scan_scrubbing(spa_get_dsl(spa)))
 			txg_wait_synced(spa_get_dsl(spa), 0);
 	}
 
 	mutex_enter(&ztest_vdev_lock);
 	ztest_device_removal_active = B_FALSE;
 	mutex_exit(&ztest_vdev_lock);
 }
 
 /*
  * Callback function which expands the physical size of the vdev.
  */
 static vdev_t *
 grow_vdev(vdev_t *vd, void *arg)
 {
 	spa_t *spa __maybe_unused = vd->vdev_spa;
 	size_t *newsize = arg;
 	size_t fsize;
 	int fd;
 
 	ASSERT3S(spa_config_held(spa, SCL_STATE, RW_READER), ==, SCL_STATE);
 	ASSERT(vd->vdev_ops->vdev_op_leaf);
 
 	if ((fd = open(vd->vdev_path, O_RDWR)) == -1)
 		return (vd);
 
 	fsize = lseek(fd, 0, SEEK_END);
 	VERIFY0(ftruncate(fd, *newsize));
 
 	if (ztest_opts.zo_verbose >= 6) {
 		(void) printf("%s grew from %lu to %lu bytes\n",
 		    vd->vdev_path, (ulong_t)fsize, (ulong_t)*newsize);
 	}
 	(void) close(fd);
 	return (NULL);
 }
 
 /*
  * Callback function which expands a given vdev by calling vdev_online().
  */
 static vdev_t *
 online_vdev(vdev_t *vd, void *arg)
 {
 	(void) arg;
 	spa_t *spa = vd->vdev_spa;
 	vdev_t *tvd = vd->vdev_top;
 	uint64_t guid = vd->vdev_guid;
 	uint64_t generation = spa->spa_config_generation + 1;
 	vdev_state_t newstate = VDEV_STATE_UNKNOWN;
 	int error;
 
 	ASSERT3S(spa_config_held(spa, SCL_STATE, RW_READER), ==, SCL_STATE);
 	ASSERT(vd->vdev_ops->vdev_op_leaf);
 
 	/* Calling vdev_online will initialize the new metaslabs */
 	spa_config_exit(spa, SCL_STATE, spa);
 	error = vdev_online(spa, guid, ZFS_ONLINE_EXPAND, &newstate);
 	spa_config_enter(spa, SCL_STATE, spa, RW_READER);
 
 	/*
 	 * If vdev_online returned an error or the underlying vdev_open
 	 * failed then we abort the expand. The only way to know that
 	 * vdev_open fails is by checking the returned newstate.
 	 */
 	if (error || newstate != VDEV_STATE_HEALTHY) {
 		if (ztest_opts.zo_verbose >= 5) {
 			(void) printf("Unable to expand vdev, state %u, "
 			    "error %d\n", newstate, error);
 		}
 		return (vd);
 	}
 	ASSERT3U(newstate, ==, VDEV_STATE_HEALTHY);
 
 	/*
 	 * Since we dropped the lock we need to ensure that we're
 	 * still talking to the original vdev. It's possible this
 	 * vdev may have been detached/replaced while we were
 	 * trying to online it.
 	 */
 	if (generation != spa->spa_config_generation) {
 		if (ztest_opts.zo_verbose >= 5) {
 			(void) printf("vdev configuration has changed, "
 			    "guid %"PRIu64", state %"PRIu64", "
 			    "expected gen %"PRIu64", got gen %"PRIu64"\n",
 			    guid,
 			    tvd->vdev_state,
 			    generation,
 			    spa->spa_config_generation);
 		}
 		return (vd);
 	}
 	return (NULL);
 }
 
 /*
  * Traverse the vdev tree calling the supplied function.
  * We continue to walk the tree until we either have walked all
  * children or we receive a non-NULL return from the callback.
  * If a NULL callback is passed, then we just return back the first
  * leaf vdev we encounter.
  */
 static vdev_t *
 vdev_walk_tree(vdev_t *vd, vdev_t *(*func)(vdev_t *, void *), void *arg)
 {
 	uint_t c;
 
 	if (vd->vdev_ops->vdev_op_leaf) {
 		if (func == NULL)
 			return (vd);
 		else
 			return (func(vd, arg));
 	}
 
 	for (c = 0; c < vd->vdev_children; c++) {
 		vdev_t *cvd = vd->vdev_child[c];
 		if ((cvd = vdev_walk_tree(cvd, func, arg)) != NULL)
 			return (cvd);
 	}
 	return (NULL);
 }
 
 /*
  * Verify that dynamic LUN growth works as expected.
  */
 void
 ztest_vdev_LUN_growth(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	spa_t *spa = ztest_spa;
 	vdev_t *vd, *tvd;
 	metaslab_class_t *mc;
 	metaslab_group_t *mg;
 	size_t psize, newsize;
 	uint64_t top;
 	uint64_t old_class_space, new_class_space, old_ms_count, new_ms_count;
 
 	mutex_enter(&ztest_checkpoint_lock);
 	mutex_enter(&ztest_vdev_lock);
 	spa_config_enter(spa, SCL_STATE, spa, RW_READER);
 
 	/*
 	 * If there is a vdev removal in progress, it could complete while
 	 * we are running, in which case we would not be able to verify
 	 * that the metaslab_class space increased (because it decreases
 	 * when the device removal completes).
 	 */
 	if (ztest_device_removal_active) {
 		spa_config_exit(spa, SCL_STATE, spa);
 		mutex_exit(&ztest_vdev_lock);
 		mutex_exit(&ztest_checkpoint_lock);
 		return;
 	}
 
 	/*
 	 * If we are under raidz expansion, the test can failed because the
 	 * metaslabs count will not increase immediately after the vdev is
 	 * expanded. It will happen only after raidz expansion completion.
 	 */
 	if (spa->spa_raidz_expand) {
 		spa_config_exit(spa, SCL_STATE, spa);
 		mutex_exit(&ztest_vdev_lock);
 		mutex_exit(&ztest_checkpoint_lock);
 		return;
 	}
 
 	top = ztest_random_vdev_top(spa, B_TRUE);
 
 	tvd = spa->spa_root_vdev->vdev_child[top];
 	mg = tvd->vdev_mg;
 	mc = mg->mg_class;
 	old_ms_count = tvd->vdev_ms_count;
 	old_class_space = metaslab_class_get_space(mc);
 
 	/*
 	 * Determine the size of the first leaf vdev associated with
 	 * our top-level device.
 	 */
 	vd = vdev_walk_tree(tvd, NULL, NULL);
 	ASSERT3P(vd, !=, NULL);
 	ASSERT(vd->vdev_ops->vdev_op_leaf);
 
 	psize = vd->vdev_psize;
 
 	/*
 	 * We only try to expand the vdev if it's healthy, less than 4x its
 	 * original size, and it has a valid psize.
 	 */
 	if (tvd->vdev_state != VDEV_STATE_HEALTHY ||
 	    psize == 0 || psize >= 4 * ztest_opts.zo_vdev_size) {
 		spa_config_exit(spa, SCL_STATE, spa);
 		mutex_exit(&ztest_vdev_lock);
 		mutex_exit(&ztest_checkpoint_lock);
 		return;
 	}
 	ASSERT3U(psize, >, 0);
 	newsize = psize + MAX(psize / 8, SPA_MAXBLOCKSIZE);
 	ASSERT3U(newsize, >, psize);
 
 	if (ztest_opts.zo_verbose >= 6) {
 		(void) printf("Expanding LUN %s from %lu to %lu\n",
 		    vd->vdev_path, (ulong_t)psize, (ulong_t)newsize);
 	}
 
 	/*
 	 * Growing the vdev is a two step process:
 	 *	1). expand the physical size (i.e. relabel)
 	 *	2). online the vdev to create the new metaslabs
 	 */
 	if (vdev_walk_tree(tvd, grow_vdev, &newsize) != NULL ||
 	    vdev_walk_tree(tvd, online_vdev, NULL) != NULL ||
 	    tvd->vdev_state != VDEV_STATE_HEALTHY) {
 		if (ztest_opts.zo_verbose >= 5) {
 			(void) printf("Could not expand LUN because "
 			    "the vdev configuration changed.\n");
 		}
 		spa_config_exit(spa, SCL_STATE, spa);
 		mutex_exit(&ztest_vdev_lock);
 		mutex_exit(&ztest_checkpoint_lock);
 		return;
 	}
 
 	spa_config_exit(spa, SCL_STATE, spa);
 
 	/*
 	 * Expanding the LUN will update the config asynchronously,
 	 * thus we must wait for the async thread to complete any
 	 * pending tasks before proceeding.
 	 */
 	for (;;) {
 		boolean_t done;
 		mutex_enter(&spa->spa_async_lock);
 		done = (spa->spa_async_thread == NULL && !spa->spa_async_tasks);
 		mutex_exit(&spa->spa_async_lock);
 		if (done)
 			break;
 		txg_wait_synced(spa_get_dsl(spa), 0);
 		(void) poll(NULL, 0, 100);
 	}
 
 	spa_config_enter(spa, SCL_STATE, spa, RW_READER);
 
 	tvd = spa->spa_root_vdev->vdev_child[top];
 	new_ms_count = tvd->vdev_ms_count;
 	new_class_space = metaslab_class_get_space(mc);
 
 	if (tvd->vdev_mg != mg || mg->mg_class != mc) {
 		if (ztest_opts.zo_verbose >= 5) {
 			(void) printf("Could not verify LUN expansion due to "
 			    "intervening vdev offline or remove.\n");
 		}
 		spa_config_exit(spa, SCL_STATE, spa);
 		mutex_exit(&ztest_vdev_lock);
 		mutex_exit(&ztest_checkpoint_lock);
 		return;
 	}
 
 	/*
 	 * Make sure we were able to grow the vdev.
 	 */
 	if (new_ms_count <= old_ms_count) {
 		fatal(B_FALSE,
 		    "LUN expansion failed: ms_count %"PRIu64" < %"PRIu64"\n",
 		    old_ms_count, new_ms_count);
 	}
 
 	/*
 	 * Make sure we were able to grow the pool.
 	 */
 	if (new_class_space <= old_class_space) {
 		fatal(B_FALSE,
 		    "LUN expansion failed: class_space %"PRIu64" < %"PRIu64"\n",
 		    old_class_space, new_class_space);
 	}
 
 	if (ztest_opts.zo_verbose >= 5) {
 		char oldnumbuf[NN_NUMBUF_SZ], newnumbuf[NN_NUMBUF_SZ];
 
 		nicenum(old_class_space, oldnumbuf, sizeof (oldnumbuf));
 		nicenum(new_class_space, newnumbuf, sizeof (newnumbuf));
 		(void) printf("%s grew from %s to %s\n",
 		    spa->spa_name, oldnumbuf, newnumbuf);
 	}
 
 	spa_config_exit(spa, SCL_STATE, spa);
 	mutex_exit(&ztest_vdev_lock);
 	mutex_exit(&ztest_checkpoint_lock);
 }
 
 /*
  * Verify that dmu_objset_{create,destroy,open,close} work as expected.
  */
 static void
 ztest_objset_create_cb(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx)
 {
 	(void) arg, (void) cr;
 
 	/*
 	 * Create the objects common to all ztest datasets.
 	 */
 	VERIFY0(zap_create_claim(os, ZTEST_DIROBJ,
 	    DMU_OT_ZAP_OTHER, DMU_OT_NONE, 0, tx));
 }
 
 static int
 ztest_dataset_create(char *dsname)
 {
 	int err;
 	uint64_t rand;
 	dsl_crypto_params_t *dcp = NULL;
 
 	/*
 	 * 50% of the time, we create encrypted datasets
 	 * using a random cipher suite and a hard-coded
 	 * wrapping key.
 	 */
 	rand = ztest_random(2);
 	if (rand != 0) {
 		nvlist_t *crypto_args = fnvlist_alloc();
 		nvlist_t *props = fnvlist_alloc();
 
 		/* slight bias towards the default cipher suite */
 		rand = ztest_random(ZIO_CRYPT_FUNCTIONS);
 		if (rand < ZIO_CRYPT_AES_128_CCM)
 			rand = ZIO_CRYPT_ON;
 
 		fnvlist_add_uint64(props,
 		    zfs_prop_to_name(ZFS_PROP_ENCRYPTION), rand);
 		fnvlist_add_uint8_array(crypto_args, "wkeydata",
 		    (uint8_t *)ztest_wkeydata, WRAPPING_KEY_LEN);
 
 		/*
 		 * These parameters aren't really used by the kernel. They
 		 * are simply stored so that userspace knows how to load
 		 * the wrapping key.
 		 */
 		fnvlist_add_uint64(props,
 		    zfs_prop_to_name(ZFS_PROP_KEYFORMAT), ZFS_KEYFORMAT_RAW);
 		fnvlist_add_string(props,
 		    zfs_prop_to_name(ZFS_PROP_KEYLOCATION), "prompt");
 		fnvlist_add_uint64(props,
 		    zfs_prop_to_name(ZFS_PROP_PBKDF2_SALT), 0ULL);
 		fnvlist_add_uint64(props,
 		    zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), 0ULL);
 
 		VERIFY0(dsl_crypto_params_create_nvlist(DCP_CMD_NONE, props,
 		    crypto_args, &dcp));
 
 		/*
 		 * Cycle through all available encryption implementations
 		 * to verify interoperability.
 		 */
 		VERIFY0(gcm_impl_set("cycle"));
 		VERIFY0(aes_impl_set("cycle"));
 
 		fnvlist_free(crypto_args);
 		fnvlist_free(props);
 	}
 
 	err = dmu_objset_create(dsname, DMU_OST_OTHER, 0, dcp,
 	    ztest_objset_create_cb, NULL);
 	dsl_crypto_params_free(dcp, !!err);
 
 	rand = ztest_random(100);
 	if (err || rand < 80)
 		return (err);
 
 	if (ztest_opts.zo_verbose >= 5)
 		(void) printf("Setting dataset %s to sync always\n", dsname);
 	return (ztest_dsl_prop_set_uint64(dsname, ZFS_PROP_SYNC,
 	    ZFS_SYNC_ALWAYS, B_FALSE));
 }
 
 static int
 ztest_objset_destroy_cb(const char *name, void *arg)
 {
 	(void) arg;
 	objset_t *os;
 	dmu_object_info_t doi;
 	int error;
 
 	/*
 	 * Verify that the dataset contains a directory object.
 	 */
 	VERIFY0(ztest_dmu_objset_own(name, DMU_OST_OTHER, B_TRUE,
 	    B_TRUE, FTAG, &os));
 	error = dmu_object_info(os, ZTEST_DIROBJ, &doi);
 	if (error != ENOENT) {
 		/* We could have crashed in the middle of destroying it */
 		ASSERT0(error);
 		ASSERT3U(doi.doi_type, ==, DMU_OT_ZAP_OTHER);
 		ASSERT3S(doi.doi_physical_blocks_512, >=, 0);
 	}
 	dmu_objset_disown(os, B_TRUE, FTAG);
 
 	/*
 	 * Destroy the dataset.
 	 */
 	if (strchr(name, '@') != NULL) {
 		error = dsl_destroy_snapshot(name, B_TRUE);
 		if (error != ECHRNG) {
 			/*
 			 * The program was executed, but encountered a runtime
 			 * error, such as insufficient slop, or a hold on the
 			 * dataset.
 			 */
 			ASSERT0(error);
 		}
 	} else {
 		error = dsl_destroy_head(name);
 		if (error == ENOSPC) {
 			/* There could be checkpoint or insufficient slop */
 			ztest_record_enospc(FTAG);
 		} else if (error != EBUSY) {
 			/* There could be a hold on this dataset */
 			ASSERT0(error);
 		}
 	}
 	return (0);
 }
 
 static boolean_t
 ztest_snapshot_create(char *osname, uint64_t id)
 {
 	char snapname[ZFS_MAX_DATASET_NAME_LEN];
 	int error;
 
 	(void) snprintf(snapname, sizeof (snapname), "%"PRIu64"", id);
 
 	error = dmu_objset_snapshot_one(osname, snapname);
 	if (error == ENOSPC) {
 		ztest_record_enospc(FTAG);
 		return (B_FALSE);
 	}
 	if (error != 0 && error != EEXIST && error != ECHRNG) {
 		fatal(B_FALSE, "ztest_snapshot_create(%s@%s) = %d", osname,
 		    snapname, error);
 	}
 	return (B_TRUE);
 }
 
 static boolean_t
 ztest_snapshot_destroy(char *osname, uint64_t id)
 {
 	char snapname[ZFS_MAX_DATASET_NAME_LEN];
 	int error;
 
 	(void) snprintf(snapname, sizeof (snapname), "%s@%"PRIu64"",
 	    osname, id);
 
 	error = dsl_destroy_snapshot(snapname, B_FALSE);
 	if (error != 0 && error != ENOENT && error != ECHRNG)
 		fatal(B_FALSE, "ztest_snapshot_destroy(%s) = %d",
 		    snapname, error);
 	return (B_TRUE);
 }
 
 void
 ztest_dmu_objset_create_destroy(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd;
 	ztest_ds_t *zdtmp;
 	int iters;
 	int error;
 	objset_t *os, *os2;
 	char name[ZFS_MAX_DATASET_NAME_LEN];
 	zilog_t *zilog;
 	int i;
 
 	zdtmp = umem_alloc(sizeof (ztest_ds_t), UMEM_NOFAIL);
 
 	(void) pthread_rwlock_rdlock(&ztest_name_lock);
 
 	(void) snprintf(name, sizeof (name), "%s/temp_%"PRIu64"",
 	    ztest_opts.zo_pool, id);
 
 	/*
 	 * If this dataset exists from a previous run, process its replay log
 	 * half of the time.  If we don't replay it, then dsl_destroy_head()
 	 * (invoked from ztest_objset_destroy_cb()) should just throw it away.
 	 */
 	if (ztest_random(2) == 0 &&
 	    ztest_dmu_objset_own(name, DMU_OST_OTHER, B_FALSE,
 	    B_TRUE, FTAG, &os) == 0) {
 		ztest_zd_init(zdtmp, NULL, os);
 		zil_replay(os, zdtmp, ztest_replay_vector);
 		ztest_zd_fini(zdtmp);
 		dmu_objset_disown(os, B_TRUE, FTAG);
 	}
 
 	/*
 	 * There may be an old instance of the dataset we're about to
 	 * create lying around from a previous run.  If so, destroy it
 	 * and all of its snapshots.
 	 */
 	(void) dmu_objset_find(name, ztest_objset_destroy_cb, NULL,
 	    DS_FIND_CHILDREN | DS_FIND_SNAPSHOTS);
 
 	/*
 	 * Verify that the destroyed dataset is no longer in the namespace.
 	 * It may still be present if the destroy above fails with ENOSPC.
 	 */
 	error = ztest_dmu_objset_own(name, DMU_OST_OTHER, B_TRUE, B_TRUE,
 	    FTAG, &os);
 	if (error == 0) {
 		dmu_objset_disown(os, B_TRUE, FTAG);
 		ztest_record_enospc(FTAG);
 		goto out;
 	}
 	VERIFY3U(ENOENT, ==, error);
 
 	/*
 	 * Verify that we can create a new dataset.
 	 */
 	error = ztest_dataset_create(name);
 	if (error) {
 		if (error == ENOSPC) {
 			ztest_record_enospc(FTAG);
 			goto out;
 		}
 		fatal(B_FALSE, "dmu_objset_create(%s) = %d", name, error);
 	}
 
 	VERIFY0(ztest_dmu_objset_own(name, DMU_OST_OTHER, B_FALSE, B_TRUE,
 	    FTAG, &os));
 
 	ztest_zd_init(zdtmp, NULL, os);
 
 	/*
 	 * Open the intent log for it.
 	 */
 	zilog = zil_open(os, ztest_get_data, NULL);
 
 	/*
 	 * Put some objects in there, do a little I/O to them,
 	 * and randomly take a couple of snapshots along the way.
 	 */
 	iters = ztest_random(5);
 	for (i = 0; i < iters; i++) {
 		ztest_dmu_object_alloc_free(zdtmp, id);
 		if (ztest_random(iters) == 0)
 			(void) ztest_snapshot_create(name, i);
 	}
 
 	/*
 	 * Verify that we cannot create an existing dataset.
 	 */
 	VERIFY3U(EEXIST, ==,
 	    dmu_objset_create(name, DMU_OST_OTHER, 0, NULL, NULL, NULL));
 
 	/*
 	 * Verify that we can hold an objset that is also owned.
 	 */
 	VERIFY0(dmu_objset_hold(name, FTAG, &os2));
 	dmu_objset_rele(os2, FTAG);
 
 	/*
 	 * Verify that we cannot own an objset that is already owned.
 	 */
 	VERIFY3U(EBUSY, ==, ztest_dmu_objset_own(name, DMU_OST_OTHER,
 	    B_FALSE, B_TRUE, FTAG, &os2));
 
 	zil_close(zilog);
 	dmu_objset_disown(os, B_TRUE, FTAG);
 	ztest_zd_fini(zdtmp);
 out:
 	(void) pthread_rwlock_unlock(&ztest_name_lock);
 
 	umem_free(zdtmp, sizeof (ztest_ds_t));
 }
 
 /*
  * Verify that dmu_snapshot_{create,destroy,open,close} work as expected.
  */
 void
 ztest_dmu_snapshot_create_destroy(ztest_ds_t *zd, uint64_t id)
 {
 	(void) pthread_rwlock_rdlock(&ztest_name_lock);
 	(void) ztest_snapshot_destroy(zd->zd_name, id);
 	(void) ztest_snapshot_create(zd->zd_name, id);
 	(void) pthread_rwlock_unlock(&ztest_name_lock);
 }
 
 /*
  * Cleanup non-standard snapshots and clones.
  */
 static void
 ztest_dsl_dataset_cleanup(char *osname, uint64_t id)
 {
 	char *snap1name;
 	char *clone1name;
 	char *snap2name;
 	char *clone2name;
 	char *snap3name;
 	int error;
 
 	snap1name  = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);
 	clone1name = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);
 	snap2name  = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);
 	clone2name = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);
 	snap3name  = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);
 
 	(void) snprintf(snap1name, ZFS_MAX_DATASET_NAME_LEN, "%s@s1_%"PRIu64"",
 	    osname, id);
 	(void) snprintf(clone1name, ZFS_MAX_DATASET_NAME_LEN, "%s/c1_%"PRIu64"",
 	    osname, id);
 	(void) snprintf(snap2name, ZFS_MAX_DATASET_NAME_LEN, "%s@s2_%"PRIu64"",
 	    clone1name, id);
 	(void) snprintf(clone2name, ZFS_MAX_DATASET_NAME_LEN, "%s/c2_%"PRIu64"",
 	    osname, id);
 	(void) snprintf(snap3name, ZFS_MAX_DATASET_NAME_LEN, "%s@s3_%"PRIu64"",
 	    clone1name, id);
 
 	error = dsl_destroy_head(clone2name);
 	if (error && error != ENOENT)
 		fatal(B_FALSE, "dsl_destroy_head(%s) = %d", clone2name, error);
 	error = dsl_destroy_snapshot(snap3name, B_FALSE);
 	if (error && error != ENOENT)
 		fatal(B_FALSE, "dsl_destroy_snapshot(%s) = %d",
 		    snap3name, error);
 	error = dsl_destroy_snapshot(snap2name, B_FALSE);
 	if (error && error != ENOENT)
 		fatal(B_FALSE, "dsl_destroy_snapshot(%s) = %d",
 		    snap2name, error);
 	error = dsl_destroy_head(clone1name);
 	if (error && error != ENOENT)
 		fatal(B_FALSE, "dsl_destroy_head(%s) = %d", clone1name, error);
 	error = dsl_destroy_snapshot(snap1name, B_FALSE);
 	if (error && error != ENOENT)
 		fatal(B_FALSE, "dsl_destroy_snapshot(%s) = %d",
 		    snap1name, error);
 
 	umem_free(snap1name, ZFS_MAX_DATASET_NAME_LEN);
 	umem_free(clone1name, ZFS_MAX_DATASET_NAME_LEN);
 	umem_free(snap2name, ZFS_MAX_DATASET_NAME_LEN);
 	umem_free(clone2name, ZFS_MAX_DATASET_NAME_LEN);
 	umem_free(snap3name, ZFS_MAX_DATASET_NAME_LEN);
 }
 
 /*
  * Verify dsl_dataset_promote handles EBUSY
  */
 void
 ztest_dsl_dataset_promote_busy(ztest_ds_t *zd, uint64_t id)
 {
 	objset_t *os;
 	char *snap1name;
 	char *clone1name;
 	char *snap2name;
 	char *clone2name;
 	char *snap3name;
 	char *osname = zd->zd_name;
 	int error;
 
 	snap1name  = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);
 	clone1name = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);
 	snap2name  = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);
 	clone2name = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);
 	snap3name  = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);
 
 	(void) pthread_rwlock_rdlock(&ztest_name_lock);
 
 	ztest_dsl_dataset_cleanup(osname, id);
 
 	(void) snprintf(snap1name, ZFS_MAX_DATASET_NAME_LEN, "%s@s1_%"PRIu64"",
 	    osname, id);
 	(void) snprintf(clone1name, ZFS_MAX_DATASET_NAME_LEN, "%s/c1_%"PRIu64"",
 	    osname, id);
 	(void) snprintf(snap2name, ZFS_MAX_DATASET_NAME_LEN, "%s@s2_%"PRIu64"",
 	    clone1name, id);
 	(void) snprintf(clone2name, ZFS_MAX_DATASET_NAME_LEN, "%s/c2_%"PRIu64"",
 	    osname, id);
 	(void) snprintf(snap3name, ZFS_MAX_DATASET_NAME_LEN, "%s@s3_%"PRIu64"",
 	    clone1name, id);
 
 	error = dmu_objset_snapshot_one(osname, strchr(snap1name, '@') + 1);
 	if (error && error != EEXIST) {
 		if (error == ENOSPC) {
 			ztest_record_enospc(FTAG);
 			goto out;
 		}
 		fatal(B_FALSE, "dmu_take_snapshot(%s) = %d", snap1name, error);
 	}
 
 	error = dmu_objset_clone(clone1name, snap1name);
 	if (error) {
 		if (error == ENOSPC) {
 			ztest_record_enospc(FTAG);
 			goto out;
 		}
 		fatal(B_FALSE, "dmu_objset_create(%s) = %d", clone1name, error);
 	}
 
 	error = dmu_objset_snapshot_one(clone1name, strchr(snap2name, '@') + 1);
 	if (error && error != EEXIST) {
 		if (error == ENOSPC) {
 			ztest_record_enospc(FTAG);
 			goto out;
 		}
 		fatal(B_FALSE, "dmu_open_snapshot(%s) = %d", snap2name, error);
 	}
 
 	error = dmu_objset_snapshot_one(clone1name, strchr(snap3name, '@') + 1);
 	if (error && error != EEXIST) {
 		if (error == ENOSPC) {
 			ztest_record_enospc(FTAG);
 			goto out;
 		}
 		fatal(B_FALSE, "dmu_open_snapshot(%s) = %d", snap3name, error);
 	}
 
 	error = dmu_objset_clone(clone2name, snap3name);
 	if (error) {
 		if (error == ENOSPC) {
 			ztest_record_enospc(FTAG);
 			goto out;
 		}
 		fatal(B_FALSE, "dmu_objset_create(%s) = %d", clone2name, error);
 	}
 
 	error = ztest_dmu_objset_own(snap2name, DMU_OST_ANY, B_TRUE, B_TRUE,
 	    FTAG, &os);
 	if (error)
 		fatal(B_FALSE, "dmu_objset_own(%s) = %d", snap2name, error);
 	error = dsl_dataset_promote(clone2name, NULL);
 	if (error == ENOSPC) {
 		dmu_objset_disown(os, B_TRUE, FTAG);
 		ztest_record_enospc(FTAG);
 		goto out;
 	}
 	if (error != EBUSY)
 		fatal(B_FALSE, "dsl_dataset_promote(%s), %d, not EBUSY",
 		    clone2name, error);
 	dmu_objset_disown(os, B_TRUE, FTAG);
 
 out:
 	ztest_dsl_dataset_cleanup(osname, id);
 
 	(void) pthread_rwlock_unlock(&ztest_name_lock);
 
 	umem_free(snap1name, ZFS_MAX_DATASET_NAME_LEN);
 	umem_free(clone1name, ZFS_MAX_DATASET_NAME_LEN);
 	umem_free(snap2name, ZFS_MAX_DATASET_NAME_LEN);
 	umem_free(clone2name, ZFS_MAX_DATASET_NAME_LEN);
 	umem_free(snap3name, ZFS_MAX_DATASET_NAME_LEN);
 }
 
 #undef OD_ARRAY_SIZE
 #define	OD_ARRAY_SIZE	4
 
 /*
  * Verify that dmu_object_{alloc,free} work as expected.
  */
 void
 ztest_dmu_object_alloc_free(ztest_ds_t *zd, uint64_t id)
 {
 	ztest_od_t *od;
 	int batchsize;
 	int size;
 	int b;
 
 	size = sizeof (ztest_od_t) * OD_ARRAY_SIZE;
 	od = umem_alloc(size, UMEM_NOFAIL);
 	batchsize = OD_ARRAY_SIZE;
 
 	for (b = 0; b < batchsize; b++)
 		ztest_od_init(od + b, id, FTAG, b, DMU_OT_UINT64_OTHER,
 		    0, 0, 0);
 
 	/*
 	 * Destroy the previous batch of objects, create a new batch,
 	 * and do some I/O on the new objects.
 	 */
 	if (ztest_object_init(zd, od, size, B_TRUE) != 0) {
 		zd->zd_od = NULL;
 		umem_free(od, size);
 		return;
 	}
 
 	while (ztest_random(4 * batchsize) != 0)
 		ztest_io(zd, od[ztest_random(batchsize)].od_object,
 		    ztest_random(ZTEST_RANGE_LOCKS) << SPA_MAXBLOCKSHIFT);
 
 	umem_free(od, size);
 }
 
 /*
  * Rewind the global allocator to verify object allocation backfilling.
  */
 void
 ztest_dmu_object_next_chunk(ztest_ds_t *zd, uint64_t id)
 {
 	(void) id;
 	objset_t *os = zd->zd_os;
 	uint_t dnodes_per_chunk = 1 << dmu_object_alloc_chunk_shift;
 	uint64_t object;
 
 	/*
 	 * Rewind the global allocator randomly back to a lower object number
 	 * to force backfilling and reclamation of recently freed dnodes.
 	 */
 	mutex_enter(&os->os_obj_lock);
 	object = ztest_random(os->os_obj_next_chunk);
 	os->os_obj_next_chunk = P2ALIGN_TYPED(object, dnodes_per_chunk,
 	    uint64_t);
 	mutex_exit(&os->os_obj_lock);
 }
 
 #undef OD_ARRAY_SIZE
 #define	OD_ARRAY_SIZE	2
 
 /*
  * Verify that dmu_{read,write} work as expected.
  */
 void
 ztest_dmu_read_write(ztest_ds_t *zd, uint64_t id)
 {
 	int size;
 	ztest_od_t *od;
 
 	objset_t *os = zd->zd_os;
 	size = sizeof (ztest_od_t) * OD_ARRAY_SIZE;
 	od = umem_alloc(size, UMEM_NOFAIL);
 	dmu_tx_t *tx;
 	int freeit, error;
 	uint64_t i, n, s, txg;
 	bufwad_t *packbuf, *bigbuf, *pack, *bigH, *bigT;
 	uint64_t packobj, packoff, packsize, bigobj, bigoff, bigsize;
 	uint64_t chunksize = (1000 + ztest_random(1000)) * sizeof (uint64_t);
 	uint64_t regions = 997;
 	uint64_t stride = 123456789ULL;
 	uint64_t width = 40;
 	int free_percent = 5;
 	uint32_t dmu_read_flags = DMU_READ_PREFETCH;
 
 	/*
 	 * We will randomly set when to do O_DIRECT on a read.
 	 */
 	if (ztest_random(4) == 0)
 		dmu_read_flags |= DMU_DIRECTIO;
 
 	/*
 	 * This test uses two objects, packobj and bigobj, that are always
 	 * updated together (i.e. in the same tx) so that their contents are
 	 * in sync and can be compared.  Their contents relate to each other
 	 * in a simple way: packobj is a dense array of 'bufwad' structures,
 	 * while bigobj is a sparse array of the same bufwads.  Specifically,
 	 * for any index n, there are three bufwads that should be identical:
 	 *
 	 *	packobj, at offset n * sizeof (bufwad_t)
 	 *	bigobj, at the head of the nth chunk
 	 *	bigobj, at the tail of the nth chunk
 	 *
 	 * The chunk size is arbitrary. It doesn't have to be a power of two,
 	 * and it doesn't have any relation to the object blocksize.
 	 * The only requirement is that it can hold at least two bufwads.
 	 *
 	 * Normally, we write the bufwad to each of these locations.
 	 * However, free_percent of the time we instead write zeroes to
 	 * packobj and perform a dmu_free_range() on bigobj.  By comparing
 	 * bigobj to packobj, we can verify that the DMU is correctly
 	 * tracking which parts of an object are allocated and free,
 	 * and that the contents of the allocated blocks are correct.
 	 */
 
 	/*
 	 * Read the directory info.  If it's the first time, set things up.
 	 */
 	ztest_od_init(od, id, FTAG, 0, DMU_OT_UINT64_OTHER, 0, 0, chunksize);
 	ztest_od_init(od + 1, id, FTAG, 1, DMU_OT_UINT64_OTHER, 0, 0,
 	    chunksize);
 
 	if (ztest_object_init(zd, od, size, B_FALSE) != 0) {
 		umem_free(od, size);
 		return;
 	}
 
 	bigobj = od[0].od_object;
 	packobj = od[1].od_object;
 	chunksize = od[0].od_gen;
 	ASSERT3U(chunksize, ==, od[1].od_gen);
 
 	/*
 	 * Prefetch a random chunk of the big object.
 	 * Our aim here is to get some async reads in flight
 	 * for blocks that we may free below; the DMU should
 	 * handle this race correctly.
 	 */
 	n = ztest_random(regions) * stride + ztest_random(width);
 	s = 1 + ztest_random(2 * width - 1);
 	dmu_prefetch(os, bigobj, 0, n * chunksize, s * chunksize,
 	    ZIO_PRIORITY_SYNC_READ);
 
 	/*
 	 * Pick a random index and compute the offsets into packobj and bigobj.
 	 */
 	n = ztest_random(regions) * stride + ztest_random(width);
 	s = 1 + ztest_random(width - 1);
 
 	packoff = n * sizeof (bufwad_t);
 	packsize = s * sizeof (bufwad_t);
 
 	bigoff = n * chunksize;
 	bigsize = s * chunksize;
 
 	packbuf = umem_alloc(packsize, UMEM_NOFAIL);
 	bigbuf = umem_alloc(bigsize, UMEM_NOFAIL);
 
 	/*
 	 * free_percent of the time, free a range of bigobj rather than
 	 * overwriting it.
 	 */
 	freeit = (ztest_random(100) < free_percent);
 
 	/*
 	 * Read the current contents of our objects.
 	 */
 	error = dmu_read(os, packobj, packoff, packsize, packbuf,
 	    dmu_read_flags);
 	ASSERT0(error);
 	error = dmu_read(os, bigobj, bigoff, bigsize, bigbuf,
 	    dmu_read_flags);
 	ASSERT0(error);
 
 	/*
 	 * Get a tx for the mods to both packobj and bigobj.
 	 */
 	tx = dmu_tx_create(os);
 
 	dmu_tx_hold_write(tx, packobj, packoff, packsize);
 
 	if (freeit)
 		dmu_tx_hold_free(tx, bigobj, bigoff, bigsize);
 	else
 		dmu_tx_hold_write(tx, bigobj, bigoff, bigsize);
 
 	/* This accounts for setting the checksum/compression. */
 	dmu_tx_hold_bonus(tx, bigobj);
 
 	txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
 	if (txg == 0) {
 		umem_free(packbuf, packsize);
 		umem_free(bigbuf, bigsize);
 		umem_free(od, size);
 		return;
 	}
 
 	enum zio_checksum cksum;
 	do {
 		cksum = (enum zio_checksum)
 		    ztest_random_dsl_prop(ZFS_PROP_CHECKSUM);
 	} while (cksum >= ZIO_CHECKSUM_LEGACY_FUNCTIONS);
 	dmu_object_set_checksum(os, bigobj, cksum, tx);
 
 	enum zio_compress comp;
 	do {
 		comp = (enum zio_compress)
 		    ztest_random_dsl_prop(ZFS_PROP_COMPRESSION);
 	} while (comp >= ZIO_COMPRESS_LEGACY_FUNCTIONS);
 	dmu_object_set_compress(os, bigobj, comp, tx);
 
 	/*
 	 * For each index from n to n + s, verify that the existing bufwad
 	 * in packobj matches the bufwads at the head and tail of the
 	 * corresponding chunk in bigobj.  Then update all three bufwads
 	 * with the new values we want to write out.
 	 */
 	for (i = 0; i < s; i++) {
 		/* LINTED */
 		pack = (bufwad_t *)((char *)packbuf + i * sizeof (bufwad_t));
 		/* LINTED */
 		bigH = (bufwad_t *)((char *)bigbuf + i * chunksize);
 		/* LINTED */
 		bigT = (bufwad_t *)((char *)bigH + chunksize) - 1;
 
 		ASSERT3U((uintptr_t)bigH - (uintptr_t)bigbuf, <, bigsize);
 		ASSERT3U((uintptr_t)bigT - (uintptr_t)bigbuf, <, bigsize);
 
 		if (pack->bw_txg > txg)
 			fatal(B_FALSE,
 			    "future leak: got %"PRIx64", open txg is %"PRIx64"",
 			    pack->bw_txg, txg);
 
 		if (pack->bw_data != 0 && pack->bw_index != n + i)
 			fatal(B_FALSE, "wrong index: "
 			    "got %"PRIx64", wanted %"PRIx64"+%"PRIx64"",
 			    pack->bw_index, n, i);
 
 		if (memcmp(pack, bigH, sizeof (bufwad_t)) != 0)
 			fatal(B_FALSE, "pack/bigH mismatch in %p/%p",
 			    pack, bigH);
 
 		if (memcmp(pack, bigT, sizeof (bufwad_t)) != 0)
 			fatal(B_FALSE, "pack/bigT mismatch in %p/%p",
 			    pack, bigT);
 
 		if (freeit) {
 			memset(pack, 0, sizeof (bufwad_t));
 		} else {
 			pack->bw_index = n + i;
 			pack->bw_txg = txg;
 			pack->bw_data = 1 + ztest_random(-2ULL);
 		}
 		*bigH = *pack;
 		*bigT = *pack;
 	}
 
 	/*
 	 * We've verified all the old bufwads, and made new ones.
 	 * Now write them out.
 	 */
 	dmu_write(os, packobj, packoff, packsize, packbuf, tx);
 
 	if (freeit) {
 		if (ztest_opts.zo_verbose >= 7) {
 			(void) printf("freeing offset %"PRIx64" size %"PRIx64""
 			    " txg %"PRIx64"\n",
 			    bigoff, bigsize, txg);
 		}
 		VERIFY0(dmu_free_range(os, bigobj, bigoff, bigsize, tx));
 	} else {
 		if (ztest_opts.zo_verbose >= 7) {
 			(void) printf("writing offset %"PRIx64" size %"PRIx64""
 			    " txg %"PRIx64"\n",
 			    bigoff, bigsize, txg);
 		}
 		dmu_write(os, bigobj, bigoff, bigsize, bigbuf, tx);
 	}
 
 	dmu_tx_commit(tx);
 
 	/*
 	 * Sanity check the stuff we just wrote.
 	 */
 	{
 		void *packcheck = umem_alloc(packsize, UMEM_NOFAIL);
 		void *bigcheck = umem_alloc(bigsize, UMEM_NOFAIL);
 
 		VERIFY0(dmu_read(os, packobj, packoff,
 		    packsize, packcheck, dmu_read_flags));
 		VERIFY0(dmu_read(os, bigobj, bigoff,
 		    bigsize, bigcheck, dmu_read_flags));
 
 		ASSERT0(memcmp(packbuf, packcheck, packsize));
 		ASSERT0(memcmp(bigbuf, bigcheck, bigsize));
 
 		umem_free(packcheck, packsize);
 		umem_free(bigcheck, bigsize);
 	}
 
 	umem_free(packbuf, packsize);
 	umem_free(bigbuf, bigsize);
 	umem_free(od, size);
 }
 
 static void
 compare_and_update_pbbufs(uint64_t s, bufwad_t *packbuf, bufwad_t *bigbuf,
     uint64_t bigsize, uint64_t n, uint64_t chunksize, uint64_t txg)
 {
 	uint64_t i;
 	bufwad_t *pack;
 	bufwad_t *bigH;
 	bufwad_t *bigT;
 
 	/*
 	 * For each index from n to n + s, verify that the existing bufwad
 	 * in packobj matches the bufwads at the head and tail of the
 	 * corresponding chunk in bigobj.  Then update all three bufwads
 	 * with the new values we want to write out.
 	 */
 	for (i = 0; i < s; i++) {
 		/* LINTED */
 		pack = (bufwad_t *)((char *)packbuf + i * sizeof (bufwad_t));
 		/* LINTED */
 		bigH = (bufwad_t *)((char *)bigbuf + i * chunksize);
 		/* LINTED */
 		bigT = (bufwad_t *)((char *)bigH + chunksize) - 1;
 
 		ASSERT3U((uintptr_t)bigH - (uintptr_t)bigbuf, <, bigsize);
 		ASSERT3U((uintptr_t)bigT - (uintptr_t)bigbuf, <, bigsize);
 
 		if (pack->bw_txg > txg)
 			fatal(B_FALSE,
 			    "future leak: got %"PRIx64", open txg is %"PRIx64"",
 			    pack->bw_txg, txg);
 
 		if (pack->bw_data != 0 && pack->bw_index != n + i)
 			fatal(B_FALSE, "wrong index: "
 			    "got %"PRIx64", wanted %"PRIx64"+%"PRIx64"",
 			    pack->bw_index, n, i);
 
 		if (memcmp(pack, bigH, sizeof (bufwad_t)) != 0)
 			fatal(B_FALSE, "pack/bigH mismatch in %p/%p",
 			    pack, bigH);
 
 		if (memcmp(pack, bigT, sizeof (bufwad_t)) != 0)
 			fatal(B_FALSE, "pack/bigT mismatch in %p/%p",
 			    pack, bigT);
 
 		pack->bw_index = n + i;
 		pack->bw_txg = txg;
 		pack->bw_data = 1 + ztest_random(-2ULL);
 
 		*bigH = *pack;
 		*bigT = *pack;
 	}
 }
 
 #undef OD_ARRAY_SIZE
 #define	OD_ARRAY_SIZE	2
 
 void
 ztest_dmu_read_write_zcopy(ztest_ds_t *zd, uint64_t id)
 {
 	objset_t *os = zd->zd_os;
 	ztest_od_t *od;
 	dmu_tx_t *tx;
 	uint64_t i;
 	int error;
 	int size;
 	uint64_t n, s, txg;
 	bufwad_t *packbuf, *bigbuf;
 	uint64_t packobj, packoff, packsize, bigobj, bigoff, bigsize;
 	uint64_t blocksize = ztest_random_blocksize();
 	uint64_t chunksize = blocksize;
 	uint64_t regions = 997;
 	uint64_t stride = 123456789ULL;
 	uint64_t width = 9;
 	dmu_buf_t *bonus_db;
 	arc_buf_t **bigbuf_arcbufs;
 	dmu_object_info_t doi;
 	uint32_t dmu_read_flags = DMU_READ_PREFETCH;
 
 	/*
 	 * We will randomly set when to do O_DIRECT on a read.
 	 */
 	if (ztest_random(4) == 0)
 		dmu_read_flags |= DMU_DIRECTIO;
 
 	size = sizeof (ztest_od_t) * OD_ARRAY_SIZE;
 	od = umem_alloc(size, UMEM_NOFAIL);
 
 	/*
 	 * This test uses two objects, packobj and bigobj, that are always
 	 * updated together (i.e. in the same tx) so that their contents are
 	 * in sync and can be compared.  Their contents relate to each other
 	 * in a simple way: packobj is a dense array of 'bufwad' structures,
 	 * while bigobj is a sparse array of the same bufwads.  Specifically,
 	 * for any index n, there are three bufwads that should be identical:
 	 *
 	 *	packobj, at offset n * sizeof (bufwad_t)
 	 *	bigobj, at the head of the nth chunk
 	 *	bigobj, at the tail of the nth chunk
 	 *
 	 * The chunk size is set equal to bigobj block size so that
 	 * dmu_assign_arcbuf_by_dbuf() can be tested for object updates.
 	 */
 
 	/*
 	 * Read the directory info.  If it's the first time, set things up.
 	 */
 	ztest_od_init(od, id, FTAG, 0, DMU_OT_UINT64_OTHER, blocksize, 0, 0);
 	ztest_od_init(od + 1, id, FTAG, 1, DMU_OT_UINT64_OTHER, 0, 0,
 	    chunksize);
 
 
 	if (ztest_object_init(zd, od, size, B_FALSE) != 0) {
 		umem_free(od, size);
 		return;
 	}
 
 	bigobj = od[0].od_object;
 	packobj = od[1].od_object;
 	blocksize = od[0].od_blocksize;
 	chunksize = blocksize;
 	ASSERT3U(chunksize, ==, od[1].od_gen);
 
 	VERIFY0(dmu_object_info(os, bigobj, &doi));
 	VERIFY(ISP2(doi.doi_data_block_size));
 	VERIFY3U(chunksize, ==, doi.doi_data_block_size);
 	VERIFY3U(chunksize, >=, 2 * sizeof (bufwad_t));
 
 	/*
 	 * Pick a random index and compute the offsets into packobj and bigobj.
 	 */
 	n = ztest_random(regions) * stride + ztest_random(width);
 	s = 1 + ztest_random(width - 1);
 
 	packoff = n * sizeof (bufwad_t);
 	packsize = s * sizeof (bufwad_t);
 
 	bigoff = n * chunksize;
 	bigsize = s * chunksize;
 
 	packbuf = umem_zalloc(packsize, UMEM_NOFAIL);
 	bigbuf = umem_zalloc(bigsize, UMEM_NOFAIL);
 
 	VERIFY0(dmu_bonus_hold(os, bigobj, FTAG, &bonus_db));
 
 	bigbuf_arcbufs = umem_zalloc(2 * s * sizeof (arc_buf_t *), UMEM_NOFAIL);
 
 	/*
 	 * Iteration 0 test zcopy for DB_UNCACHED dbufs.
 	 * Iteration 1 test zcopy to already referenced dbufs.
 	 * Iteration 2 test zcopy to dirty dbuf in the same txg.
 	 * Iteration 3 test zcopy to dbuf dirty in previous txg.
 	 * Iteration 4 test zcopy when dbuf is no longer dirty.
 	 * Iteration 5 test zcopy when it can't be done.
 	 * Iteration 6 one more zcopy write.
 	 */
 	for (i = 0; i < 7; i++) {
 		uint64_t j;
 		uint64_t off;
 
 		/*
 		 * In iteration 5 (i == 5) use arcbufs
 		 * that don't match bigobj blksz to test
 		 * dmu_assign_arcbuf_by_dbuf() when it can't directly
 		 * assign an arcbuf to a dbuf.
 		 */
 		for (j = 0; j < s; j++) {
 			if (i != 5 || chunksize < (SPA_MINBLOCKSIZE * 2)) {
 				bigbuf_arcbufs[j] =
 				    dmu_request_arcbuf(bonus_db, chunksize);
 			} else {
 				bigbuf_arcbufs[2 * j] =
 				    dmu_request_arcbuf(bonus_db, chunksize / 2);
 				bigbuf_arcbufs[2 * j + 1] =
 				    dmu_request_arcbuf(bonus_db, chunksize / 2);
 			}
 		}
 
 		/*
 		 * Get a tx for the mods to both packobj and bigobj.
 		 */
 		tx = dmu_tx_create(os);
 
 		dmu_tx_hold_write(tx, packobj, packoff, packsize);
 		dmu_tx_hold_write(tx, bigobj, bigoff, bigsize);
 
 		txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
 		if (txg == 0) {
 			umem_free(packbuf, packsize);
 			umem_free(bigbuf, bigsize);
 			for (j = 0; j < s; j++) {
 				if (i != 5 ||
 				    chunksize < (SPA_MINBLOCKSIZE * 2)) {
 					dmu_return_arcbuf(bigbuf_arcbufs[j]);
 				} else {
 					dmu_return_arcbuf(
 					    bigbuf_arcbufs[2 * j]);
 					dmu_return_arcbuf(
 					    bigbuf_arcbufs[2 * j + 1]);
 				}
 			}
 			umem_free(bigbuf_arcbufs, 2 * s * sizeof (arc_buf_t *));
 			umem_free(od, size);
 			dmu_buf_rele(bonus_db, FTAG);
 			return;
 		}
 
 		/*
 		 * 50% of the time don't read objects in the 1st iteration to
 		 * test dmu_assign_arcbuf_by_dbuf() for the case when there are
 		 * no existing dbufs for the specified offsets.
 		 */
 		if (i != 0 || ztest_random(2) != 0) {
 			error = dmu_read(os, packobj, packoff,
 			    packsize, packbuf, dmu_read_flags);
 			ASSERT0(error);
 			error = dmu_read(os, bigobj, bigoff, bigsize,
 			    bigbuf, dmu_read_flags);
 			ASSERT0(error);
 		}
 		compare_and_update_pbbufs(s, packbuf, bigbuf, bigsize,
 		    n, chunksize, txg);
 
 		/*
 		 * We've verified all the old bufwads, and made new ones.
 		 * Now write them out.
 		 */
 		dmu_write(os, packobj, packoff, packsize, packbuf, tx);
 		if (ztest_opts.zo_verbose >= 7) {
 			(void) printf("writing offset %"PRIx64" size %"PRIx64""
 			    " txg %"PRIx64"\n",
 			    bigoff, bigsize, txg);
 		}
 		for (off = bigoff, j = 0; j < s; j++, off += chunksize) {
 			dmu_buf_t *dbt;
 			if (i != 5 || chunksize < (SPA_MINBLOCKSIZE * 2)) {
 				memcpy(bigbuf_arcbufs[j]->b_data,
 				    (caddr_t)bigbuf + (off - bigoff),
 				    chunksize);
 			} else {
 				memcpy(bigbuf_arcbufs[2 * j]->b_data,
 				    (caddr_t)bigbuf + (off - bigoff),
 				    chunksize / 2);
 				memcpy(bigbuf_arcbufs[2 * j + 1]->b_data,
 				    (caddr_t)bigbuf + (off - bigoff) +
 				    chunksize / 2,
 				    chunksize / 2);
 			}
 
 			if (i == 1) {
 				VERIFY(dmu_buf_hold(os, bigobj, off,
 				    FTAG, &dbt, DMU_READ_NO_PREFETCH) == 0);
 			}
 			if (i != 5 || chunksize < (SPA_MINBLOCKSIZE * 2)) {
 				VERIFY0(dmu_assign_arcbuf_by_dbuf(bonus_db,
 				    off, bigbuf_arcbufs[j], tx));
 			} else {
 				VERIFY0(dmu_assign_arcbuf_by_dbuf(bonus_db,
 				    off, bigbuf_arcbufs[2 * j], tx));
 				VERIFY0(dmu_assign_arcbuf_by_dbuf(bonus_db,
 				    off + chunksize / 2,
 				    bigbuf_arcbufs[2 * j + 1], tx));
 			}
 			if (i == 1) {
 				dmu_buf_rele(dbt, FTAG);
 			}
 		}
 		dmu_tx_commit(tx);
 
 		/*
 		 * Sanity check the stuff we just wrote.
 		 */
 		{
 			void *packcheck = umem_alloc(packsize, UMEM_NOFAIL);
 			void *bigcheck = umem_alloc(bigsize, UMEM_NOFAIL);
 
 			VERIFY0(dmu_read(os, packobj, packoff,
 			    packsize, packcheck, dmu_read_flags));
 			VERIFY0(dmu_read(os, bigobj, bigoff,
 			    bigsize, bigcheck, dmu_read_flags));
 
 			ASSERT0(memcmp(packbuf, packcheck, packsize));
 			ASSERT0(memcmp(bigbuf, bigcheck, bigsize));
 
 			umem_free(packcheck, packsize);
 			umem_free(bigcheck, bigsize);
 		}
 		if (i == 2) {
 			txg_wait_open(dmu_objset_pool(os), 0, B_TRUE);
 		} else if (i == 3) {
 			txg_wait_synced(dmu_objset_pool(os), 0);
 		}
 	}
 
 	dmu_buf_rele(bonus_db, FTAG);
 	umem_free(packbuf, packsize);
 	umem_free(bigbuf, bigsize);
 	umem_free(bigbuf_arcbufs, 2 * s * sizeof (arc_buf_t *));
 	umem_free(od, size);
 }
 
 void
 ztest_dmu_write_parallel(ztest_ds_t *zd, uint64_t id)
 {
 	(void) id;
 	ztest_od_t *od;
 
 	od = umem_alloc(sizeof (ztest_od_t), UMEM_NOFAIL);
 	uint64_t offset = (1ULL << (ztest_random(20) + 43)) +
 	    (ztest_random(ZTEST_RANGE_LOCKS) << SPA_MAXBLOCKSHIFT);
 
 	/*
 	 * Have multiple threads write to large offsets in an object
 	 * to verify that parallel writes to an object -- even to the
 	 * same blocks within the object -- doesn't cause any trouble.
 	 */
 	ztest_od_init(od, ID_PARALLEL, FTAG, 0, DMU_OT_UINT64_OTHER, 0, 0, 0);
 
 	if (ztest_object_init(zd, od, sizeof (ztest_od_t), B_FALSE) != 0)
 		return;
 
 	while (ztest_random(10) != 0)
 		ztest_io(zd, od->od_object, offset);
 
 	umem_free(od, sizeof (ztest_od_t));
 }
 
 void
 ztest_dmu_prealloc(ztest_ds_t *zd, uint64_t id)
 {
 	ztest_od_t *od;
 	uint64_t offset = (1ULL << (ztest_random(4) + SPA_MAXBLOCKSHIFT)) +
 	    (ztest_random(ZTEST_RANGE_LOCKS) << SPA_MAXBLOCKSHIFT);
 	uint64_t count = ztest_random(20) + 1;
 	uint64_t blocksize = ztest_random_blocksize();
 	void *data;
 
 	od = umem_alloc(sizeof (ztest_od_t), UMEM_NOFAIL);
 
 	ztest_od_init(od, id, FTAG, 0, DMU_OT_UINT64_OTHER, blocksize, 0, 0);
 
 	if (ztest_object_init(zd, od, sizeof (ztest_od_t),
 	    !ztest_random(2)) != 0) {
 		umem_free(od, sizeof (ztest_od_t));
 		return;
 	}
 
 	if (ztest_truncate(zd, od->od_object, offset, count * blocksize) != 0) {
 		umem_free(od, sizeof (ztest_od_t));
 		return;
 	}
 
 	ztest_prealloc(zd, od->od_object, offset, count * blocksize);
 
 	data = umem_zalloc(blocksize, UMEM_NOFAIL);
 
 	while (ztest_random(count) != 0) {
 		uint64_t randoff = offset + (ztest_random(count) * blocksize);
 		if (ztest_write(zd, od->od_object, randoff, blocksize,
 		    data) != 0)
 			break;
 		while (ztest_random(4) != 0)
 			ztest_io(zd, od->od_object, randoff);
 	}
 
 	umem_free(data, blocksize);
 	umem_free(od, sizeof (ztest_od_t));
 }
 
 /*
  * Verify that zap_{create,destroy,add,remove,update} work as expected.
  */
 #define	ZTEST_ZAP_MIN_INTS	1
 #define	ZTEST_ZAP_MAX_INTS	4
 #define	ZTEST_ZAP_MAX_PROPS	1000
 
 void
 ztest_zap(ztest_ds_t *zd, uint64_t id)
 {
 	objset_t *os = zd->zd_os;
 	ztest_od_t *od;
 	uint64_t object;
 	uint64_t txg, last_txg;
 	uint64_t value[ZTEST_ZAP_MAX_INTS];
 	uint64_t zl_ints, zl_intsize, prop;
 	int i, ints;
 	dmu_tx_t *tx;
 	char propname[100], txgname[100];
 	int error;
 	const char *const hc[2] = { "s.acl.h", ".s.open.h.hyLZlg" };
 
 	od = umem_alloc(sizeof (ztest_od_t), UMEM_NOFAIL);
 	ztest_od_init(od, id, FTAG, 0, DMU_OT_ZAP_OTHER, 0, 0, 0);
 
 	if (ztest_object_init(zd, od, sizeof (ztest_od_t),
 	    !ztest_random(2)) != 0)
 		goto out;
 
 	object = od->od_object;
 
 	/*
 	 * Generate a known hash collision, and verify that
 	 * we can lookup and remove both entries.
 	 */
 	tx = dmu_tx_create(os);
 	dmu_tx_hold_zap(tx, object, B_TRUE, NULL);
 	txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
 	if (txg == 0)
 		goto out;
 	for (i = 0; i < 2; i++) {
 		value[i] = i;
 		VERIFY0(zap_add(os, object, hc[i], sizeof (uint64_t),
 		    1, &value[i], tx));
 	}
 	for (i = 0; i < 2; i++) {
 		VERIFY3U(EEXIST, ==, zap_add(os, object, hc[i],
 		    sizeof (uint64_t), 1, &value[i], tx));
 		VERIFY0(
 		    zap_length(os, object, hc[i], &zl_intsize, &zl_ints));
 		ASSERT3U(zl_intsize, ==, sizeof (uint64_t));
 		ASSERT3U(zl_ints, ==, 1);
 	}
 	for (i = 0; i < 2; i++) {
 		VERIFY0(zap_remove(os, object, hc[i], tx));
 	}
 	dmu_tx_commit(tx);
 
 	/*
 	 * Generate a bunch of random entries.
 	 */
 	ints = MAX(ZTEST_ZAP_MIN_INTS, object % ZTEST_ZAP_MAX_INTS);
 
 	prop = ztest_random(ZTEST_ZAP_MAX_PROPS);
 	(void) sprintf(propname, "prop_%"PRIu64"", prop);
 	(void) sprintf(txgname, "txg_%"PRIu64"", prop);
 	memset(value, 0, sizeof (value));
 	last_txg = 0;
 
 	/*
 	 * If these zap entries already exist, validate their contents.
 	 */
 	error = zap_length(os, object, txgname, &zl_intsize, &zl_ints);
 	if (error == 0) {
 		ASSERT3U(zl_intsize, ==, sizeof (uint64_t));
 		ASSERT3U(zl_ints, ==, 1);
 
 		VERIFY0(zap_lookup(os, object, txgname, zl_intsize,
 		    zl_ints, &last_txg));
 
 		VERIFY0(zap_length(os, object, propname, &zl_intsize,
 		    &zl_ints));
 
 		ASSERT3U(zl_intsize, ==, sizeof (uint64_t));
 		ASSERT3U(zl_ints, ==, ints);
 
 		VERIFY0(zap_lookup(os, object, propname, zl_intsize,
 		    zl_ints, value));
 
 		for (i = 0; i < ints; i++) {
 			ASSERT3U(value[i], ==, last_txg + object + i);
 		}
 	} else {
 		ASSERT3U(error, ==, ENOENT);
 	}
 
 	/*
 	 * Atomically update two entries in our zap object.
 	 * The first is named txg_%llu, and contains the txg
 	 * in which the property was last updated.  The second
 	 * is named prop_%llu, and the nth element of its value
 	 * should be txg + object + n.
 	 */
 	tx = dmu_tx_create(os);
 	dmu_tx_hold_zap(tx, object, B_TRUE, NULL);
 	txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
 	if (txg == 0)
 		goto out;
 
 	if (last_txg > txg)
 		fatal(B_FALSE, "zap future leak: old %"PRIu64" new %"PRIu64"",
 		    last_txg, txg);
 
 	for (i = 0; i < ints; i++)
 		value[i] = txg + object + i;
 
 	VERIFY0(zap_update(os, object, txgname, sizeof (uint64_t),
 	    1, &txg, tx));
 	VERIFY0(zap_update(os, object, propname, sizeof (uint64_t),
 	    ints, value, tx));
 
 	dmu_tx_commit(tx);
 
 	/*
 	 * Remove a random pair of entries.
 	 */
 	prop = ztest_random(ZTEST_ZAP_MAX_PROPS);
 	(void) sprintf(propname, "prop_%"PRIu64"", prop);
 	(void) sprintf(txgname, "txg_%"PRIu64"", prop);
 
 	error = zap_length(os, object, txgname, &zl_intsize, &zl_ints);
 
 	if (error == ENOENT)
 		goto out;
 
 	ASSERT0(error);
 
 	tx = dmu_tx_create(os);
 	dmu_tx_hold_zap(tx, object, B_TRUE, NULL);
 	txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
 	if (txg == 0)
 		goto out;
 	VERIFY0(zap_remove(os, object, txgname, tx));
 	VERIFY0(zap_remove(os, object, propname, tx));
 	dmu_tx_commit(tx);
 out:
 	umem_free(od, sizeof (ztest_od_t));
 }
 
 /*
  * Test case to test the upgrading of a microzap to fatzap.
  */
 void
 ztest_fzap(ztest_ds_t *zd, uint64_t id)
 {
 	objset_t *os = zd->zd_os;
 	ztest_od_t *od;
 	uint64_t object, txg, value;
 
 	od = umem_alloc(sizeof (ztest_od_t), UMEM_NOFAIL);
 	ztest_od_init(od, id, FTAG, 0, DMU_OT_ZAP_OTHER, 0, 0, 0);
 
 	if (ztest_object_init(zd, od, sizeof (ztest_od_t),
 	    !ztest_random(2)) != 0)
 		goto out;
 	object = od->od_object;
 
 	/*
 	 * Add entries to this ZAP and make sure it spills over
 	 * and gets upgraded to a fatzap. Also, since we are adding
 	 * 2050 entries we should see ptrtbl growth and leaf-block split.
 	 */
 	for (value = 0; value < 2050; value++) {
 		char name[ZFS_MAX_DATASET_NAME_LEN];
 		dmu_tx_t *tx;
 		int error;
 
 		(void) snprintf(name, sizeof (name), "fzap-%"PRIu64"-%"PRIu64"",
 		    id, value);
 
 		tx = dmu_tx_create(os);
 		dmu_tx_hold_zap(tx, object, B_TRUE, name);
 		txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
 		if (txg == 0)
 			goto out;
 		error = zap_add(os, object, name, sizeof (uint64_t), 1,
 		    &value, tx);
 		ASSERT(error == 0 || error == EEXIST);
 		dmu_tx_commit(tx);
 	}
 out:
 	umem_free(od, sizeof (ztest_od_t));
 }
 
 void
 ztest_zap_parallel(ztest_ds_t *zd, uint64_t id)
 {
 	(void) id;
 	objset_t *os = zd->zd_os;
 	ztest_od_t *od;
 	uint64_t txg, object, count, wsize, wc, zl_wsize, zl_wc;
 	dmu_tx_t *tx;
 	int i, namelen, error;
 	int micro = ztest_random(2);
 	char name[20], string_value[20];
 	void *data;
 
 	od = umem_alloc(sizeof (ztest_od_t), UMEM_NOFAIL);
 	ztest_od_init(od, ID_PARALLEL, FTAG, micro, DMU_OT_ZAP_OTHER, 0, 0, 0);
 
 	if (ztest_object_init(zd, od, sizeof (ztest_od_t), B_FALSE) != 0) {
 		umem_free(od, sizeof (ztest_od_t));
 		return;
 	}
 
 	object = od->od_object;
 
 	/*
 	 * Generate a random name of the form 'xxx.....' where each
 	 * x is a random printable character and the dots are dots.
 	 * There are 94 such characters, and the name length goes from
 	 * 6 to 20, so there are 94^3 * 15 = 12,458,760 possible names.
 	 */
 	namelen = ztest_random(sizeof (name) - 5) + 5 + 1;
 
 	for (i = 0; i < 3; i++)
 		name[i] = '!' + ztest_random('~' - '!' + 1);
 	for (; i < namelen - 1; i++)
 		name[i] = '.';
 	name[i] = '\0';
 
 	if ((namelen & 1) || micro) {
 		wsize = sizeof (txg);
 		wc = 1;
 		data = &txg;
 	} else {
 		wsize = 1;
 		wc = namelen;
 		data = string_value;
 	}
 
 	count = -1ULL;
 	VERIFY0(zap_count(os, object, &count));
 	ASSERT3S(count, !=, -1ULL);
 
 	/*
 	 * Select an operation: length, lookup, add, update, remove.
 	 */
 	i = ztest_random(5);
 
 	if (i >= 2) {
 		tx = dmu_tx_create(os);
 		dmu_tx_hold_zap(tx, object, B_TRUE, NULL);
 		txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
 		if (txg == 0) {
 			umem_free(od, sizeof (ztest_od_t));
 			return;
 		}
 		memcpy(string_value, name, namelen);
 	} else {
 		tx = NULL;
 		txg = 0;
 		memset(string_value, 0, namelen);
 	}
 
 	switch (i) {
 
 	case 0:
 		error = zap_length(os, object, name, &zl_wsize, &zl_wc);
 		if (error == 0) {
 			ASSERT3U(wsize, ==, zl_wsize);
 			ASSERT3U(wc, ==, zl_wc);
 		} else {
 			ASSERT3U(error, ==, ENOENT);
 		}
 		break;
 
 	case 1:
 		error = zap_lookup(os, object, name, wsize, wc, data);
 		if (error == 0) {
 			if (data == string_value &&
 			    memcmp(name, data, namelen) != 0)
 				fatal(B_FALSE, "name '%s' != val '%s' len %d",
 				    name, (char *)data, namelen);
 		} else {
 			ASSERT3U(error, ==, ENOENT);
 		}
 		break;
 
 	case 2:
 		error = zap_add(os, object, name, wsize, wc, data, tx);
 		ASSERT(error == 0 || error == EEXIST);
 		break;
 
 	case 3:
 		VERIFY0(zap_update(os, object, name, wsize, wc, data, tx));
 		break;
 
 	case 4:
 		error = zap_remove(os, object, name, tx);
 		ASSERT(error == 0 || error == ENOENT);
 		break;
 	}
 
 	if (tx != NULL)
 		dmu_tx_commit(tx);
 
 	umem_free(od, sizeof (ztest_od_t));
 }
 
 /*
  * Commit callback data.
  */
 typedef struct ztest_cb_data {
 	list_node_t		zcd_node;
 	uint64_t		zcd_txg;
 	int			zcd_expected_err;
 	boolean_t		zcd_added;
 	boolean_t		zcd_called;
 	spa_t			*zcd_spa;
 } ztest_cb_data_t;
 
 /* This is the actual commit callback function */
 static void
 ztest_commit_callback(void *arg, int error)
 {
 	ztest_cb_data_t *data = arg;
 	uint64_t synced_txg;
 
 	VERIFY3P(data, !=, NULL);
 	VERIFY3S(data->zcd_expected_err, ==, error);
 	VERIFY(!data->zcd_called);
 
 	synced_txg = spa_last_synced_txg(data->zcd_spa);
 	if (data->zcd_txg > synced_txg)
 		fatal(B_FALSE,
 		    "commit callback of txg %"PRIu64" called prematurely, "
 		    "last synced txg = %"PRIu64"\n",
 		    data->zcd_txg, synced_txg);
 
 	data->zcd_called = B_TRUE;
 
 	if (error == ECANCELED) {
 		ASSERT0(data->zcd_txg);
 		ASSERT(!data->zcd_added);
 
 		/*
 		 * The private callback data should be destroyed here, but
 		 * since we are going to check the zcd_called field after
 		 * dmu_tx_abort(), we will destroy it there.
 		 */
 		return;
 	}
 
 	ASSERT(data->zcd_added);
 	ASSERT3U(data->zcd_txg, !=, 0);
 
 	(void) mutex_enter(&zcl.zcl_callbacks_lock);
 
 	/* See if this cb was called more quickly */
 	if ((synced_txg - data->zcd_txg) < zc_min_txg_delay)
 		zc_min_txg_delay = synced_txg - data->zcd_txg;
 
 	/* Remove our callback from the list */
 	list_remove(&zcl.zcl_callbacks, data);
 
 	(void) mutex_exit(&zcl.zcl_callbacks_lock);
 
 	umem_free(data, sizeof (ztest_cb_data_t));
 }
 
 /* Allocate and initialize callback data structure */
 static ztest_cb_data_t *
 ztest_create_cb_data(objset_t *os, uint64_t txg)
 {
 	ztest_cb_data_t *cb_data;
 
 	cb_data = umem_zalloc(sizeof (ztest_cb_data_t), UMEM_NOFAIL);
 
 	cb_data->zcd_txg = txg;
 	cb_data->zcd_spa = dmu_objset_spa(os);
 	list_link_init(&cb_data->zcd_node);
 
 	return (cb_data);
 }
 
 /*
  * Commit callback test.
  */
 void
 ztest_dmu_commit_callbacks(ztest_ds_t *zd, uint64_t id)
 {
 	objset_t *os = zd->zd_os;
 	ztest_od_t *od;
 	dmu_tx_t *tx;
 	ztest_cb_data_t *cb_data[3], *tmp_cb;
 	uint64_t old_txg, txg;
 	int i, error = 0;
 
 	od = umem_alloc(sizeof (ztest_od_t), UMEM_NOFAIL);
 	ztest_od_init(od, id, FTAG, 0, DMU_OT_UINT64_OTHER, 0, 0, 0);
 
 	if (ztest_object_init(zd, od, sizeof (ztest_od_t), B_FALSE) != 0) {
 		umem_free(od, sizeof (ztest_od_t));
 		return;
 	}
 
 	tx = dmu_tx_create(os);
 
 	cb_data[0] = ztest_create_cb_data(os, 0);
 	dmu_tx_callback_register(tx, ztest_commit_callback, cb_data[0]);
 
 	dmu_tx_hold_write(tx, od->od_object, 0, sizeof (uint64_t));
 
 	/* Every once in a while, abort the transaction on purpose */
 	if (ztest_random(100) == 0)
 		error = -1;
 
 	if (!error)
 		error = dmu_tx_assign(tx, TXG_NOWAIT);
 
 	txg = error ? 0 : dmu_tx_get_txg(tx);
 
 	cb_data[0]->zcd_txg = txg;
 	cb_data[1] = ztest_create_cb_data(os, txg);
 	dmu_tx_callback_register(tx, ztest_commit_callback, cb_data[1]);
 
 	if (error) {
 		/*
 		 * It's not a strict requirement to call the registered
 		 * callbacks from inside dmu_tx_abort(), but that's what
 		 * it's supposed to happen in the current implementation
 		 * so we will check for that.
 		 */
 		for (i = 0; i < 2; i++) {
 			cb_data[i]->zcd_expected_err = ECANCELED;
 			VERIFY(!cb_data[i]->zcd_called);
 		}
 
 		dmu_tx_abort(tx);
 
 		for (i = 0; i < 2; i++) {
 			VERIFY(cb_data[i]->zcd_called);
 			umem_free(cb_data[i], sizeof (ztest_cb_data_t));
 		}
 
 		umem_free(od, sizeof (ztest_od_t));
 		return;
 	}
 
 	cb_data[2] = ztest_create_cb_data(os, txg);
 	dmu_tx_callback_register(tx, ztest_commit_callback, cb_data[2]);
 
 	/*
 	 * Read existing data to make sure there isn't a future leak.
 	 */
 	VERIFY0(dmu_read(os, od->od_object, 0, sizeof (uint64_t),
 	    &old_txg, DMU_READ_PREFETCH));
 
 	if (old_txg > txg)
 		fatal(B_FALSE,
 		    "future leak: got %"PRIu64", open txg is %"PRIu64"",
 		    old_txg, txg);
 
 	dmu_write(os, od->od_object, 0, sizeof (uint64_t), &txg, tx);
 
 	(void) mutex_enter(&zcl.zcl_callbacks_lock);
 
 	/*
 	 * Since commit callbacks don't have any ordering requirement and since
 	 * it is theoretically possible for a commit callback to be called
 	 * after an arbitrary amount of time has elapsed since its txg has been
 	 * synced, it is difficult to reliably determine whether a commit
 	 * callback hasn't been called due to high load or due to a flawed
 	 * implementation.
 	 *
 	 * In practice, we will assume that if after a certain number of txgs a
 	 * commit callback hasn't been called, then most likely there's an
 	 * implementation bug..
 	 */
 	tmp_cb = list_head(&zcl.zcl_callbacks);
 	if (tmp_cb != NULL &&
 	    tmp_cb->zcd_txg + ZTEST_COMMIT_CB_THRESH < txg) {
 		fatal(B_FALSE,
 		    "Commit callback threshold exceeded, "
 		    "oldest txg: %"PRIu64", open txg: %"PRIu64"\n",
 		    tmp_cb->zcd_txg, txg);
 	}
 
 	/*
 	 * Let's find the place to insert our callbacks.
 	 *
 	 * Even though the list is ordered by txg, it is possible for the
 	 * insertion point to not be the end because our txg may already be
 	 * quiescing at this point and other callbacks in the open txg
 	 * (from other objsets) may have sneaked in.
 	 */
 	tmp_cb = list_tail(&zcl.zcl_callbacks);
 	while (tmp_cb != NULL && tmp_cb->zcd_txg > txg)
 		tmp_cb = list_prev(&zcl.zcl_callbacks, tmp_cb);
 
 	/* Add the 3 callbacks to the list */
 	for (i = 0; i < 3; i++) {
 		if (tmp_cb == NULL)
 			list_insert_head(&zcl.zcl_callbacks, cb_data[i]);
 		else
 			list_insert_after(&zcl.zcl_callbacks, tmp_cb,
 			    cb_data[i]);
 
 		cb_data[i]->zcd_added = B_TRUE;
 		VERIFY(!cb_data[i]->zcd_called);
 
 		tmp_cb = cb_data[i];
 	}
 
 	zc_cb_counter += 3;
 
 	(void) mutex_exit(&zcl.zcl_callbacks_lock);
 
 	dmu_tx_commit(tx);
 
 	umem_free(od, sizeof (ztest_od_t));
 }
 
 /*
  * Visit each object in the dataset. Verify that its properties
  * are consistent what was stored in the block tag when it was created,
  * and that its unused bonus buffer space has not been overwritten.
  */
 void
 ztest_verify_dnode_bt(ztest_ds_t *zd, uint64_t id)
 {
 	(void) id;
 	objset_t *os = zd->zd_os;
 	uint64_t obj;
 	int err = 0;
 
 	for (obj = 0; err == 0; err = dmu_object_next(os, &obj, FALSE, 0)) {
 		ztest_block_tag_t *bt = NULL;
 		dmu_object_info_t doi;
 		dmu_buf_t *db;
 
 		ztest_object_lock(zd, obj, ZTRL_READER);
 		if (dmu_bonus_hold(os, obj, FTAG, &db) != 0) {
 			ztest_object_unlock(zd, obj);
 			continue;
 		}
 
 		dmu_object_info_from_db(db, &doi);
 		if (doi.doi_bonus_size >= sizeof (*bt))
 			bt = ztest_bt_bonus(db);
 
 		if (bt && bt->bt_magic == BT_MAGIC) {
 			ztest_bt_verify(bt, os, obj, doi.doi_dnodesize,
 			    bt->bt_offset, bt->bt_gen, bt->bt_txg,
 			    bt->bt_crtxg);
 			ztest_verify_unused_bonus(db, bt, obj, os, bt->bt_gen);
 		}
 
 		dmu_buf_rele(db, FTAG);
 		ztest_object_unlock(zd, obj);
 	}
 }
 
 void
 ztest_dsl_prop_get_set(ztest_ds_t *zd, uint64_t id)
 {
 	(void) id;
 	zfs_prop_t proplist[] = {
 		ZFS_PROP_CHECKSUM,
 		ZFS_PROP_COMPRESSION,
 		ZFS_PROP_COPIES,
 		ZFS_PROP_DEDUP
 	};
 
 	(void) pthread_rwlock_rdlock(&ztest_name_lock);
 
 	for (int p = 0; p < sizeof (proplist) / sizeof (proplist[0]); p++) {
 		int error = ztest_dsl_prop_set_uint64(zd->zd_name, proplist[p],
 		    ztest_random_dsl_prop(proplist[p]), (int)ztest_random(2));
 		ASSERT(error == 0 || error == ENOSPC);
 	}
 
 	int error = ztest_dsl_prop_set_uint64(zd->zd_name, ZFS_PROP_RECORDSIZE,
 	    ztest_random_blocksize(), (int)ztest_random(2));
 	ASSERT(error == 0 || error == ENOSPC);
 
 	(void) pthread_rwlock_unlock(&ztest_name_lock);
 }
 
 void
 ztest_spa_prop_get_set(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 
 	(void) pthread_rwlock_rdlock(&ztest_name_lock);
 
 	(void) ztest_spa_prop_set_uint64(ZPOOL_PROP_AUTOTRIM, ztest_random(2));
 
 	nvlist_t *props = fnvlist_alloc();
 
 	VERIFY0(spa_prop_get(ztest_spa, props));
 
 	if (ztest_opts.zo_verbose >= 6)
 		dump_nvlist(props, 4);
 
 	fnvlist_free(props);
 
 	(void) pthread_rwlock_unlock(&ztest_name_lock);
 }
 
 static int
 user_release_one(const char *snapname, const char *holdname)
 {
 	nvlist_t *snaps, *holds;
 	int error;
 
 	snaps = fnvlist_alloc();
 	holds = fnvlist_alloc();
 	fnvlist_add_boolean(holds, holdname);
 	fnvlist_add_nvlist(snaps, snapname, holds);
 	fnvlist_free(holds);
 	error = dsl_dataset_user_release(snaps, NULL);
 	fnvlist_free(snaps);
 	return (error);
 }
 
 /*
  * Test snapshot hold/release and deferred destroy.
  */
 void
 ztest_dmu_snapshot_hold(ztest_ds_t *zd, uint64_t id)
 {
 	int error;
 	objset_t *os = zd->zd_os;
 	objset_t *origin;
 	char snapname[100];
 	char fullname[100];
 	char clonename[100];
 	char tag[100];
 	char osname[ZFS_MAX_DATASET_NAME_LEN];
 	nvlist_t *holds;
 
 	(void) pthread_rwlock_rdlock(&ztest_name_lock);
 
 	dmu_objset_name(os, osname);
 
 	(void) snprintf(snapname, sizeof (snapname), "sh1_%"PRIu64"", id);
 	(void) snprintf(fullname, sizeof (fullname), "%s@%s", osname, snapname);
 	(void) snprintf(clonename, sizeof (clonename), "%s/ch1_%"PRIu64"",
 	    osname, id);
 	(void) snprintf(tag, sizeof (tag), "tag_%"PRIu64"", id);
 
 	/*
 	 * Clean up from any previous run.
 	 */
 	error = dsl_destroy_head(clonename);
 	if (error != ENOENT)
 		ASSERT0(error);
 	error = user_release_one(fullname, tag);
 	if (error != ESRCH && error != ENOENT)
 		ASSERT0(error);
 	error = dsl_destroy_snapshot(fullname, B_FALSE);
 	if (error != ENOENT)
 		ASSERT0(error);
 
 	/*
 	 * Create snapshot, clone it, mark snap for deferred destroy,
 	 * destroy clone, verify snap was also destroyed.
 	 */
 	error = dmu_objset_snapshot_one(osname, snapname);
 	if (error) {
 		if (error == ENOSPC) {
 			ztest_record_enospc("dmu_objset_snapshot");
 			goto out;
 		}
 		fatal(B_FALSE, "dmu_objset_snapshot(%s) = %d", fullname, error);
 	}
 
 	error = dmu_objset_clone(clonename, fullname);
 	if (error) {
 		if (error == ENOSPC) {
 			ztest_record_enospc("dmu_objset_clone");
 			goto out;
 		}
 		fatal(B_FALSE, "dmu_objset_clone(%s) = %d", clonename, error);
 	}
 
 	error = dsl_destroy_snapshot(fullname, B_TRUE);
 	if (error) {
 		fatal(B_FALSE, "dsl_destroy_snapshot(%s, B_TRUE) = %d",
 		    fullname, error);
 	}
 
 	error = dsl_destroy_head(clonename);
 	if (error)
 		fatal(B_FALSE, "dsl_destroy_head(%s) = %d", clonename, error);
 
 	error = dmu_objset_hold(fullname, FTAG, &origin);
 	if (error != ENOENT)
 		fatal(B_FALSE, "dmu_objset_hold(%s) = %d", fullname, error);
 
 	/*
 	 * Create snapshot, add temporary hold, verify that we can't
 	 * destroy a held snapshot, mark for deferred destroy,
 	 * release hold, verify snapshot was destroyed.
 	 */
 	error = dmu_objset_snapshot_one(osname, snapname);
 	if (error) {
 		if (error == ENOSPC) {
 			ztest_record_enospc("dmu_objset_snapshot");
 			goto out;
 		}
 		fatal(B_FALSE, "dmu_objset_snapshot(%s) = %d", fullname, error);
 	}
 
 	holds = fnvlist_alloc();
 	fnvlist_add_string(holds, fullname, tag);
 	error = dsl_dataset_user_hold(holds, 0, NULL);
 	fnvlist_free(holds);
 
 	if (error == ENOSPC) {
 		ztest_record_enospc("dsl_dataset_user_hold");
 		goto out;
 	} else if (error) {
 		fatal(B_FALSE, "dsl_dataset_user_hold(%s, %s) = %u",
 		    fullname, tag, error);
 	}
 
 	error = dsl_destroy_snapshot(fullname, B_FALSE);
 	if (error != EBUSY) {
 		fatal(B_FALSE, "dsl_destroy_snapshot(%s, B_FALSE) = %d",
 		    fullname, error);
 	}
 
 	error = dsl_destroy_snapshot(fullname, B_TRUE);
 	if (error) {
 		fatal(B_FALSE, "dsl_destroy_snapshot(%s, B_TRUE) = %d",
 		    fullname, error);
 	}
 
 	error = user_release_one(fullname, tag);
 	if (error)
 		fatal(B_FALSE, "user_release_one(%s, %s) = %d",
 		    fullname, tag, error);
 
 	VERIFY3U(dmu_objset_hold(fullname, FTAG, &origin), ==, ENOENT);
 
 out:
 	(void) pthread_rwlock_unlock(&ztest_name_lock);
 }
 
 /*
  * Inject random faults into the on-disk data.
  */
 void
 ztest_fault_inject(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	ztest_shared_t *zs = ztest_shared;
 	spa_t *spa = ztest_spa;
 	int fd;
 	uint64_t offset;
 	uint64_t leaves;
 	uint64_t bad = 0x1990c0ffeedecadeull;
 	uint64_t top, leaf;
 	uint64_t raidz_children;
 	char *path0;
 	char *pathrand;
 	size_t fsize;
 	int bshift = SPA_MAXBLOCKSHIFT + 2;
 	int iters = 1000;
 	int maxfaults;
 	int mirror_save;
 	vdev_t *vd0 = NULL;
 	uint64_t guid0 = 0;
 	boolean_t islog = B_FALSE;
 	boolean_t injected = B_FALSE;
 
 	path0 = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
 	pathrand = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
 
 	mutex_enter(&ztest_vdev_lock);
 
 	/*
 	 * Device removal is in progress, fault injection must be disabled
 	 * until it completes and the pool is scrubbed.  The fault injection
 	 * strategy for damaging blocks does not take in to account evacuated
 	 * blocks which may have already been damaged.
 	 */
 	if (ztest_device_removal_active)
 		goto out;
 
 	/*
 	 * The fault injection strategy for damaging blocks cannot be used
 	 * if raidz expansion is in progress. The leaves value
 	 * (attached raidz children) is variable and strategy for damaging
 	 * blocks will corrupt same data blocks on different child vdevs
 	 * because of the reflow process.
 	 */
 	if (spa->spa_raidz_expand != NULL)
 		goto out;
 
 	maxfaults = MAXFAULTS(zs);
 	raidz_children = ztest_get_raidz_children(spa);
 	leaves = MAX(zs->zs_mirrors, 1) * raidz_children;
 	mirror_save = zs->zs_mirrors;
 
 	ASSERT3U(leaves, >=, 1);
 
 	/*
 	 * While ztest is running the number of leaves will not change.  This
 	 * is critical for the fault injection logic as it determines where
 	 * errors can be safely injected such that they are always repairable.
 	 *
 	 * When restarting ztest a different number of leaves may be requested
 	 * which will shift the regions to be damaged.  This is fine as long
 	 * as the pool has been scrubbed prior to using the new mapping.
 	 * Failure to do can result in non-repairable damage being injected.
 	 */
 	if (ztest_pool_scrubbed == B_FALSE)
 		goto out;
 
 	/*
 	 * Grab the name lock as reader. There are some operations
 	 * which don't like to have their vdevs changed while
 	 * they are in progress (i.e. spa_change_guid). Those
 	 * operations will have grabbed the name lock as writer.
 	 */
 	(void) pthread_rwlock_rdlock(&ztest_name_lock);
 
 	/*
 	 * We need SCL_STATE here because we're going to look at vd0->vdev_tsd.
 	 */
 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
 
 	if (ztest_random(2) == 0) {
 		/*
 		 * Inject errors on a normal data device or slog device.
 		 */
 		top = ztest_random_vdev_top(spa, B_TRUE);
 		leaf = ztest_random(leaves) + zs->zs_splits;
 
 		/*
 		 * Generate paths to the first leaf in this top-level vdev,
 		 * and to the random leaf we selected.  We'll induce transient
 		 * write failures and random online/offline activity on leaf 0,
 		 * and we'll write random garbage to the randomly chosen leaf.
 		 */
 		(void) snprintf(path0, MAXPATHLEN, ztest_dev_template,
 		    ztest_opts.zo_dir, ztest_opts.zo_pool,
 		    top * leaves + zs->zs_splits);
 		(void) snprintf(pathrand, MAXPATHLEN, ztest_dev_template,
 		    ztest_opts.zo_dir, ztest_opts.zo_pool,
 		    top * leaves + leaf);
 
 		vd0 = vdev_lookup_by_path(spa->spa_root_vdev, path0);
 		if (vd0 != NULL && vd0->vdev_top->vdev_islog)
 			islog = B_TRUE;
 
 		/*
 		 * If the top-level vdev needs to be resilvered
 		 * then we only allow faults on the device that is
 		 * resilvering.
 		 */
 		if (vd0 != NULL && maxfaults != 1 &&
 		    (!vdev_resilver_needed(vd0->vdev_top, NULL, NULL) ||
 		    vd0->vdev_resilver_txg != 0)) {
 			/*
 			 * Make vd0 explicitly claim to be unreadable,
 			 * or unwritable, or reach behind its back
 			 * and close the underlying fd.  We can do this if
 			 * maxfaults == 0 because we'll fail and reexecute,
 			 * and we can do it if maxfaults >= 2 because we'll
 			 * have enough redundancy.  If maxfaults == 1, the
 			 * combination of this with injection of random data
 			 * corruption below exceeds the pool's fault tolerance.
 			 */
 			vdev_file_t *vf = vd0->vdev_tsd;
 
 			zfs_dbgmsg("injecting fault to vdev %llu; maxfaults=%d",
 			    (long long)vd0->vdev_id, (int)maxfaults);
 
 			if (vf != NULL && ztest_random(3) == 0) {
 				(void) close(vf->vf_file->f_fd);
 				vf->vf_file->f_fd = -1;
 			} else if (ztest_random(2) == 0) {
 				vd0->vdev_cant_read = B_TRUE;
 			} else {
 				vd0->vdev_cant_write = B_TRUE;
 			}
 			guid0 = vd0->vdev_guid;
 		}
 	} else {
 		/*
 		 * Inject errors on an l2cache device.
 		 */
 		spa_aux_vdev_t *sav = &spa->spa_l2cache;
 
 		if (sav->sav_count == 0) {
 			spa_config_exit(spa, SCL_STATE, FTAG);
 			(void) pthread_rwlock_unlock(&ztest_name_lock);
 			goto out;
 		}
 		vd0 = sav->sav_vdevs[ztest_random(sav->sav_count)];
 		guid0 = vd0->vdev_guid;
 		(void) strlcpy(path0, vd0->vdev_path, MAXPATHLEN);
 		(void) strlcpy(pathrand, vd0->vdev_path, MAXPATHLEN);
 
 		leaf = 0;
 		leaves = 1;
 		maxfaults = INT_MAX;	/* no limit on cache devices */
 	}
 
 	spa_config_exit(spa, SCL_STATE, FTAG);
 	(void) pthread_rwlock_unlock(&ztest_name_lock);
 
 	/*
 	 * If we can tolerate two or more faults, or we're dealing
 	 * with a slog, randomly online/offline vd0.
 	 */
 	if ((maxfaults >= 2 || islog) && guid0 != 0) {
 		if (ztest_random(10) < 6) {
 			int flags = (ztest_random(2) == 0 ?
 			    ZFS_OFFLINE_TEMPORARY : 0);
 
 			/*
 			 * We have to grab the zs_name_lock as writer to
 			 * prevent a race between offlining a slog and
 			 * destroying a dataset. Offlining the slog will
 			 * grab a reference on the dataset which may cause
 			 * dsl_destroy_head() to fail with EBUSY thus
 			 * leaving the dataset in an inconsistent state.
 			 */
 			if (islog)
 				(void) pthread_rwlock_wrlock(&ztest_name_lock);
 
 			VERIFY3U(vdev_offline(spa, guid0, flags), !=, EBUSY);
 
 			if (islog)
 				(void) pthread_rwlock_unlock(&ztest_name_lock);
 		} else {
 			/*
 			 * Ideally we would like to be able to randomly
 			 * call vdev_[on|off]line without holding locks
 			 * to force unpredictable failures but the side
 			 * effects of vdev_[on|off]line prevent us from
 			 * doing so.
 			 */
 			(void) vdev_online(spa, guid0, 0, NULL);
 		}
 	}
 
 	if (maxfaults == 0)
 		goto out;
 
 	/*
 	 * We have at least single-fault tolerance, so inject data corruption.
 	 */
 	fd = open(pathrand, O_RDWR);
 
 	if (fd == -1) /* we hit a gap in the device namespace */
 		goto out;
 
 	fsize = lseek(fd, 0, SEEK_END);
 
 	while (--iters != 0) {
 		/*
 		 * The offset must be chosen carefully to ensure that
 		 * we do not inject a given logical block with errors
 		 * on two different leaf devices, because ZFS can not
 		 * tolerate that (if maxfaults==1).
 		 *
 		 * To achieve this we divide each leaf device into
 		 * chunks of size (# leaves * SPA_MAXBLOCKSIZE * 4).
 		 * Each chunk is further divided into error-injection
 		 * ranges (can accept errors) and clear ranges (we do
 		 * not inject errors in those). Each error-injection
 		 * range can accept errors only for a single leaf vdev.
 		 * Error-injection ranges are separated by clear ranges.
 		 *
 		 * For example, with 3 leaves, each chunk looks like:
 		 *    0 to  32M: injection range for leaf 0
 		 *  32M to  64M: clear range - no injection allowed
 		 *  64M to  96M: injection range for leaf 1
 		 *  96M to 128M: clear range - no injection allowed
 		 * 128M to 160M: injection range for leaf 2
 		 * 160M to 192M: clear range - no injection allowed
 		 *
 		 * Each clear range must be large enough such that a
 		 * single block cannot straddle it. This way a block
 		 * can't be a target in two different injection ranges
 		 * (on different leaf vdevs).
 		 */
 		offset = ztest_random(fsize / (leaves << bshift)) *
 		    (leaves << bshift) + (leaf << bshift) +
 		    (ztest_random(1ULL << (bshift - 1)) & -8ULL);
 
 		/*
 		 * Only allow damage to the labels at one end of the vdev.
 		 *
 		 * If all labels are damaged, the device will be totally
 		 * inaccessible, which will result in loss of data,
 		 * because we also damage (parts of) the other side of
 		 * the mirror/raidz.
 		 *
 		 * Additionally, we will always have both an even and an
 		 * odd label, so that we can handle crashes in the
 		 * middle of vdev_config_sync().
 		 */
 		if ((leaf & 1) == 0 && offset < VDEV_LABEL_START_SIZE)
 			continue;
 
 		/*
 		 * The two end labels are stored at the "end" of the disk, but
 		 * the end of the disk (vdev_psize) is aligned to
 		 * sizeof (vdev_label_t).
 		 */
 		uint64_t psize = P2ALIGN_TYPED(fsize, sizeof (vdev_label_t),
 		    uint64_t);
 		if ((leaf & 1) == 1 &&
 		    offset + sizeof (bad) > psize - VDEV_LABEL_END_SIZE)
 			continue;
 
 		if (mirror_save != zs->zs_mirrors) {
 			(void) close(fd);
 			goto out;
 		}
 
 		if (pwrite(fd, &bad, sizeof (bad), offset) != sizeof (bad))
 			fatal(B_TRUE,
 			    "can't inject bad word at 0x%"PRIx64" in %s",
 			    offset, pathrand);
 
 		if (ztest_opts.zo_verbose >= 7)
 			(void) printf("injected bad word into %s,"
 			    " offset 0x%"PRIx64"\n", pathrand, offset);
 
 		injected = B_TRUE;
 	}
 
 	(void) close(fd);
 out:
 	mutex_exit(&ztest_vdev_lock);
 
 	if (injected && ztest_opts.zo_raid_do_expand) {
 		int error = spa_scan(spa, POOL_SCAN_SCRUB);
 		if (error == 0) {
 			while (dsl_scan_scrubbing(spa_get_dsl(spa)))
 				txg_wait_synced(spa_get_dsl(spa), 0);
 		}
 	}
 
 	umem_free(path0, MAXPATHLEN);
 	umem_free(pathrand, MAXPATHLEN);
 }
 
 /*
  * By design ztest will never inject uncorrectable damage in to the pool.
  * Issue a scrub, wait for it to complete, and verify there is never any
  * persistent damage.
  *
  * Only after a full scrub has been completed is it safe to start injecting
  * data corruption.  See the comment in zfs_fault_inject().
+ *
+ * EBUSY may be returned for the following six cases.  It's the callers
+ * responsibility to handle them accordingly.
+ *
+ * Current state                Requested
+ * 1. Normal Scrub Running      Normal Scrub or Error Scrub
+ * 2. Normal Scrub Paused       Error Scrub
+ * 3. Normal Scrub Paused       Pause Normal Scrub
+ * 4. Error Scrub Running       Normal Scrub or Error Scrub
+ * 5. Error Scrub Paused        Pause Error Scrub
+ * 6. Resilvering               Anything else
  */
 static int
 ztest_scrub_impl(spa_t *spa)
 {
 	int error = spa_scan(spa, POOL_SCAN_SCRUB);
 	if (error)
 		return (error);
 
 	while (dsl_scan_scrubbing(spa_get_dsl(spa)))
 		txg_wait_synced(spa_get_dsl(spa), 0);
 
 	if (spa_approx_errlog_size(spa) > 0)
 		return (ECKSUM);
 
 	ztest_pool_scrubbed = B_TRUE;
 
 	return (0);
 }
 
 /*
  * Scrub the pool.
  */
 void
 ztest_scrub(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	spa_t *spa = ztest_spa;
 	int error;
 
 	/*
 	 * Scrub in progress by device removal.
 	 */
 	if (ztest_device_removal_active)
 		return;
 
 	/*
 	 * Start a scrub, wait a moment, then force a restart.
 	 */
 	(void) spa_scan(spa, POOL_SCAN_SCRUB);
 	(void) poll(NULL, 0, 100);
 
 	error = ztest_scrub_impl(spa);
 	if (error == EBUSY)
 		error = 0;
 	ASSERT0(error);
 }
 
 /*
  * Change the guid for the pool.
  */
 void
 ztest_reguid(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	spa_t *spa = ztest_spa;
 	uint64_t orig, load;
 	int error;
 	ztest_shared_t *zs = ztest_shared;
 
 	if (ztest_opts.zo_mmp_test)
 		return;
 
 	orig = spa_guid(spa);
 	load = spa_load_guid(spa);
 
 	(void) pthread_rwlock_wrlock(&ztest_name_lock);
 	error = spa_change_guid(spa, NULL);
 	zs->zs_guid = spa_guid(spa);
 	(void) pthread_rwlock_unlock(&ztest_name_lock);
 
 	if (error != 0)
 		return;
 
 	if (ztest_opts.zo_verbose >= 4) {
 		(void) printf("Changed guid old %"PRIu64" -> %"PRIu64"\n",
 		    orig, spa_guid(spa));
 	}
 
 	VERIFY3U(orig, !=, spa_guid(spa));
 	VERIFY3U(load, ==, spa_load_guid(spa));
 }
 
 void
 ztest_blake3(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	hrtime_t end = gethrtime() + NANOSEC;
 	zio_cksum_salt_t salt;
 	void *salt_ptr = &salt.zcs_bytes;
 	struct abd *abd_data, *abd_meta;
 	void *buf, *templ;
 	int i, *ptr;
 	uint32_t size;
 	BLAKE3_CTX ctx;
 	const zfs_impl_t *blake3 = zfs_impl_get_ops("blake3");
 
 	size = ztest_random_blocksize();
 	buf = umem_alloc(size, UMEM_NOFAIL);
 	abd_data = abd_alloc(size, B_FALSE);
 	abd_meta = abd_alloc(size, B_TRUE);
 
 	for (i = 0, ptr = buf; i < size / sizeof (*ptr); i++, ptr++)
 		*ptr = ztest_random(UINT_MAX);
 	memset(salt_ptr, 'A', 32);
 
 	abd_copy_from_buf_off(abd_data, buf, 0, size);
 	abd_copy_from_buf_off(abd_meta, buf, 0, size);
 
 	while (gethrtime() <= end) {
 		int run_count = 100;
 		zio_cksum_t zc_ref1, zc_ref2;
 		zio_cksum_t zc_res1, zc_res2;
 
 		void *ref1 = &zc_ref1;
 		void *ref2 = &zc_ref2;
 		void *res1 = &zc_res1;
 		void *res2 = &zc_res2;
 
 		/* BLAKE3_KEY_LEN = 32 */
 		VERIFY0(blake3->setname("generic"));
 		templ = abd_checksum_blake3_tmpl_init(&salt);
 		Blake3_InitKeyed(&ctx, salt_ptr);
 		Blake3_Update(&ctx, buf, size);
 		Blake3_Final(&ctx, ref1);
 		zc_ref2 = zc_ref1;
 		ZIO_CHECKSUM_BSWAP(&zc_ref2);
 		abd_checksum_blake3_tmpl_free(templ);
 
 		VERIFY0(blake3->setname("cycle"));
 		while (run_count-- > 0) {
 
 			/* Test current implementation */
 			Blake3_InitKeyed(&ctx, salt_ptr);
 			Blake3_Update(&ctx, buf, size);
 			Blake3_Final(&ctx, res1);
 			zc_res2 = zc_res1;
 			ZIO_CHECKSUM_BSWAP(&zc_res2);
 
 			VERIFY0(memcmp(ref1, res1, 32));
 			VERIFY0(memcmp(ref2, res2, 32));
 
 			/* Test ABD - data */
 			templ = abd_checksum_blake3_tmpl_init(&salt);
 			abd_checksum_blake3_native(abd_data, size,
 			    templ, &zc_res1);
 			abd_checksum_blake3_byteswap(abd_data, size,
 			    templ, &zc_res2);
 
 			VERIFY0(memcmp(ref1, res1, 32));
 			VERIFY0(memcmp(ref2, res2, 32));
 
 			/* Test ABD - metadata */
 			abd_checksum_blake3_native(abd_meta, size,
 			    templ, &zc_res1);
 			abd_checksum_blake3_byteswap(abd_meta, size,
 			    templ, &zc_res2);
 			abd_checksum_blake3_tmpl_free(templ);
 
 			VERIFY0(memcmp(ref1, res1, 32));
 			VERIFY0(memcmp(ref2, res2, 32));
 
 		}
 	}
 
 	abd_free(abd_data);
 	abd_free(abd_meta);
 	umem_free(buf, size);
 }
 
 void
 ztest_fletcher(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	hrtime_t end = gethrtime() + NANOSEC;
 
 	while (gethrtime() <= end) {
 		int run_count = 100;
 		void *buf;
 		struct abd *abd_data, *abd_meta;
 		uint32_t size;
 		int *ptr;
 		int i;
 		zio_cksum_t zc_ref;
 		zio_cksum_t zc_ref_byteswap;
 
 		size = ztest_random_blocksize();
 
 		buf = umem_alloc(size, UMEM_NOFAIL);
 		abd_data = abd_alloc(size, B_FALSE);
 		abd_meta = abd_alloc(size, B_TRUE);
 
 		for (i = 0, ptr = buf; i < size / sizeof (*ptr); i++, ptr++)
 			*ptr = ztest_random(UINT_MAX);
 
 		abd_copy_from_buf_off(abd_data, buf, 0, size);
 		abd_copy_from_buf_off(abd_meta, buf, 0, size);
 
 		VERIFY0(fletcher_4_impl_set("scalar"));
 		fletcher_4_native(buf, size, NULL, &zc_ref);
 		fletcher_4_byteswap(buf, size, NULL, &zc_ref_byteswap);
 
 		VERIFY0(fletcher_4_impl_set("cycle"));
 		while (run_count-- > 0) {
 			zio_cksum_t zc;
 			zio_cksum_t zc_byteswap;
 
 			fletcher_4_byteswap(buf, size, NULL, &zc_byteswap);
 			fletcher_4_native(buf, size, NULL, &zc);
 
 			VERIFY0(memcmp(&zc, &zc_ref, sizeof (zc)));
 			VERIFY0(memcmp(&zc_byteswap, &zc_ref_byteswap,
 			    sizeof (zc_byteswap)));
 
 			/* Test ABD - data */
 			abd_fletcher_4_byteswap(abd_data, size, NULL,
 			    &zc_byteswap);
 			abd_fletcher_4_native(abd_data, size, NULL, &zc);
 
 			VERIFY0(memcmp(&zc, &zc_ref, sizeof (zc)));
 			VERIFY0(memcmp(&zc_byteswap, &zc_ref_byteswap,
 			    sizeof (zc_byteswap)));
 
 			/* Test ABD - metadata */
 			abd_fletcher_4_byteswap(abd_meta, size, NULL,
 			    &zc_byteswap);
 			abd_fletcher_4_native(abd_meta, size, NULL, &zc);
 
 			VERIFY0(memcmp(&zc, &zc_ref, sizeof (zc)));
 			VERIFY0(memcmp(&zc_byteswap, &zc_ref_byteswap,
 			    sizeof (zc_byteswap)));
 
 		}
 
 		umem_free(buf, size);
 		abd_free(abd_data);
 		abd_free(abd_meta);
 	}
 }
 
 void
 ztest_fletcher_incr(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	void *buf;
 	size_t size;
 	int *ptr;
 	int i;
 	zio_cksum_t zc_ref;
 	zio_cksum_t zc_ref_bswap;
 
 	hrtime_t end = gethrtime() + NANOSEC;
 
 	while (gethrtime() <= end) {
 		int run_count = 100;
 
 		size = ztest_random_blocksize();
 		buf = umem_alloc(size, UMEM_NOFAIL);
 
 		for (i = 0, ptr = buf; i < size / sizeof (*ptr); i++, ptr++)
 			*ptr = ztest_random(UINT_MAX);
 
 		VERIFY0(fletcher_4_impl_set("scalar"));
 		fletcher_4_native(buf, size, NULL, &zc_ref);
 		fletcher_4_byteswap(buf, size, NULL, &zc_ref_bswap);
 
 		VERIFY0(fletcher_4_impl_set("cycle"));
 
 		while (run_count-- > 0) {
 			zio_cksum_t zc;
 			zio_cksum_t zc_bswap;
 			size_t pos = 0;
 
 			ZIO_SET_CHECKSUM(&zc, 0, 0, 0, 0);
 			ZIO_SET_CHECKSUM(&zc_bswap, 0, 0, 0, 0);
 
 			while (pos < size) {
 				size_t inc = 64 * ztest_random(size / 67);
 				/* sometimes add few bytes to test non-simd */
 				if (ztest_random(100) < 10)
 					inc += P2ALIGN_TYPED(ztest_random(64),
 					    sizeof (uint32_t), uint64_t);
 
 				if (inc > (size - pos))
 					inc = size - pos;
 
 				fletcher_4_incremental_native(buf + pos, inc,
 				    &zc);
 				fletcher_4_incremental_byteswap(buf + pos, inc,
 				    &zc_bswap);
 
 				pos += inc;
 			}
 
 			VERIFY3U(pos, ==, size);
 
 			VERIFY(ZIO_CHECKSUM_EQUAL(zc, zc_ref));
 			VERIFY(ZIO_CHECKSUM_EQUAL(zc_bswap, zc_ref_bswap));
 
 			/*
 			 * verify if incremental on the whole buffer is
 			 * equivalent to non-incremental version
 			 */
 			ZIO_SET_CHECKSUM(&zc, 0, 0, 0, 0);
 			ZIO_SET_CHECKSUM(&zc_bswap, 0, 0, 0, 0);
 
 			fletcher_4_incremental_native(buf, size, &zc);
 			fletcher_4_incremental_byteswap(buf, size, &zc_bswap);
 
 			VERIFY(ZIO_CHECKSUM_EQUAL(zc, zc_ref));
 			VERIFY(ZIO_CHECKSUM_EQUAL(zc_bswap, zc_ref_bswap));
 		}
 
 		umem_free(buf, size);
 	}
 }
 
 void
 ztest_pool_prefetch_ddt(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	spa_t *spa;
 
 	(void) pthread_rwlock_rdlock(&ztest_name_lock);
 	VERIFY0(spa_open(ztest_opts.zo_pool, &spa, FTAG));
 
 	ddt_prefetch_all(spa);
 
 	spa_close(spa, FTAG);
 	(void) pthread_rwlock_unlock(&ztest_name_lock);
 }
 
 static int
 ztest_set_global_vars(void)
 {
 	for (size_t i = 0; i < ztest_opts.zo_gvars_count; i++) {
 		char *kv = ztest_opts.zo_gvars[i];
 		VERIFY3U(strlen(kv), <=, ZO_GVARS_MAX_ARGLEN);
 		VERIFY3U(strlen(kv), >, 0);
 		int err = set_global_var(kv);
 		if (ztest_opts.zo_verbose > 0) {
 			(void) printf("setting global var %s ... %s\n", kv,
 			    err ? "failed" : "ok");
 		}
 		if (err != 0) {
 			(void) fprintf(stderr,
 			    "failed to set global var '%s'\n", kv);
 			return (err);
 		}
 	}
 	return (0);
 }
 
 static char **
 ztest_global_vars_to_zdb_args(void)
 {
 	char **args = calloc(2*ztest_opts.zo_gvars_count + 1, sizeof (char *));
 	char **cur = args;
 	if (args == NULL)
 		return (NULL);
 	for (size_t i = 0; i < ztest_opts.zo_gvars_count; i++) {
 		*cur++ = (char *)"-o";
 		*cur++ = ztest_opts.zo_gvars[i];
 	}
 	ASSERT3P(cur, ==, &args[2*ztest_opts.zo_gvars_count]);
 	*cur = NULL;
 	return (args);
 }
 
 /* The end of strings is indicated by a NULL element */
 static char *
 join_strings(char **strings, const char *sep)
 {
 	size_t totallen = 0;
 	for (char **sp = strings; *sp != NULL; sp++) {
 		totallen += strlen(*sp);
 		totallen += strlen(sep);
 	}
 	if (totallen > 0) {
 		ASSERT(totallen >= strlen(sep));
 		totallen -= strlen(sep);
 	}
 
 	size_t buflen = totallen + 1;
 	char *o = umem_alloc(buflen, UMEM_NOFAIL); /* trailing 0 byte */
 	o[0] = '\0';
 	for (char **sp = strings; *sp != NULL; sp++) {
 		size_t would;
 		would = strlcat(o, *sp, buflen);
 		VERIFY3U(would, <, buflen);
 		if (*(sp+1) == NULL) {
 			break;
 		}
 		would = strlcat(o, sep, buflen);
 		VERIFY3U(would, <, buflen);
 	}
 	ASSERT3S(strlen(o), ==, totallen);
 	return (o);
 }
 
 static int
 ztest_check_path(char *path)
 {
 	struct stat s;
 	/* return true on success */
 	return (!stat(path, &s));
 }
 
 static void
 ztest_get_zdb_bin(char *bin, int len)
 {
 	char *zdb_path;
 	/*
 	 * Try to use $ZDB and in-tree zdb path. If not successful, just
 	 * let popen to search through PATH.
 	 */
 	if ((zdb_path = getenv("ZDB"))) {
 		strlcpy(bin, zdb_path, len); /* In env */
 		if (!ztest_check_path(bin)) {
 			ztest_dump_core = 0;
 			fatal(B_TRUE, "invalid ZDB '%s'", bin);
 		}
 		return;
 	}
 
 	VERIFY3P(realpath(getexecname(), bin), !=, NULL);
 	if (strstr(bin, ".libs/ztest")) {
 		strstr(bin, ".libs/ztest")[0] = '\0'; /* In-tree */
 		strcat(bin, "zdb");
 		if (ztest_check_path(bin))
 			return;
 	}
 	strcpy(bin, "zdb");
 }
 
 static vdev_t *
 ztest_random_concrete_vdev_leaf(vdev_t *vd)
 {
 	if (vd == NULL)
 		return (NULL);
 
 	if (vd->vdev_children == 0)
 		return (vd);
 
 	vdev_t *eligible[vd->vdev_children];
 	int eligible_idx = 0, i;
 	for (i = 0; i < vd->vdev_children; i++) {
 		vdev_t *cvd = vd->vdev_child[i];
 		if (cvd->vdev_top->vdev_removing)
 			continue;
 		if (cvd->vdev_children > 0 ||
 		    (vdev_is_concrete(cvd) && !cvd->vdev_detached)) {
 			eligible[eligible_idx++] = cvd;
 		}
 	}
 	VERIFY3S(eligible_idx, >, 0);
 
 	uint64_t child_no = ztest_random(eligible_idx);
 	return (ztest_random_concrete_vdev_leaf(eligible[child_no]));
 }
 
 void
 ztest_initialize(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	spa_t *spa = ztest_spa;
 	int error = 0;
 
 	mutex_enter(&ztest_vdev_lock);
 
 	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
 
 	/* Random leaf vdev */
 	vdev_t *rand_vd = ztest_random_concrete_vdev_leaf(spa->spa_root_vdev);
 	if (rand_vd == NULL) {
 		spa_config_exit(spa, SCL_VDEV, FTAG);
 		mutex_exit(&ztest_vdev_lock);
 		return;
 	}
 
 	/*
 	 * The random vdev we've selected may change as soon as we
 	 * drop the spa_config_lock. We create local copies of things
 	 * we're interested in.
 	 */
 	uint64_t guid = rand_vd->vdev_guid;
 	char *path = strdup(rand_vd->vdev_path);
 	boolean_t active = rand_vd->vdev_initialize_thread != NULL;
 
 	zfs_dbgmsg("vd %px, guid %llu", rand_vd, (u_longlong_t)guid);
 	spa_config_exit(spa, SCL_VDEV, FTAG);
 
 	uint64_t cmd = ztest_random(POOL_INITIALIZE_FUNCS);
 
 	nvlist_t *vdev_guids = fnvlist_alloc();
 	nvlist_t *vdev_errlist = fnvlist_alloc();
 	fnvlist_add_uint64(vdev_guids, path, guid);
 	error = spa_vdev_initialize(spa, vdev_guids, cmd, vdev_errlist);
 	fnvlist_free(vdev_guids);
 	fnvlist_free(vdev_errlist);
 
 	switch (cmd) {
 	case POOL_INITIALIZE_CANCEL:
 		if (ztest_opts.zo_verbose >= 4) {
 			(void) printf("Cancel initialize %s", path);
 			if (!active)
 				(void) printf(" failed (no initialize active)");
 			(void) printf("\n");
 		}
 		break;
 	case POOL_INITIALIZE_START:
 		if (ztest_opts.zo_verbose >= 4) {
 			(void) printf("Start initialize %s", path);
 			if (active && error == 0)
 				(void) printf(" failed (already active)");
 			else if (error != 0)
 				(void) printf(" failed (error %d)", error);
 			(void) printf("\n");
 		}
 		break;
 	case POOL_INITIALIZE_SUSPEND:
 		if (ztest_opts.zo_verbose >= 4) {
 			(void) printf("Suspend initialize %s", path);
 			if (!active)
 				(void) printf(" failed (no initialize active)");
 			(void) printf("\n");
 		}
 		break;
 	}
 	free(path);
 	mutex_exit(&ztest_vdev_lock);
 }
 
 void
 ztest_trim(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 	spa_t *spa = ztest_spa;
 	int error = 0;
 
 	mutex_enter(&ztest_vdev_lock);
 
 	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
 
 	/* Random leaf vdev */
 	vdev_t *rand_vd = ztest_random_concrete_vdev_leaf(spa->spa_root_vdev);
 	if (rand_vd == NULL) {
 		spa_config_exit(spa, SCL_VDEV, FTAG);
 		mutex_exit(&ztest_vdev_lock);
 		return;
 	}
 
 	/*
 	 * The random vdev we've selected may change as soon as we
 	 * drop the spa_config_lock. We create local copies of things
 	 * we're interested in.
 	 */
 	uint64_t guid = rand_vd->vdev_guid;
 	char *path = strdup(rand_vd->vdev_path);
 	boolean_t active = rand_vd->vdev_trim_thread != NULL;
 
 	zfs_dbgmsg("vd %p, guid %llu", rand_vd, (u_longlong_t)guid);
 	spa_config_exit(spa, SCL_VDEV, FTAG);
 
 	uint64_t cmd = ztest_random(POOL_TRIM_FUNCS);
 	uint64_t rate = 1 << ztest_random(30);
 	boolean_t partial = (ztest_random(5) > 0);
 	boolean_t secure = (ztest_random(5) > 0);
 
 	nvlist_t *vdev_guids = fnvlist_alloc();
 	nvlist_t *vdev_errlist = fnvlist_alloc();
 	fnvlist_add_uint64(vdev_guids, path, guid);
 	error = spa_vdev_trim(spa, vdev_guids, cmd, rate, partial,
 	    secure, vdev_errlist);
 	fnvlist_free(vdev_guids);
 	fnvlist_free(vdev_errlist);
 
 	switch (cmd) {
 	case POOL_TRIM_CANCEL:
 		if (ztest_opts.zo_verbose >= 4) {
 			(void) printf("Cancel TRIM %s", path);
 			if (!active)
 				(void) printf(" failed (no TRIM active)");
 			(void) printf("\n");
 		}
 		break;
 	case POOL_TRIM_START:
 		if (ztest_opts.zo_verbose >= 4) {
 			(void) printf("Start TRIM %s", path);
 			if (active && error == 0)
 				(void) printf(" failed (already active)");
 			else if (error != 0)
 				(void) printf(" failed (error %d)", error);
 			(void) printf("\n");
 		}
 		break;
 	case POOL_TRIM_SUSPEND:
 		if (ztest_opts.zo_verbose >= 4) {
 			(void) printf("Suspend TRIM %s", path);
 			if (!active)
 				(void) printf(" failed (no TRIM active)");
 			(void) printf("\n");
 		}
 		break;
 	}
 	free(path);
 	mutex_exit(&ztest_vdev_lock);
 }
 
 void
 ztest_ddt_prune(ztest_ds_t *zd, uint64_t id)
 {
 	(void) zd, (void) id;
 
 	spa_t *spa = ztest_spa;
 	uint64_t pct = ztest_random(15) + 1;
 
 	(void) ddt_prune_unique_entries(spa, ZPOOL_DDT_PRUNE_PERCENTAGE, pct);
 }
 
 /*
  * Verify pool integrity by running zdb.
  */
 static void
 ztest_run_zdb(uint64_t guid)
 {
 	int status;
 	char *bin;
 	char *zdb;
 	char *zbuf;
 	const int len = MAXPATHLEN + MAXNAMELEN + 20;
 	FILE *fp;
 
 	bin = umem_alloc(len, UMEM_NOFAIL);
 	zdb = umem_alloc(len, UMEM_NOFAIL);
 	zbuf = umem_alloc(1024, UMEM_NOFAIL);
 
 	ztest_get_zdb_bin(bin, len);
 
 	char **set_gvars_args = ztest_global_vars_to_zdb_args();
 	if (set_gvars_args == NULL) {
 		fatal(B_FALSE, "Failed to allocate memory in "
 		    "ztest_global_vars_to_zdb_args(). Cannot run zdb.\n");
 	}
 	char *set_gvars_args_joined = join_strings(set_gvars_args, " ");
 	free(set_gvars_args);
 
 	size_t would = snprintf(zdb, len,
 	    "%s -bcc%s%s -G -d -Y -e -y %s -p %s %"PRIu64,
 	    bin,
 	    ztest_opts.zo_verbose >= 3 ? "s" : "",
 	    ztest_opts.zo_verbose >= 4 ? "v" : "",
 	    set_gvars_args_joined,
 	    ztest_opts.zo_dir,
 	    guid);
 	ASSERT3U(would, <, len);
 
 	umem_free(set_gvars_args_joined, strlen(set_gvars_args_joined) + 1);
 
 	if (ztest_opts.zo_verbose >= 5)
 		(void) printf("Executing %s\n", zdb);
 
 	fp = popen(zdb, "r");
 
 	while (fgets(zbuf, 1024, fp) != NULL)
 		if (ztest_opts.zo_verbose >= 3)
 			(void) printf("%s", zbuf);
 
 	status = pclose(fp);
 
 	if (status == 0)
 		goto out;
 
 	ztest_dump_core = 0;
 	if (WIFEXITED(status))
 		fatal(B_FALSE, "'%s' exit code %d", zdb, WEXITSTATUS(status));
 	else
 		fatal(B_FALSE, "'%s' died with signal %d",
 		    zdb, WTERMSIG(status));
 out:
 	umem_free(bin, len);
 	umem_free(zdb, len);
 	umem_free(zbuf, 1024);
 }
 
 static void
 ztest_walk_pool_directory(const char *header)
 {
 	spa_t *spa = NULL;
 
 	if (ztest_opts.zo_verbose >= 6)
 		(void) puts(header);
 
 	mutex_enter(&spa_namespace_lock);
 	while ((spa = spa_next(spa)) != NULL)
 		if (ztest_opts.zo_verbose >= 6)
 			(void) printf("\t%s\n", spa_name(spa));
 	mutex_exit(&spa_namespace_lock);
 }
 
 static void
 ztest_spa_import_export(char *oldname, char *newname)
 {
 	nvlist_t *config, *newconfig;
 	uint64_t pool_guid;
 	spa_t *spa;
 	int error;
 
 	if (ztest_opts.zo_verbose >= 4) {
 		(void) printf("import/export: old = %s, new = %s\n",
 		    oldname, newname);
 	}
 
 	/*
 	 * Clean up from previous runs.
 	 */
 	(void) spa_destroy(newname);
 
 	/*
 	 * Get the pool's configuration and guid.
 	 */
 	VERIFY0(spa_open(oldname, &spa, FTAG));
 
 	/*
 	 * Kick off a scrub to tickle scrub/export races.
 	 */
 	if (ztest_random(2) == 0)
 		(void) spa_scan(spa, POOL_SCAN_SCRUB);
 
 	pool_guid = spa_guid(spa);
 	spa_close(spa, FTAG);
 
 	ztest_walk_pool_directory("pools before export");
 
 	/*
 	 * Export it.
 	 */
 	VERIFY0(spa_export(oldname, &config, B_FALSE, B_FALSE));
 
 	ztest_walk_pool_directory("pools after export");
 
 	/*
 	 * Try to import it.
 	 */
 	newconfig = spa_tryimport(config);
 	ASSERT3P(newconfig, !=, NULL);
 	fnvlist_free(newconfig);
 
 	/*
 	 * Import it under the new name.
 	 */
 	error = spa_import(newname, config, NULL, 0);
 	if (error != 0) {
 		dump_nvlist(config, 0);
 		fatal(B_FALSE, "couldn't import pool %s as %s: error %u",
 		    oldname, newname, error);
 	}
 
 	ztest_walk_pool_directory("pools after import");
 
 	/*
 	 * Try to import it again -- should fail with EEXIST.
 	 */
 	VERIFY3U(EEXIST, ==, spa_import(newname, config, NULL, 0));
 
 	/*
 	 * Try to import it under a different name -- should fail with EEXIST.
 	 */
 	VERIFY3U(EEXIST, ==, spa_import(oldname, config, NULL, 0));
 
 	/*
 	 * Verify that the pool is no longer visible under the old name.
 	 */
 	VERIFY3U(ENOENT, ==, spa_open(oldname, &spa, FTAG));
 
 	/*
 	 * Verify that we can open and close the pool using the new name.
 	 */
 	VERIFY0(spa_open(newname, &spa, FTAG));
 	ASSERT3U(pool_guid, ==, spa_guid(spa));
 	spa_close(spa, FTAG);
 
 	fnvlist_free(config);
 }
 
 static void
 ztest_resume(spa_t *spa)
 {
 	if (spa_suspended(spa) && ztest_opts.zo_verbose >= 6)
 		(void) printf("resuming from suspended state\n");
 	spa_vdev_state_enter(spa, SCL_NONE);
 	vdev_clear(spa, NULL);
 	(void) spa_vdev_state_exit(spa, NULL, 0);
 	(void) zio_resume(spa);
 }
 
 static __attribute__((noreturn)) void
 ztest_resume_thread(void *arg)
 {
 	spa_t *spa = arg;
 
 	/*
 	 * Synthesize aged DDT entries for ddt prune testing
 	 */
 	ddt_prune_artificial_age = B_TRUE;
 	if (ztest_opts.zo_verbose >= 3)
 		ddt_dump_prune_histogram = B_TRUE;
 
 	while (!ztest_exiting) {
 		if (spa_suspended(spa))
 			ztest_resume(spa);
 		(void) poll(NULL, 0, 100);
 
 		/*
 		 * Periodically change the zfs_compressed_arc_enabled setting.
 		 */
 		if (ztest_random(10) == 0)
 			zfs_compressed_arc_enabled = ztest_random(2);
 
 		/*
 		 * Periodically change the zfs_abd_scatter_enabled setting.
 		 */
 		if (ztest_random(10) == 0)
 			zfs_abd_scatter_enabled = ztest_random(2);
 	}
 
 	thread_exit();
 }
 
 static __attribute__((noreturn)) void
 ztest_deadman_thread(void *arg)
 {
 	ztest_shared_t *zs = arg;
 	spa_t *spa = ztest_spa;
 	hrtime_t delay, overdue, last_run = gethrtime();
 
 	delay = (zs->zs_thread_stop - zs->zs_thread_start) +
 	    MSEC2NSEC(zfs_deadman_synctime_ms);
 
 	while (!ztest_exiting) {
 		/*
 		 * Wait for the delay timer while checking occasionally
 		 * if we should stop.
 		 */
 		if (gethrtime() < last_run + delay) {
 			(void) poll(NULL, 0, 1000);
 			continue;
 		}
 
 		/*
 		 * If the pool is suspended then fail immediately. Otherwise,
 		 * check to see if the pool is making any progress. If
 		 * vdev_deadman() discovers that there hasn't been any recent
 		 * I/Os then it will end up aborting the tests.
 		 */
 		if (spa_suspended(spa) || spa->spa_root_vdev == NULL) {
 			fatal(B_FALSE,
 			    "aborting test after %llu seconds because "
 			    "pool has transitioned to a suspended state.",
 			    (u_longlong_t)zfs_deadman_synctime_ms / 1000);
 		}
 		vdev_deadman(spa->spa_root_vdev, FTAG);
 
 		/*
 		 * If the process doesn't complete within a grace period of
 		 * zfs_deadman_synctime_ms over the expected finish time,
 		 * then it may be hung and is terminated.
 		 */
 		overdue = zs->zs_proc_stop + MSEC2NSEC(zfs_deadman_synctime_ms);
 		if (gethrtime() > overdue) {
 			fatal(B_FALSE,
 			    "aborting test after %llu seconds because "
 			    "the process is overdue for termination.",
 			    (gethrtime() - zs->zs_proc_start) / NANOSEC);
 		}
 
 		(void) printf("ztest has been running for %lld seconds\n",
 		    (gethrtime() - zs->zs_proc_start) / NANOSEC);
 
 		last_run = gethrtime();
 		delay = MSEC2NSEC(zfs_deadman_checktime_ms);
 	}
 
 	thread_exit();
 }
 
 static void
 ztest_execute(int test, ztest_info_t *zi, uint64_t id)
 {
 	ztest_ds_t *zd = &ztest_ds[id % ztest_opts.zo_datasets];
 	ztest_shared_callstate_t *zc = ZTEST_GET_SHARED_CALLSTATE(test);
 	hrtime_t functime = gethrtime();
 	int i;
 
 	for (i = 0; i < zi->zi_iters; i++)
 		zi->zi_func(zd, id);
 
 	functime = gethrtime() - functime;
 
 	atomic_add_64(&zc->zc_count, 1);
 	atomic_add_64(&zc->zc_time, functime);
 
 	if (ztest_opts.zo_verbose >= 4)
 		(void) printf("%6.2f sec in %s\n",
 		    (double)functime / NANOSEC, zi->zi_funcname);
 }
 
 typedef struct ztest_raidz_expand_io {
 	uint64_t	rzx_id;
 	uint64_t	rzx_amount;
 	uint64_t	rzx_bufsize;
 	const void	*rzx_buffer;
 	uint64_t	rzx_alloc_max;
 	spa_t		*rzx_spa;
 } ztest_expand_io_t;
 
 #undef OD_ARRAY_SIZE
 #define	OD_ARRAY_SIZE	10
 
 /*
  * Write a request amount of data to some dataset objects.
  * There will be ztest_opts.zo_threads count of these running in parallel.
  */
 static __attribute__((noreturn)) void
 ztest_rzx_thread(void *arg)
 {
 	ztest_expand_io_t *info = (ztest_expand_io_t *)arg;
 	ztest_od_t *od;
 	int batchsize;
 	int od_size;
 	ztest_ds_t *zd = &ztest_ds[info->rzx_id % ztest_opts.zo_datasets];
 	spa_t *spa = info->rzx_spa;
 
 	od_size = sizeof (ztest_od_t) * OD_ARRAY_SIZE;
 	od = umem_alloc(od_size, UMEM_NOFAIL);
 	batchsize = OD_ARRAY_SIZE;
 
 	/* Create objects to write to */
 	for (int b = 0; b < batchsize; b++) {
 		ztest_od_init(od + b, info->rzx_id, FTAG, b,
 		    DMU_OT_UINT64_OTHER, 0, 0, 0);
 	}
 	if (ztest_object_init(zd, od, od_size, B_FALSE) != 0) {
 		umem_free(od, od_size);
 		thread_exit();
 	}
 
 	for (uint64_t offset = 0, written = 0; written < info->rzx_amount;
 	    offset += info->rzx_bufsize) {
 		/* write to 10 objects */
 		for (int i = 0; i < batchsize && written < info->rzx_amount;
 		    i++) {
 			(void) pthread_rwlock_rdlock(&zd->zd_zilog_lock);
 			ztest_write(zd, od[i].od_object, offset,
 			    info->rzx_bufsize, info->rzx_buffer);
 			(void) pthread_rwlock_unlock(&zd->zd_zilog_lock);
 			written += info->rzx_bufsize;
 		}
 		txg_wait_synced(spa_get_dsl(spa), 0);
 		/* due to inflation, we'll typically bail here */
 		if (metaslab_class_get_alloc(spa_normal_class(spa)) >
 		    info->rzx_alloc_max) {
 			break;
 		}
 	}
 
 	/* Remove a few objects to leave some holes in allocation space */
 	mutex_enter(&zd->zd_dirobj_lock);
 	(void) ztest_remove(zd, od, 2);
 	mutex_exit(&zd->zd_dirobj_lock);
 
 	umem_free(od, od_size);
 
 	thread_exit();
 }
 
 static __attribute__((noreturn)) void
 ztest_thread(void *arg)
 {
 	int rand;
 	uint64_t id = (uintptr_t)arg;
 	ztest_shared_t *zs = ztest_shared;
 	uint64_t call_next;
 	hrtime_t now;
 	ztest_info_t *zi;
 	ztest_shared_callstate_t *zc;
 
 	while ((now = gethrtime()) < zs->zs_thread_stop) {
 		/*
 		 * See if it's time to force a crash.
 		 */
 		if (now > zs->zs_thread_kill &&
 		    raidz_expand_pause_point == RAIDZ_EXPAND_PAUSE_NONE) {
 			ztest_kill(zs);
 		}
 
 		/*
 		 * If we're getting ENOSPC with some regularity, stop.
 		 */
 		if (zs->zs_enospc_count > 10)
 			break;
 
 		/*
 		 * Pick a random function to execute.
 		 */
 		rand = ztest_random(ZTEST_FUNCS);
 		zi = &ztest_info[rand];
 		zc = ZTEST_GET_SHARED_CALLSTATE(rand);
 		call_next = zc->zc_next;
 
 		if (now >= call_next &&
 		    atomic_cas_64(&zc->zc_next, call_next, call_next +
 		    ztest_random(2 * zi->zi_interval[0] + 1)) == call_next) {
 			ztest_execute(rand, zi, id);
 		}
 	}
 
 	thread_exit();
 }
 
 static void
 ztest_dataset_name(char *dsname, const char *pool, int d)
 {
 	(void) snprintf(dsname, ZFS_MAX_DATASET_NAME_LEN, "%s/ds_%d", pool, d);
 }
 
 static void
 ztest_dataset_destroy(int d)
 {
 	char name[ZFS_MAX_DATASET_NAME_LEN];
 	int t;
 
 	ztest_dataset_name(name, ztest_opts.zo_pool, d);
 
 	if (ztest_opts.zo_verbose >= 3)
 		(void) printf("Destroying %s to free up space\n", name);
 
 	/*
 	 * Cleanup any non-standard clones and snapshots.  In general,
 	 * ztest thread t operates on dataset (t % zopt_datasets),
 	 * so there may be more than one thing to clean up.
 	 */
 	for (t = d; t < ztest_opts.zo_threads;
 	    t += ztest_opts.zo_datasets)
 		ztest_dsl_dataset_cleanup(name, t);
 
 	(void) dmu_objset_find(name, ztest_objset_destroy_cb, NULL,
 	    DS_FIND_SNAPSHOTS | DS_FIND_CHILDREN);
 }
 
 static void
 ztest_dataset_dirobj_verify(ztest_ds_t *zd)
 {
 	uint64_t usedobjs, dirobjs, scratch;
 
 	/*
 	 * ZTEST_DIROBJ is the object directory for the entire dataset.
 	 * Therefore, the number of objects in use should equal the
 	 * number of ZTEST_DIROBJ entries, +1 for ZTEST_DIROBJ itself.
 	 * If not, we have an object leak.
 	 *
 	 * Note that we can only check this in ztest_dataset_open(),
 	 * when the open-context and syncing-context values agree.
 	 * That's because zap_count() returns the open-context value,
 	 * while dmu_objset_space() returns the rootbp fill count.
 	 */
 	VERIFY0(zap_count(zd->zd_os, ZTEST_DIROBJ, &dirobjs));
 	dmu_objset_space(zd->zd_os, &scratch, &scratch, &usedobjs, &scratch);
 	ASSERT3U(dirobjs + 1, ==, usedobjs);
 }
 
 static int
 ztest_dataset_open(int d)
 {
 	ztest_ds_t *zd = &ztest_ds[d];
 	uint64_t committed_seq = ZTEST_GET_SHARED_DS(d)->zd_seq;
 	objset_t *os;
 	zilog_t *zilog;
 	char name[ZFS_MAX_DATASET_NAME_LEN];
 	int error;
 
 	ztest_dataset_name(name, ztest_opts.zo_pool, d);
 
 	(void) pthread_rwlock_rdlock(&ztest_name_lock);
 
 	error = ztest_dataset_create(name);
 	if (error == ENOSPC) {
 		(void) pthread_rwlock_unlock(&ztest_name_lock);
 		ztest_record_enospc(FTAG);
 		return (error);
 	}
 	ASSERT(error == 0 || error == EEXIST);
 
 	VERIFY0(ztest_dmu_objset_own(name, DMU_OST_OTHER, B_FALSE,
 	    B_TRUE, zd, &os));
 	(void) pthread_rwlock_unlock(&ztest_name_lock);
 
 	ztest_zd_init(zd, ZTEST_GET_SHARED_DS(d), os);
 
 	zilog = zd->zd_zilog;
 
 	if (zilog->zl_header->zh_claim_lr_seq != 0 &&
 	    zilog->zl_header->zh_claim_lr_seq < committed_seq)
 		fatal(B_FALSE, "missing log records: "
 		    "claimed %"PRIu64" < committed %"PRIu64"",
 		    zilog->zl_header->zh_claim_lr_seq, committed_seq);
 
 	ztest_dataset_dirobj_verify(zd);
 
 	zil_replay(os, zd, ztest_replay_vector);
 
 	ztest_dataset_dirobj_verify(zd);
 
 	if (ztest_opts.zo_verbose >= 6)
 		(void) printf("%s replay %"PRIu64" blocks, "
 		    "%"PRIu64" records, seq %"PRIu64"\n",
 		    zd->zd_name,
 		    zilog->zl_parse_blk_count,
 		    zilog->zl_parse_lr_count,
 		    zilog->zl_replaying_seq);
 
 	zilog = zil_open(os, ztest_get_data, NULL);
 
 	if (zilog->zl_replaying_seq != 0 &&
 	    zilog->zl_replaying_seq < committed_seq)
 		fatal(B_FALSE, "missing log records: "
 		    "replayed %"PRIu64" < committed %"PRIu64"",
 		    zilog->zl_replaying_seq, committed_seq);
 
 	return (0);
 }
 
 static void
 ztest_dataset_close(int d)
 {
 	ztest_ds_t *zd = &ztest_ds[d];
 
 	zil_close(zd->zd_zilog);
 	dmu_objset_disown(zd->zd_os, B_TRUE, zd);
 
 	ztest_zd_fini(zd);
 }
 
 static int
 ztest_replay_zil_cb(const char *name, void *arg)
 {
 	(void) arg;
 	objset_t *os;
 	ztest_ds_t *zdtmp;
 
 	VERIFY0(ztest_dmu_objset_own(name, DMU_OST_ANY, B_TRUE,
 	    B_TRUE, FTAG, &os));
 
 	zdtmp = umem_alloc(sizeof (ztest_ds_t), UMEM_NOFAIL);
 
 	ztest_zd_init(zdtmp, NULL, os);
 	zil_replay(os, zdtmp, ztest_replay_vector);
 	ztest_zd_fini(zdtmp);
 
 	if (dmu_objset_zil(os)->zl_parse_lr_count != 0 &&
 	    ztest_opts.zo_verbose >= 6) {
 		zilog_t *zilog = dmu_objset_zil(os);
 
 		(void) printf("%s replay %"PRIu64" blocks, "
 		    "%"PRIu64" records, seq %"PRIu64"\n",
 		    name,
 		    zilog->zl_parse_blk_count,
 		    zilog->zl_parse_lr_count,
 		    zilog->zl_replaying_seq);
 	}
 
 	umem_free(zdtmp, sizeof (ztest_ds_t));
 
 	dmu_objset_disown(os, B_TRUE, FTAG);
 	return (0);
 }
 
 static void
 ztest_freeze(void)
 {
 	ztest_ds_t *zd = &ztest_ds[0];
 	spa_t *spa;
 	int numloops = 0;
 
 	/* freeze not supported during RAIDZ expansion */
 	if (ztest_opts.zo_raid_do_expand)
 		return;
 
 	if (ztest_opts.zo_verbose >= 3)
 		(void) printf("testing spa_freeze()...\n");
 
 	raidz_scratch_verify();
 	kernel_init(SPA_MODE_READ | SPA_MODE_WRITE);
 	VERIFY0(spa_open(ztest_opts.zo_pool, &spa, FTAG));
 	VERIFY0(ztest_dataset_open(0));
 	ztest_spa = spa;
 
 	/*
 	 * Force the first log block to be transactionally allocated.
 	 * We have to do this before we freeze the pool -- otherwise
 	 * the log chain won't be anchored.
 	 */
 	while (BP_IS_HOLE(&zd->zd_zilog->zl_header->zh_log)) {
 		ztest_dmu_object_alloc_free(zd, 0);
 		zil_commit(zd->zd_zilog, 0);
 	}
 
 	txg_wait_synced(spa_get_dsl(spa), 0);
 
 	/*
 	 * Freeze the pool.  This stops spa_sync() from doing anything,
 	 * so that the only way to record changes from now on is the ZIL.
 	 */
 	spa_freeze(spa);
 
 	/*
 	 * Because it is hard to predict how much space a write will actually
 	 * require beforehand, we leave ourselves some fudge space to write over
 	 * capacity.
 	 */
 	uint64_t capacity = metaslab_class_get_space(spa_normal_class(spa)) / 2;
 
 	/*
 	 * Run tests that generate log records but don't alter the pool config
 	 * or depend on DSL sync tasks (snapshots, objset create/destroy, etc).
 	 * We do a txg_wait_synced() after each iteration to force the txg
 	 * to increase well beyond the last synced value in the uberblock.
 	 * The ZIL should be OK with that.
 	 *
 	 * Run a random number of times less than zo_maxloops and ensure we do
 	 * not run out of space on the pool.
 	 */
 	while (ztest_random(10) != 0 &&
 	    numloops++ < ztest_opts.zo_maxloops &&
 	    metaslab_class_get_alloc(spa_normal_class(spa)) < capacity) {
 		ztest_od_t od;
 		ztest_od_init(&od, 0, FTAG, 0, DMU_OT_UINT64_OTHER, 0, 0, 0);
 		VERIFY0(ztest_object_init(zd, &od, sizeof (od), B_FALSE));
 		ztest_io(zd, od.od_object,
 		    ztest_random(ZTEST_RANGE_LOCKS) << SPA_MAXBLOCKSHIFT);
 		txg_wait_synced(spa_get_dsl(spa), 0);
 	}
 
 	/*
 	 * Commit all of the changes we just generated.
 	 */
 	zil_commit(zd->zd_zilog, 0);
 	txg_wait_synced(spa_get_dsl(spa), 0);
 
 	/*
 	 * Close our dataset and close the pool.
 	 */
 	ztest_dataset_close(0);
 	spa_close(spa, FTAG);
 	kernel_fini();
 
 	/*
 	 * Open and close the pool and dataset to induce log replay.
 	 */
 	raidz_scratch_verify();
 	kernel_init(SPA_MODE_READ | SPA_MODE_WRITE);
 	VERIFY0(spa_open(ztest_opts.zo_pool, &spa, FTAG));
 	ASSERT3U(spa_freeze_txg(spa), ==, UINT64_MAX);
 	VERIFY0(ztest_dataset_open(0));
 	ztest_spa = spa;
 	txg_wait_synced(spa_get_dsl(spa), 0);
 	ztest_dataset_close(0);
 	ztest_reguid(NULL, 0);
 
 	spa_close(spa, FTAG);
 	kernel_fini();
 }
 
 static void
 ztest_import_impl(void)
 {
 	importargs_t args = { 0 };
 	nvlist_t *cfg = NULL;
 	int nsearch = 1;
 	char *searchdirs[nsearch];
 	int flags = ZFS_IMPORT_MISSING_LOG;
 
 	searchdirs[0] = ztest_opts.zo_dir;
 	args.paths = nsearch;
 	args.path = searchdirs;
 	args.can_be_active = B_FALSE;
 
 	libpc_handle_t lpch = {
 		.lpc_lib_handle = NULL,
 		.lpc_ops = &libzpool_config_ops,
 		.lpc_printerr = B_TRUE
 	};
 	VERIFY0(zpool_find_config(&lpch, ztest_opts.zo_pool, &cfg, &args));
 	VERIFY0(spa_import(ztest_opts.zo_pool, cfg, NULL, flags));
 	fnvlist_free(cfg);
 }
 
 /*
  * Import a storage pool with the given name.
  */
 static void
 ztest_import(ztest_shared_t *zs)
 {
 	spa_t *spa;
 
 	mutex_init(&ztest_vdev_lock, NULL, MUTEX_DEFAULT, NULL);
 	mutex_init(&ztest_checkpoint_lock, NULL, MUTEX_DEFAULT, NULL);
 	VERIFY0(pthread_rwlock_init(&ztest_name_lock, NULL));
 
 	raidz_scratch_verify();
 	kernel_init(SPA_MODE_READ | SPA_MODE_WRITE);
 
 	ztest_import_impl();
 
 	VERIFY0(spa_open(ztest_opts.zo_pool, &spa, FTAG));
 	zs->zs_metaslab_sz =
 	    1ULL << spa->spa_root_vdev->vdev_child[0]->vdev_ms_shift;
 	zs->zs_guid = spa_guid(spa);
 	spa_close(spa, FTAG);
 
 	kernel_fini();
 
 	if (!ztest_opts.zo_mmp_test) {
 		ztest_run_zdb(zs->zs_guid);
 		ztest_freeze();
 		ztest_run_zdb(zs->zs_guid);
 	}
 
 	(void) pthread_rwlock_destroy(&ztest_name_lock);
 	mutex_destroy(&ztest_vdev_lock);
 	mutex_destroy(&ztest_checkpoint_lock);
 }
 
 /*
  * After the expansion was killed, check that the pool is healthy
  */
 static void
 ztest_raidz_expand_check(spa_t *spa)
 {
 	ASSERT3U(ztest_opts.zo_raidz_expand_test, ==, RAIDZ_EXPAND_KILLED);
 	/*
 	 * Set pool check done flag, main program will run a zdb check
 	 * of the pool when we exit.
 	 */
 	ztest_shared_opts->zo_raidz_expand_test = RAIDZ_EXPAND_CHECKED;
 
 	/* Wait for reflow to finish */
 	if (ztest_opts.zo_verbose >= 1) {
 		(void) printf("\nwaiting for reflow to finish ...\n");
 	}
 	pool_raidz_expand_stat_t rzx_stats;
 	pool_raidz_expand_stat_t *pres = &rzx_stats;
 	do {
 		txg_wait_synced(spa_get_dsl(spa), 0);
 		(void) poll(NULL, 0, 500); /* wait 1/2 second */
 
 		spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
 		(void) spa_raidz_expand_get_stats(spa, pres);
 		spa_config_exit(spa, SCL_CONFIG, FTAG);
 	} while (pres->pres_state != DSS_FINISHED &&
 	    pres->pres_reflowed < pres->pres_to_reflow);
 
 	if (ztest_opts.zo_verbose >= 1) {
 		(void) printf("verifying an interrupted raidz "
 		    "expansion using a pool scrub ...\n");
 	}
+
 	/* Will fail here if there is non-recoverable corruption detected */
-	VERIFY0(ztest_scrub_impl(spa));
+	int error = ztest_scrub_impl(spa);
+	if (error == EBUSY)
+		error = 0;
+
+	VERIFY0(error);
+
 	if (ztest_opts.zo_verbose >= 1) {
 		(void) printf("raidz expansion scrub check complete\n");
 	}
 }
 
 /*
  * Start a raidz expansion test.  We run some I/O on the pool for a while
  * to get some data in the pool.  Then we grow the raidz and
  * kill the test at the requested offset into the reflow, verifying that
  * doing such does not lead to pool corruption.
  */
 static void
 ztest_raidz_expand_run(ztest_shared_t *zs, spa_t *spa)
 {
 	nvlist_t *root;
 	pool_raidz_expand_stat_t rzx_stats;
 	pool_raidz_expand_stat_t *pres = &rzx_stats;
 	kthread_t **run_threads;
 	vdev_t *cvd, *rzvd = spa->spa_root_vdev->vdev_child[0];
 	int total_disks = rzvd->vdev_children;
 	int data_disks = total_disks - vdev_get_nparity(rzvd);
 	uint64_t alloc_goal;
 	uint64_t csize;
 	int error, t;
 	int threads = ztest_opts.zo_threads;
 	ztest_expand_io_t *thread_args;
 
 	ASSERT3U(ztest_opts.zo_raidz_expand_test, !=, RAIDZ_EXPAND_NONE);
 	ASSERT3P(rzvd->vdev_ops, ==, &vdev_raidz_ops);
 	ztest_opts.zo_raidz_expand_test = RAIDZ_EXPAND_STARTED;
 
 	/* Setup a 1 MiB buffer of random data */
 	uint64_t bufsize = 1024 * 1024;
 	void *buffer = umem_alloc(bufsize, UMEM_NOFAIL);
 
 	if (read(ztest_fd_rand, buffer, bufsize) != bufsize) {
 		fatal(B_TRUE, "short read from /dev/urandom");
 	}
 	/*
 	 * Put some data in the pool and then attach a vdev to initiate
 	 * reflow.
 	 */
 	run_threads = umem_zalloc(threads * sizeof (kthread_t *), UMEM_NOFAIL);
 	thread_args = umem_zalloc(threads * sizeof (ztest_expand_io_t),
 	    UMEM_NOFAIL);
 	/* Aim for roughly 25% of allocatable space up to 1GB */
 	alloc_goal = (vdev_get_min_asize(rzvd) * data_disks) / total_disks;
 	alloc_goal = MIN(alloc_goal >> 2, 1024*1024*1024);
 	if (ztest_opts.zo_verbose >= 1) {
 		(void) printf("adding data to pool '%s', goal %llu bytes\n",
 		    ztest_opts.zo_pool, (u_longlong_t)alloc_goal);
 	}
 
 	/*
 	 * Kick off all the I/O generators that run in parallel.
 	 */
 	for (t = 0; t < threads; t++) {
 		if (t < ztest_opts.zo_datasets && ztest_dataset_open(t) != 0) {
 			umem_free(run_threads, threads * sizeof (kthread_t *));
 			umem_free(buffer, bufsize);
 			return;
 		}
 		thread_args[t].rzx_id = t;
 		thread_args[t].rzx_amount = alloc_goal / threads;
 		thread_args[t].rzx_bufsize = bufsize;
 		thread_args[t].rzx_buffer = buffer;
 		thread_args[t].rzx_alloc_max = alloc_goal;
 		thread_args[t].rzx_spa = spa;
 		run_threads[t] = thread_create(NULL, 0, ztest_rzx_thread,
 		    &thread_args[t], 0, NULL, TS_RUN | TS_JOINABLE,
 		    defclsyspri);
 	}
 
 	/*
 	 * Wait for all of the writers to complete.
 	 */
 	for (t = 0; t < threads; t++)
 		VERIFY0(thread_join(run_threads[t]));
 
 	/*
 	 * Close all datasets. This must be done after all the threads
 	 * are joined so we can be sure none of the datasets are in-use
 	 * by any of the threads.
 	 */
 	for (t = 0; t < ztest_opts.zo_threads; t++) {
 		if (t < ztest_opts.zo_datasets)
 			ztest_dataset_close(t);
 	}
 
 	txg_wait_synced(spa_get_dsl(spa), 0);
 
 	zs->zs_alloc = metaslab_class_get_alloc(spa_normal_class(spa));
 	zs->zs_space = metaslab_class_get_space(spa_normal_class(spa));
 
 	umem_free(buffer, bufsize);
 	umem_free(run_threads, threads * sizeof (kthread_t *));
 	umem_free(thread_args, threads * sizeof (ztest_expand_io_t));
 
 	/* Set our reflow target to 25%, 50% or 75% of allocated size */
 	uint_t multiple = ztest_random(3) + 1;
 	uint64_t reflow_max = (rzvd->vdev_stat.vs_alloc * multiple) / 4;
 	raidz_expand_max_reflow_bytes = reflow_max;
 
 	if (ztest_opts.zo_verbose >= 1) {
 		(void) printf("running raidz expansion test, killing when "
 		    "reflow reaches %llu bytes (%u/4 of allocated space)\n",
 		    (u_longlong_t)reflow_max, multiple);
 	}
 
 	/* XXX - do we want some I/O load during the reflow? */
 
 	/*
 	 * Use a disk size that is larger than existing ones
 	 */
 	cvd = rzvd->vdev_child[0];
 	csize = vdev_get_min_asize(cvd);
 	csize += csize / 10;
 	/*
 	 * Path to vdev to be attached
 	 */
 	char *newpath = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
 	(void) snprintf(newpath, MAXPATHLEN, ztest_dev_template,
 	    ztest_opts.zo_dir, ztest_opts.zo_pool, rzvd->vdev_children);
 	/*
 	 * Build the nvlist describing newpath.
 	 */
 	root = make_vdev_root(newpath, NULL, NULL, csize, ztest_get_ashift(),
 	    NULL, 0, 0, 1);
 	/*
 	 * Expand the raidz vdev by attaching the new disk
 	 */
 	if (ztest_opts.zo_verbose >= 1) {
 		(void) printf("expanding raidz: %d wide to %d wide with '%s'\n",
 		    (int)rzvd->vdev_children, (int)rzvd->vdev_children + 1,
 		    newpath);
 	}
 	error = spa_vdev_attach(spa, rzvd->vdev_guid, root, B_FALSE, B_FALSE);
 	nvlist_free(root);
 	if (error != 0) {
 		fatal(0, "raidz expand: attach (%s %llu) returned %d",
 		    newpath, (long long)csize, error);
 	}
 
 	/*
 	 * Wait for reflow to begin
 	 */
 	while (spa->spa_raidz_expand == NULL) {
 		txg_wait_synced(spa_get_dsl(spa), 0);
 		(void) poll(NULL, 0, 100); /* wait 1/10 second */
 	}
 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
 	(void) spa_raidz_expand_get_stats(spa, pres);
 	spa_config_exit(spa, SCL_CONFIG, FTAG);
 	while (pres->pres_state != DSS_SCANNING) {
 		txg_wait_synced(spa_get_dsl(spa), 0);
 		(void) poll(NULL, 0, 100); /* wait 1/10 second */
 		spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
 		(void) spa_raidz_expand_get_stats(spa, pres);
 		spa_config_exit(spa, SCL_CONFIG, FTAG);
 	}
 
 	ASSERT3U(pres->pres_state, ==, DSS_SCANNING);
 	ASSERT3U(pres->pres_to_reflow, !=, 0);
 	/*
 	 * Set so when we are killed we go to raidz checking rather than
 	 * restarting test.
 	 */
 	ztest_shared_opts->zo_raidz_expand_test = RAIDZ_EXPAND_KILLED;
 	if (ztest_opts.zo_verbose >= 1) {
 		(void) printf("raidz expansion reflow started, waiting for "
 		    "%llu bytes to be copied\n", (u_longlong_t)reflow_max);
 	}
 
 	/*
 	 * Wait for reflow maximum to be reached and then kill the test
 	 */
 	while (pres->pres_reflowed < reflow_max) {
 		txg_wait_synced(spa_get_dsl(spa), 0);
 		(void) poll(NULL, 0, 100); /* wait 1/10 second */
 		spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
 		(void) spa_raidz_expand_get_stats(spa, pres);
 		spa_config_exit(spa, SCL_CONFIG, FTAG);
 	}
 
 	/* Reset the reflow pause before killing */
 	raidz_expand_max_reflow_bytes = 0;
 
 	if (ztest_opts.zo_verbose >= 1) {
 		(void) printf("killing raidz expansion test after reflow "
 		    "reached %llu bytes\n", (u_longlong_t)pres->pres_reflowed);
 	}
 
 	/*
 	 * Kill ourself to simulate a panic during a reflow.  Our parent will
 	 * restart the test and the changed flag value will drive the test
 	 * through the scrub/check code to verify the pool is not corrupted.
 	 */
 	ztest_kill(zs);
 }
 
 static void
 ztest_generic_run(ztest_shared_t *zs, spa_t *spa)
 {
 	kthread_t **run_threads;
 	int t;
 
 	run_threads = umem_zalloc(ztest_opts.zo_threads * sizeof (kthread_t *),
 	    UMEM_NOFAIL);
 
 	/*
 	 * Kick off all the tests that run in parallel.
 	 */
 	for (t = 0; t < ztest_opts.zo_threads; t++) {
 		if (t < ztest_opts.zo_datasets && ztest_dataset_open(t) != 0) {
 			umem_free(run_threads, ztest_opts.zo_threads *
 			    sizeof (kthread_t *));
 			return;
 		}
 
 		run_threads[t] = thread_create(NULL, 0, ztest_thread,
 		    (void *)(uintptr_t)t, 0, NULL, TS_RUN | TS_JOINABLE,
 		    defclsyspri);
 	}
 
 	/*
 	 * Wait for all of the tests to complete.
 	 */
 	for (t = 0; t < ztest_opts.zo_threads; t++)
 		VERIFY0(thread_join(run_threads[t]));
 
 	/*
 	 * Close all datasets. This must be done after all the threads
 	 * are joined so we can be sure none of the datasets are in-use
 	 * by any of the threads.
 	 */
 	for (t = 0; t < ztest_opts.zo_threads; t++) {
 		if (t < ztest_opts.zo_datasets)
 			ztest_dataset_close(t);
 	}
 
 	txg_wait_synced(spa_get_dsl(spa), 0);
 
 	zs->zs_alloc = metaslab_class_get_alloc(spa_normal_class(spa));
 	zs->zs_space = metaslab_class_get_space(spa_normal_class(spa));
 
 	umem_free(run_threads, ztest_opts.zo_threads * sizeof (kthread_t *));
 }
 
 /*
  * Setup our test context and kick off threads to run tests on all datasets
  * in parallel.
  */
 static void
 ztest_run(ztest_shared_t *zs)
 {
 	spa_t *spa;
 	objset_t *os;
 	kthread_t *resume_thread, *deadman_thread;
 	uint64_t object;
 	int error;
 	int t, d;
 
 	ztest_exiting = B_FALSE;
 
 	/*
 	 * Initialize parent/child shared state.
 	 */
 	mutex_init(&ztest_vdev_lock, NULL, MUTEX_DEFAULT, NULL);
 	mutex_init(&ztest_checkpoint_lock, NULL, MUTEX_DEFAULT, NULL);
 	VERIFY0(pthread_rwlock_init(&ztest_name_lock, NULL));
 
 	zs->zs_thread_start = gethrtime();
 	zs->zs_thread_stop =
 	    zs->zs_thread_start + ztest_opts.zo_passtime * NANOSEC;
 	zs->zs_thread_stop = MIN(zs->zs_thread_stop, zs->zs_proc_stop);
 	zs->zs_thread_kill = zs->zs_thread_stop;
 	if (ztest_random(100) < ztest_opts.zo_killrate) {
 		zs->zs_thread_kill -=
 		    ztest_random(ztest_opts.zo_passtime * NANOSEC);
 	}
 
 	mutex_init(&zcl.zcl_callbacks_lock, NULL, MUTEX_DEFAULT, NULL);
 
 	list_create(&zcl.zcl_callbacks, sizeof (ztest_cb_data_t),
 	    offsetof(ztest_cb_data_t, zcd_node));
 
 	/*
 	 * Open our pool.  It may need to be imported first depending on
 	 * what tests were running when the previous pass was terminated.
 	 */
 	raidz_scratch_verify();
 	kernel_init(SPA_MODE_READ | SPA_MODE_WRITE);
 	error = spa_open(ztest_opts.zo_pool, &spa, FTAG);
 	if (error) {
 		VERIFY3S(error, ==, ENOENT);
 		ztest_import_impl();
 		VERIFY0(spa_open(ztest_opts.zo_pool, &spa, FTAG));
 		zs->zs_metaslab_sz =
 		    1ULL << spa->spa_root_vdev->vdev_child[0]->vdev_ms_shift;
 	}
 
 	metaslab_preload_limit = ztest_random(20) + 1;
 	ztest_spa = spa;
 
 	/*
 	 * XXX - BUGBUG raidz expansion do not run this for generic for now
 	 */
 	if (ztest_opts.zo_raidz_expand_test != RAIDZ_EXPAND_NONE)
 		VERIFY0(vdev_raidz_impl_set("cycle"));
 
 	dmu_objset_stats_t dds;
 	VERIFY0(ztest_dmu_objset_own(ztest_opts.zo_pool,
 	    DMU_OST_ANY, B_TRUE, B_TRUE, FTAG, &os));
 	dsl_pool_config_enter(dmu_objset_pool(os), FTAG);
 	dmu_objset_fast_stat(os, &dds);
 	dsl_pool_config_exit(dmu_objset_pool(os), FTAG);
 	dmu_objset_disown(os, B_TRUE, FTAG);
 
 	/* Give the dedicated raidz expansion test more grace time */
 	if (ztest_opts.zo_raidz_expand_test != RAIDZ_EXPAND_NONE)
 		zfs_deadman_synctime_ms *= 2;
 
 	/*
 	 * Create a thread to periodically resume suspended I/O.
 	 */
 	resume_thread = thread_create(NULL, 0, ztest_resume_thread,
 	    spa, 0, NULL, TS_RUN | TS_JOINABLE, defclsyspri);
 
 	/*
 	 * Create a deadman thread and set to panic if we hang.
 	 */
 	deadman_thread = thread_create(NULL, 0, ztest_deadman_thread,
 	    zs, 0, NULL, TS_RUN | TS_JOINABLE, defclsyspri);
 
 	spa->spa_deadman_failmode = ZIO_FAILURE_MODE_PANIC;
 
 	/*
 	 * Verify that we can safely inquire about any object,
 	 * whether it's allocated or not.  To make it interesting,
 	 * we probe a 5-wide window around each power of two.
 	 * This hits all edge cases, including zero and the max.
 	 */
 	for (t = 0; t < 64; t++) {
 		for (d = -5; d <= 5; d++) {
 			error = dmu_object_info(spa->spa_meta_objset,
 			    (1ULL << t) + d, NULL);
 			ASSERT(error == 0 || error == ENOENT ||
 			    error == EINVAL);
 		}
 	}
 
 	/*
 	 * If we got any ENOSPC errors on the previous run, destroy something.
 	 */
 	if (zs->zs_enospc_count != 0) {
 		/* Not expecting ENOSPC errors during raidz expansion tests */
 		ASSERT3U(ztest_opts.zo_raidz_expand_test, ==,
 		    RAIDZ_EXPAND_NONE);
 
 		int d = ztest_random(ztest_opts.zo_datasets);
 		ztest_dataset_destroy(d);
 	}
 	zs->zs_enospc_count = 0;
 
 	/*
 	 * If we were in the middle of ztest_device_removal() and were killed
 	 * we need to ensure the removal and scrub complete before running
 	 * any tests that check ztest_device_removal_active. The removal will
 	 * be restarted automatically when the spa is opened, but we need to
 	 * initiate the scrub manually if it is not already in progress. Note
 	 * that we always run the scrub whenever an indirect vdev exists
 	 * because we have no way of knowing for sure if ztest_device_removal()
 	 * fully completed its scrub before the pool was reimported.
 	 *
 	 * Does not apply for the RAIDZ expansion specific test runs
 	 */
 	if (ztest_opts.zo_raidz_expand_test == RAIDZ_EXPAND_NONE &&
 	    (spa->spa_removing_phys.sr_state == DSS_SCANNING ||
 	    spa->spa_removing_phys.sr_prev_indirect_vdev != -1)) {
 		while (spa->spa_removing_phys.sr_state == DSS_SCANNING)
 			txg_wait_synced(spa_get_dsl(spa), 0);
 
 		error = ztest_scrub_impl(spa);
 		if (error == EBUSY)
 			error = 0;
 		ASSERT0(error);
 	}
 
 	if (ztest_opts.zo_verbose >= 4)
 		(void) printf("starting main threads...\n");
 
 	/*
 	 * Replay all logs of all datasets in the pool. This is primarily for
 	 * temporary datasets which wouldn't otherwise get replayed, which
 	 * can trigger failures when attempting to offline a SLOG in
 	 * ztest_fault_inject().
 	 */
 	(void) dmu_objset_find(ztest_opts.zo_pool, ztest_replay_zil_cb,
 	    NULL, DS_FIND_CHILDREN);
 
 	if (ztest_opts.zo_raidz_expand_test == RAIDZ_EXPAND_REQUESTED)
 		ztest_raidz_expand_run(zs, spa);
 	else if (ztest_opts.zo_raidz_expand_test == RAIDZ_EXPAND_KILLED)
 		ztest_raidz_expand_check(spa);
 	else
 		ztest_generic_run(zs, spa);
 
 	/* Kill the resume and deadman threads */
 	ztest_exiting = B_TRUE;
 	VERIFY0(thread_join(resume_thread));
 	VERIFY0(thread_join(deadman_thread));
 	ztest_resume(spa);
 
 	/*
 	 * Right before closing the pool, kick off a bunch of async I/O;
 	 * spa_close() should wait for it to complete.
 	 */
 	for (object = 1; object < 50; object++) {
 		dmu_prefetch(spa->spa_meta_objset, object, 0, 0, 1ULL << 20,
 		    ZIO_PRIORITY_SYNC_READ);
 	}
 
 	/* Verify that at least one commit cb was called in a timely fashion */
 	if (zc_cb_counter >= ZTEST_COMMIT_CB_MIN_REG)
 		VERIFY0(zc_min_txg_delay);
 
 	spa_close(spa, FTAG);
 
 	/*
 	 * Verify that we can loop over all pools.
 	 */
 	mutex_enter(&spa_namespace_lock);
 	for (spa = spa_next(NULL); spa != NULL; spa = spa_next(spa))
 		if (ztest_opts.zo_verbose > 3)
 			(void) printf("spa_next: found %s\n", spa_name(spa));
 	mutex_exit(&spa_namespace_lock);
 
 	/*
 	 * Verify that we can export the pool and reimport it under a
 	 * different name.
 	 */
 	if ((ztest_random(2) == 0) && !ztest_opts.zo_mmp_test) {
 		char name[ZFS_MAX_DATASET_NAME_LEN];
 		(void) snprintf(name, sizeof (name), "%s_import",
 		    ztest_opts.zo_pool);
 		ztest_spa_import_export(ztest_opts.zo_pool, name);
 		ztest_spa_import_export(name, ztest_opts.zo_pool);
 	}
 
 	kernel_fini();
 
 	list_destroy(&zcl.zcl_callbacks);
 	mutex_destroy(&zcl.zcl_callbacks_lock);
 	(void) pthread_rwlock_destroy(&ztest_name_lock);
 	mutex_destroy(&ztest_vdev_lock);
 	mutex_destroy(&ztest_checkpoint_lock);
 }
 
 static void
 print_time(hrtime_t t, char *timebuf)
 {
 	hrtime_t s = t / NANOSEC;
 	hrtime_t m = s / 60;
 	hrtime_t h = m / 60;
 	hrtime_t d = h / 24;
 
 	s -= m * 60;
 	m -= h * 60;
 	h -= d * 24;
 
 	timebuf[0] = '\0';
 
 	if (d)
 		(void) sprintf(timebuf,
 		    "%llud%02lluh%02llum%02llus", d, h, m, s);
 	else if (h)
 		(void) sprintf(timebuf, "%lluh%02llum%02llus", h, m, s);
 	else if (m)
 		(void) sprintf(timebuf, "%llum%02llus", m, s);
 	else
 		(void) sprintf(timebuf, "%llus", s);
 }
 
 static nvlist_t *
 make_random_pool_props(void)
 {
 	nvlist_t *props;
 
 	props = fnvlist_alloc();
 
 	/* Twenty percent of the time enable ZPOOL_PROP_DEDUP_TABLE_QUOTA */
 	if (ztest_random(5) == 0) {
 		fnvlist_add_uint64(props,
 		    zpool_prop_to_name(ZPOOL_PROP_DEDUP_TABLE_QUOTA),
 		    2 * 1024 * 1024);
 	}
 
 	/* Fifty percent of the time enable ZPOOL_PROP_AUTOREPLACE */
 	if (ztest_random(2) == 0) {
 		fnvlist_add_uint64(props,
 		    zpool_prop_to_name(ZPOOL_PROP_AUTOREPLACE), 1);
 	}
 
 	return (props);
 }
 
 /*
  * Create a storage pool with the given name and initial vdev size.
  * Then test spa_freeze() functionality.
  */
 static void
 ztest_init(ztest_shared_t *zs)
 {
 	spa_t *spa;
 	nvlist_t *nvroot, *props;
 	int i;
 
 	mutex_init(&ztest_vdev_lock, NULL, MUTEX_DEFAULT, NULL);
 	mutex_init(&ztest_checkpoint_lock, NULL, MUTEX_DEFAULT, NULL);
 	VERIFY0(pthread_rwlock_init(&ztest_name_lock, NULL));
 
 	raidz_scratch_verify();
 	kernel_init(SPA_MODE_READ | SPA_MODE_WRITE);
 
 	/*
 	 * Create the storage pool.
 	 */
 	(void) spa_destroy(ztest_opts.zo_pool);
 	ztest_shared->zs_vdev_next_leaf = 0;
 	zs->zs_splits = 0;
 	zs->zs_mirrors = ztest_opts.zo_mirrors;
 	nvroot = make_vdev_root(NULL, NULL, NULL, ztest_opts.zo_vdev_size, 0,
 	    NULL, ztest_opts.zo_raid_children, zs->zs_mirrors, 1);
 	props = make_random_pool_props();
 
 	/*
 	 * We don't expect the pool to suspend unless maxfaults == 0,
 	 * in which case ztest_fault_inject() temporarily takes away
 	 * the only valid replica.
 	 */
 	fnvlist_add_uint64(props,
 	    zpool_prop_to_name(ZPOOL_PROP_FAILUREMODE),
 	    MAXFAULTS(zs) ? ZIO_FAILURE_MODE_PANIC : ZIO_FAILURE_MODE_WAIT);
 
 	for (i = 0; i < SPA_FEATURES; i++) {
 		char *buf;
 
 		if (!spa_feature_table[i].fi_zfs_mod_supported)
 			continue;
 
 		/*
 		 * 75% chance of using the log space map feature. We want ztest
 		 * to exercise both the code paths that use the log space map
 		 * feature and the ones that don't.
 		 */
 		if (i == SPA_FEATURE_LOG_SPACEMAP && ztest_random(4) == 0)
 			continue;
 
 		/*
 		 * split 50/50 between legacy and fast dedup
 		 */
 		if (i == SPA_FEATURE_FAST_DEDUP && ztest_random(2) != 0)
 			continue;
 
 		VERIFY3S(-1, !=, asprintf(&buf, "feature@%s",
 		    spa_feature_table[i].fi_uname));
 		fnvlist_add_uint64(props, buf, 0);
 		free(buf);
 	}
 
 	VERIFY0(spa_create(ztest_opts.zo_pool, nvroot, props, NULL, NULL));
 	fnvlist_free(nvroot);
 	fnvlist_free(props);
 
 	VERIFY0(spa_open(ztest_opts.zo_pool, &spa, FTAG));
 	zs->zs_metaslab_sz =
 	    1ULL << spa->spa_root_vdev->vdev_child[0]->vdev_ms_shift;
 	zs->zs_guid = spa_guid(spa);
 	spa_close(spa, FTAG);
 
 	kernel_fini();
 
 	if (!ztest_opts.zo_mmp_test) {
 		ztest_run_zdb(zs->zs_guid);
 		ztest_freeze();
 		ztest_run_zdb(zs->zs_guid);
 	}
 
 	(void) pthread_rwlock_destroy(&ztest_name_lock);
 	mutex_destroy(&ztest_vdev_lock);
 	mutex_destroy(&ztest_checkpoint_lock);
 }
 
 static void
 setup_data_fd(void)
 {
 	static char ztest_name_data[] = "/tmp/ztest.data.XXXXXX";
 
 	ztest_fd_data = mkstemp(ztest_name_data);
 	ASSERT3S(ztest_fd_data, >=, 0);
 	(void) unlink(ztest_name_data);
 }
 
 static int
 shared_data_size(ztest_shared_hdr_t *hdr)
 {
 	int size;
 
 	size = hdr->zh_hdr_size;
 	size += hdr->zh_opts_size;
 	size += hdr->zh_size;
 	size += hdr->zh_stats_size * hdr->zh_stats_count;
 	size += hdr->zh_ds_size * hdr->zh_ds_count;
 	size += hdr->zh_scratch_state_size;
 
 	return (size);
 }
 
 static void
 setup_hdr(void)
 {
 	int size;
 	ztest_shared_hdr_t *hdr;
 
 	hdr = (void *)mmap(0, P2ROUNDUP(sizeof (*hdr), getpagesize()),
 	    PROT_READ | PROT_WRITE, MAP_SHARED, ztest_fd_data, 0);
 	ASSERT3P(hdr, !=, MAP_FAILED);
 
 	VERIFY0(ftruncate(ztest_fd_data, sizeof (ztest_shared_hdr_t)));
 
 	hdr->zh_hdr_size = sizeof (ztest_shared_hdr_t);
 	hdr->zh_opts_size = sizeof (ztest_shared_opts_t);
 	hdr->zh_size = sizeof (ztest_shared_t);
 	hdr->zh_stats_size = sizeof (ztest_shared_callstate_t);
 	hdr->zh_stats_count = ZTEST_FUNCS;
 	hdr->zh_ds_size = sizeof (ztest_shared_ds_t);
 	hdr->zh_ds_count = ztest_opts.zo_datasets;
 	hdr->zh_scratch_state_size = sizeof (ztest_shared_scratch_state_t);
 
 	size = shared_data_size(hdr);
 	VERIFY0(ftruncate(ztest_fd_data, size));
 
 	(void) munmap((caddr_t)hdr, P2ROUNDUP(sizeof (*hdr), getpagesize()));
 }
 
 static void
 setup_data(void)
 {
 	int size, offset;
 	ztest_shared_hdr_t *hdr;
 	uint8_t *buf;
 
 	hdr = (void *)mmap(0, P2ROUNDUP(sizeof (*hdr), getpagesize()),
 	    PROT_READ, MAP_SHARED, ztest_fd_data, 0);
 	ASSERT3P(hdr, !=, MAP_FAILED);
 
 	size = shared_data_size(hdr);
 
 	(void) munmap((caddr_t)hdr, P2ROUNDUP(sizeof (*hdr), getpagesize()));
 	hdr = ztest_shared_hdr = (void *)mmap(0, P2ROUNDUP(size, getpagesize()),
 	    PROT_READ | PROT_WRITE, MAP_SHARED, ztest_fd_data, 0);
 	ASSERT3P(hdr, !=, MAP_FAILED);
 	buf = (uint8_t *)hdr;
 
 	offset = hdr->zh_hdr_size;
 	ztest_shared_opts = (void *)&buf[offset];
 	offset += hdr->zh_opts_size;
 	ztest_shared = (void *)&buf[offset];
 	offset += hdr->zh_size;
 	ztest_shared_callstate = (void *)&buf[offset];
 	offset += hdr->zh_stats_size * hdr->zh_stats_count;
 	ztest_shared_ds = (void *)&buf[offset];
 	offset += hdr->zh_ds_size * hdr->zh_ds_count;
 	ztest_scratch_state = (void *)&buf[offset];
 }
 
 static boolean_t
 exec_child(char *cmd, char *libpath, boolean_t ignorekill, int *statusp)
 {
 	pid_t pid;
 	int status;
 	char *cmdbuf = NULL;
 
 	pid = fork();
 
 	if (cmd == NULL) {
 		cmdbuf = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
 		(void) strlcpy(cmdbuf, getexecname(), MAXPATHLEN);
 		cmd = cmdbuf;
 	}
 
 	if (pid == -1)
 		fatal(B_TRUE, "fork failed");
 
 	if (pid == 0) {	/* child */
 		char fd_data_str[12];
 
 		VERIFY3S(11, >=,
 		    snprintf(fd_data_str, 12, "%d", ztest_fd_data));
 		VERIFY0(setenv("ZTEST_FD_DATA", fd_data_str, 1));
 
 		if (libpath != NULL) {
 			const char *curlp = getenv("LD_LIBRARY_PATH");
 			if (curlp == NULL)
 				VERIFY0(setenv("LD_LIBRARY_PATH", libpath, 1));
 			else {
 				char *newlp = NULL;
 				VERIFY3S(-1, !=,
 				    asprintf(&newlp, "%s:%s", libpath, curlp));
 				VERIFY0(setenv("LD_LIBRARY_PATH", newlp, 1));
 				free(newlp);
 			}
 		}
 		(void) execl(cmd, cmd, (char *)NULL);
 		ztest_dump_core = B_FALSE;
 		fatal(B_TRUE, "exec failed: %s", cmd);
 	}
 
 	if (cmdbuf != NULL) {
 		umem_free(cmdbuf, MAXPATHLEN);
 		cmd = NULL;
 	}
 
 	while (waitpid(pid, &status, 0) != pid)
 		continue;
 	if (statusp != NULL)
 		*statusp = status;
 
 	if (WIFEXITED(status)) {
 		if (WEXITSTATUS(status) != 0) {
 			(void) fprintf(stderr, "child exited with code %d\n",
 			    WEXITSTATUS(status));
 			exit(2);
 		}
 		return (B_FALSE);
 	} else if (WIFSIGNALED(status)) {
 		if (!ignorekill || WTERMSIG(status) != SIGKILL) {
 			(void) fprintf(stderr, "child died with signal %d\n",
 			    WTERMSIG(status));
 			exit(3);
 		}
 		return (B_TRUE);
 	} else {
 		(void) fprintf(stderr, "something strange happened to child\n");
 		exit(4);
 	}
 }
 
 static void
 ztest_run_init(void)
 {
 	int i;
 
 	ztest_shared_t *zs = ztest_shared;
 
 	/*
 	 * Blow away any existing copy of zpool.cache
 	 */
 	(void) remove(spa_config_path);
 
 	if (ztest_opts.zo_init == 0) {
 		if (ztest_opts.zo_verbose >= 1)
 			(void) printf("Importing pool %s\n",
 			    ztest_opts.zo_pool);
 		ztest_import(zs);
 		return;
 	}
 
 	/*
 	 * Create and initialize our storage pool.
 	 */
 	for (i = 1; i <= ztest_opts.zo_init; i++) {
 		memset(zs, 0, sizeof (*zs));
 		if (ztest_opts.zo_verbose >= 3 &&
 		    ztest_opts.zo_init != 1) {
 			(void) printf("ztest_init(), pass %d\n", i);
 		}
 		ztest_init(zs);
 	}
 }
 
 int
 main(int argc, char **argv)
 {
 	int kills = 0;
 	int iters = 0;
 	int older = 0;
 	int newer = 0;
 	ztest_shared_t *zs;
 	ztest_info_t *zi;
 	ztest_shared_callstate_t *zc;
 	char timebuf[100];
 	char numbuf[NN_NUMBUF_SZ];
 	char *cmd;
 	boolean_t hasalt;
 	int f, err;
 	char *fd_data_str = getenv("ZTEST_FD_DATA");
 	struct sigaction action;
 
 	(void) setvbuf(stdout, NULL, _IOLBF, 0);
 
 	dprintf_setup(&argc, argv);
 	zfs_deadman_synctime_ms = 300000;
 	zfs_deadman_checktime_ms = 30000;
 	/*
 	 * As two-word space map entries may not come up often (especially
 	 * if pool and vdev sizes are small) we want to force at least some
 	 * of them so the feature get tested.
 	 */
 	zfs_force_some_double_word_sm_entries = B_TRUE;
 
 	/*
 	 * Verify that even extensively damaged split blocks with many
 	 * segments can be reconstructed in a reasonable amount of time
 	 * when reconstruction is known to be possible.
 	 *
 	 * Note: the lower this value is, the more damage we inflict, and
 	 * the more time ztest spends in recovering that damage. We chose
 	 * to induce damage 1/100th of the time so recovery is tested but
 	 * not so frequently that ztest doesn't get to test other code paths.
 	 */
 	zfs_reconstruct_indirect_damage_fraction = 100;
 
 	action.sa_handler = sig_handler;
 	sigemptyset(&action.sa_mask);
 	action.sa_flags = 0;
 
 	if (sigaction(SIGSEGV, &action, NULL) < 0) {
 		(void) fprintf(stderr, "ztest: cannot catch SIGSEGV: %s.\n",
 		    strerror(errno));
 		exit(EXIT_FAILURE);
 	}
 
 	if (sigaction(SIGABRT, &action, NULL) < 0) {
 		(void) fprintf(stderr, "ztest: cannot catch SIGABRT: %s.\n",
 		    strerror(errno));
 		exit(EXIT_FAILURE);
 	}
 
 	/*
 	 * Force random_get_bytes() to use /dev/urandom in order to prevent
 	 * ztest from needlessly depleting the system entropy pool.
 	 */
 	random_path = "/dev/urandom";
 	ztest_fd_rand = open(random_path, O_RDONLY | O_CLOEXEC);
 	ASSERT3S(ztest_fd_rand, >=, 0);
 
 	if (!fd_data_str) {
 		process_options(argc, argv);
 
 		setup_data_fd();
 		setup_hdr();
 		setup_data();
 		memcpy(ztest_shared_opts, &ztest_opts,
 		    sizeof (*ztest_shared_opts));
 	} else {
 		ztest_fd_data = atoi(fd_data_str);
 		setup_data();
 		memcpy(&ztest_opts, ztest_shared_opts, sizeof (ztest_opts));
 	}
 	ASSERT3U(ztest_opts.zo_datasets, ==, ztest_shared_hdr->zh_ds_count);
 
 	err = ztest_set_global_vars();
 	if (err != 0 && !fd_data_str) {
 		/* error message done by ztest_set_global_vars */
 		exit(EXIT_FAILURE);
 	} else {
 		/* children should not be spawned if setting gvars fails */
 		VERIFY3S(err, ==, 0);
 	}
 
 	/* Override location of zpool.cache */
 	VERIFY3S(asprintf((char **)&spa_config_path, "%s/zpool.cache",
 	    ztest_opts.zo_dir), !=, -1);
 
 	ztest_ds = umem_alloc(ztest_opts.zo_datasets * sizeof (ztest_ds_t),
 	    UMEM_NOFAIL);
 	zs = ztest_shared;
 
 	if (fd_data_str) {
 		metaslab_force_ganging = ztest_opts.zo_metaslab_force_ganging;
 		metaslab_df_alloc_threshold =
 		    zs->zs_metaslab_df_alloc_threshold;
 
 		if (zs->zs_do_init)
 			ztest_run_init();
 		else
 			ztest_run(zs);
 		exit(0);
 	}
 
 	hasalt = (strlen(ztest_opts.zo_alt_ztest) != 0);
 
 	if (ztest_opts.zo_verbose >= 1) {
 		(void) printf("%"PRIu64" vdevs, %d datasets, %d threads, "
 		    "%d %s disks, parity %d, %"PRIu64" seconds...\n\n",
 		    ztest_opts.zo_vdevs,
 		    ztest_opts.zo_datasets,
 		    ztest_opts.zo_threads,
 		    ztest_opts.zo_raid_children,
 		    ztest_opts.zo_raid_type,
 		    ztest_opts.zo_raid_parity,
 		    ztest_opts.zo_time);
 	}
 
 	cmd = umem_alloc(MAXNAMELEN, UMEM_NOFAIL);
 	(void) strlcpy(cmd, getexecname(), MAXNAMELEN);
 
 	zs->zs_do_init = B_TRUE;
 	if (strlen(ztest_opts.zo_alt_ztest) != 0) {
 		if (ztest_opts.zo_verbose >= 1) {
 			(void) printf("Executing older ztest for "
 			    "initialization: %s\n", ztest_opts.zo_alt_ztest);
 		}
 		VERIFY(!exec_child(ztest_opts.zo_alt_ztest,
 		    ztest_opts.zo_alt_libpath, B_FALSE, NULL));
 	} else {
 		VERIFY(!exec_child(NULL, NULL, B_FALSE, NULL));
 	}
 	zs->zs_do_init = B_FALSE;
 
 	zs->zs_proc_start = gethrtime();
 	zs->zs_proc_stop = zs->zs_proc_start + ztest_opts.zo_time * NANOSEC;
 
 	for (f = 0; f < ZTEST_FUNCS; f++) {
 		zi = &ztest_info[f];
 		zc = ZTEST_GET_SHARED_CALLSTATE(f);
 		if (zs->zs_proc_start + zi->zi_interval[0] > zs->zs_proc_stop)
 			zc->zc_next = UINT64_MAX;
 		else
 			zc->zc_next = zs->zs_proc_start +
 			    ztest_random(2 * zi->zi_interval[0] + 1);
 	}
 
 	/*
 	 * Run the tests in a loop.  These tests include fault injection
 	 * to verify that self-healing data works, and forced crashes
 	 * to verify that we never lose on-disk consistency.
 	 */
 	while (gethrtime() < zs->zs_proc_stop) {
 		int status;
 		boolean_t killed;
 
 		/*
 		 * Initialize the workload counters for each function.
 		 */
 		for (f = 0; f < ZTEST_FUNCS; f++) {
 			zc = ZTEST_GET_SHARED_CALLSTATE(f);
 			zc->zc_count = 0;
 			zc->zc_time = 0;
 		}
 
 		/* Set the allocation switch size */
 		zs->zs_metaslab_df_alloc_threshold =
 		    ztest_random(zs->zs_metaslab_sz / 4) + 1;
 
 		if (!hasalt || ztest_random(2) == 0) {
 			if (hasalt && ztest_opts.zo_verbose >= 1) {
 				(void) printf("Executing newer ztest: %s\n",
 				    cmd);
 			}
 			newer++;
 			killed = exec_child(cmd, NULL, B_TRUE, &status);
 		} else {
 			if (hasalt && ztest_opts.zo_verbose >= 1) {
 				(void) printf("Executing older ztest: %s\n",
 				    ztest_opts.zo_alt_ztest);
 			}
 			older++;
 			killed = exec_child(ztest_opts.zo_alt_ztest,
 			    ztest_opts.zo_alt_libpath, B_TRUE, &status);
 		}
 
 		if (killed)
 			kills++;
 		iters++;
 
 		if (ztest_opts.zo_verbose >= 1) {
 			hrtime_t now = gethrtime();
 
 			now = MIN(now, zs->zs_proc_stop);
 			print_time(zs->zs_proc_stop - now, timebuf);
 			nicenum(zs->zs_space, numbuf, sizeof (numbuf));
 
 			(void) printf("Pass %3d, %8s, %3"PRIu64" ENOSPC, "
 			    "%4.1f%% of %5s used, %3.0f%% done, %8s to go\n",
 			    iters,
 			    WIFEXITED(status) ? "Complete" : "SIGKILL",
 			    zs->zs_enospc_count,
 			    100.0 * zs->zs_alloc / zs->zs_space,
 			    numbuf,
 			    100.0 * (now - zs->zs_proc_start) /
 			    (ztest_opts.zo_time * NANOSEC), timebuf);
 		}
 
 		if (ztest_opts.zo_verbose >= 2) {
 			(void) printf("\nWorkload summary:\n\n");
 			(void) printf("%7s %9s   %s\n",
 			    "Calls", "Time", "Function");
 			(void) printf("%7s %9s   %s\n",
 			    "-----", "----", "--------");
 			for (f = 0; f < ZTEST_FUNCS; f++) {
 				zi = &ztest_info[f];
 				zc = ZTEST_GET_SHARED_CALLSTATE(f);
 				print_time(zc->zc_time, timebuf);
 				(void) printf("%7"PRIu64" %9s   %s\n",
 				    zc->zc_count, timebuf,
 				    zi->zi_funcname);
 			}
 			(void) printf("\n");
 		}
 
 		if (!ztest_opts.zo_mmp_test)
 			ztest_run_zdb(zs->zs_guid);
 		if (ztest_shared_opts->zo_raidz_expand_test ==
 		    RAIDZ_EXPAND_CHECKED)
 			break; /* raidz expand test complete */
 	}
 
 	if (ztest_opts.zo_verbose >= 1) {
 		if (hasalt) {
 			(void) printf("%d runs of older ztest: %s\n", older,
 			    ztest_opts.zo_alt_ztest);
 			(void) printf("%d runs of newer ztest: %s\n", newer,
 			    cmd);
 		}
 		(void) printf("%d killed, %d completed, %.0f%% kill rate\n",
 		    kills, iters - kills, (100.0 * kills) / MAX(1, iters));
 	}
 
 	umem_free(cmd, MAXNAMELEN);
 
 	return (0);
 }
diff --git a/sys/contrib/openzfs/config/deb.am b/sys/contrib/openzfs/config/deb.am
index 4d86a1b70615..9e58e1905b73 100644
--- a/sys/contrib/openzfs/config/deb.am
+++ b/sys/contrib/openzfs/config/deb.am
@@ -1,105 +1,109 @@
 PHONY += deb-kmod deb-dkms deb-utils deb deb-local native-deb-local \
 	native-deb-utils native-deb-kmod native-deb
 
 native-deb-local:
 	@(if test "${HAVE_DPKGBUILD}" = "no"; then \
 		echo -e "\n" \
 	"*** Required util ${DPKGBUILD} missing.  Please install the\n" \
 	"*** package for your distribution which provides ${DPKGBUILD},\n" \
 	"*** re-run configure, and try again.\n"; \
 		exit 1; \
 	fi)
 
 deb-local: native-deb-local
 	@(if test "${HAVE_ALIEN}" = "no"; then \
 		echo -e "\n" \
 	"*** Required util ${ALIEN} missing.  Please install the\n" \
 	"*** package for your distribution which provides ${ALIEN},\n" \
 	"*** re-run configure, and try again.\n"; \
 		exit 1; \
 	fi; \
         if test "${ALIEN_MAJOR}" = "8" && \
            test "${ALIEN_MINOR}" = "95"; then \
         if test "${ALIEN_POINT}" = "1" || \
            test "${ALIEN_POINT}" = "2" || \
            test "${ALIEN_POINT}" = "3"; then \
                 /bin/echo -e "\n" \
         "*** Installed version of ${ALIEN} is known to be broken;\n" \
         "*** attempting to generate debs will fail! See\n" \
         "*** https://github.com/openzfs/zfs/issues/11650 for details.\n"; \
                 exit 1; \
         fi; \
         fi)
 
 deb-kmod: deb-local rpm-kmod
 	name=${PACKAGE}; \
 	version=${VERSION}-${RELEASE}; \
 	arch=`$(RPM) -qp $${name}-kmod-$${version}.src.rpm --qf %{arch} | tail -1`; \
 	debarch=`$(DPKG) --print-architecture`; \
 	pkg1=kmod-$${name}*$${version}.$${arch}.rpm; \
 	fakeroot $(ALIEN) --bump=0 --scripts --to-deb --target=$$debarch $$pkg1 || exit 1; \
 	$(RM) $$pkg1
 
 
 deb-dkms: deb-local rpm-dkms
 	name=${PACKAGE}; \
 	version=${VERSION}-${RELEASE}; \
 	arch=`$(RPM) -qp $${name}-dkms-$${version}.src.rpm --qf %{arch} | tail -1`; \
 	debarch=`$(DPKG) --print-architecture`; \
 	pkg1=$${name}-dkms-$${version}.$${arch}.rpm; \
 	fakeroot $(ALIEN) --bump=0 --scripts --to-deb --target=$$debarch $$pkg1 || exit 1; \
 	$(RM) $$pkg1
 
 deb-utils: deb-local rpm-utils-initramfs
 	name=${PACKAGE}; \
 	version=${VERSION}-${RELEASE}; \
 	arch=`$(RPM) -qp $${name}-$${version}.src.rpm --qf %{arch} | tail -1`; \
 	debarch=`$(DPKG) --print-architecture`; \
 	pkg1=$${name}-$${version}.$${arch}.rpm; \
 	pkg2=libnvpair3-$${version}.$${arch}.rpm; \
 	pkg3=libuutil3-$${version}.$${arch}.rpm; \
-	pkg4=libzfs5-$${version}.$${arch}.rpm; \
-	pkg5=libzpool5-$${version}.$${arch}.rpm; \
-	pkg6=libzfs5-devel-$${version}.$${arch}.rpm; \
+	pkg4=libzfs6-$${version}.$${arch}.rpm; \
+	pkg5=libzpool6-$${version}.$${arch}.rpm; \
+	pkg6=libzfs6-devel-$${version}.$${arch}.rpm; \
 	pkg7=$${name}-test-$${version}.$${arch}.rpm; \
 	pkg8=$${name}-dracut-$${version}.noarch.rpm; \
 	pkg9=$${name}-initramfs-$${version}.$${arch}.rpm; \
 	pkg10=`ls python3-pyzfs-$${version}.noarch.rpm 2>/dev/null`; \
 	pkg11=`ls pam_zfs_key-$${version}.$${arch}.rpm 2>/dev/null`; \
 ## Arguments need to be passed to dh_shlibdeps. Alien provides no mechanism
 ## to do this, so we install a shim onto the path which calls the real
 ## dh_shlibdeps with the required arguments.
 	path_prepend=`mktemp -d /tmp/intercept.XXXXXX`; \
 	echo "#!$(SHELL)" > $${path_prepend}/dh_shlibdeps; \
 	echo "`which dh_shlibdeps` -- \
-	 -xlibuutil3linux -xlibnvpair3linux -xlibzfs5linux -xlibzpool5linux" \
+	 -xlibuutil3linux -xlibnvpair3linux -xlibzfs6linux -xlibzpool6linux" \
 	 >> $${path_prepend}/dh_shlibdeps; \
 ## These -x arguments are passed to dpkg-shlibdeps, which exclude the
 ## Debianized packages from the auto-generated dependencies of the new debs,
 ## which should NOT be mixed with the alien-generated debs created here
 	chmod +x $${path_prepend}/dh_shlibdeps; \
 	env "PATH=$${path_prepend}:$${PATH}" \
 	fakeroot $(ALIEN) --bump=0 --scripts --to-deb --target=$$debarch \
 	    $$pkg1 $$pkg2 $$pkg3 $$pkg4 $$pkg5 $$pkg6 $$pkg7 \
 	    $$pkg8 $$pkg9 $$pkg10 $$pkg11 || exit 1; \
 	$(RM) $${path_prepend}/dh_shlibdeps; \
 	rmdir $${path_prepend}; \
 	$(RM) $$pkg1 $$pkg2 $$pkg3 $$pkg4 $$pkg5 $$pkg6 $$pkg7 \
 	    $$pkg8 $$pkg9 $$pkg10 $$pkg11;
 
 deb: deb-kmod deb-dkms deb-utils
 
 debian:
 	cp -r contrib/debian debian; chmod +x debian/rules;
 
 native-deb-utils: native-deb-local debian
+	while [ -f debian/deb-build.lock ]; do sleep 1; done; \
+	echo "native-deb-utils" > debian/deb-build.lock; \
 	cp contrib/debian/control debian/control; \
-	$(DPKGBUILD) -b -rfakeroot -us -uc;
+	$(DPKGBUILD) -b -rfakeroot -us -uc; \
+	$(RM) -f debian/deb-build.lock
 
 native-deb-kmod: native-deb-local debian
+	while [ -f debian/deb-build.lock ]; do sleep 1; done; \
+	echo "native-deb-kmod" > debian/deb-build.lock; \
 	sh scripts/make_gitrev.sh; \
-	fakeroot debian/rules override_dh_binary-modules;
+	fakeroot debian/rules override_dh_binary-modules; \
+	$(RM) -f debian/deb-build.lock
 
 native-deb: native-deb-utils native-deb-kmod
-
-.NOTPARALLEL: native-deb native-deb-utils native-deb-kmod
diff --git a/sys/contrib/openzfs/config/user.m4 b/sys/contrib/openzfs/config/user.m4
index badd920d2b8a..4e31745a2abc 100644
--- a/sys/contrib/openzfs/config/user.m4
+++ b/sys/contrib/openzfs/config/user.m4
@@ -1,39 +1,39 @@
 dnl #
 dnl # Default ZFS user configuration
 dnl #
 AC_DEFUN([ZFS_AC_CONFIG_USER], [
 	ZFS_AC_CONFIG_USER_GETTEXT
 	ZFS_AC_CONFIG_USER_MOUNT_HELPER
 	ZFS_AC_CONFIG_USER_SYSVINIT
 	ZFS_AC_CONFIG_USER_DRACUT
 	AM_COND_IF([BUILD_FREEBSD], [
 		PKG_INSTALLDIR(['${prefix}/libdata/pkgconfig'])], [
 		PKG_INSTALLDIR
 	])
 	ZFS_AC_CONFIG_USER_ZLIB
 	AM_COND_IF([BUILD_LINUX], [
 		ZFS_AC_CONFIG_USER_UDEV
 		ZFS_AC_CONFIG_USER_SYSTEMD
 		ZFS_AC_CONFIG_USER_LIBUDEV
 		ZFS_AC_CONFIG_USER_LIBUUID
 		ZFS_AC_CONFIG_USER_LIBBLKID
 	])
 	ZFS_AC_CONFIG_USER_LIBTIRPC
 	ZFS_AC_CONFIG_USER_LIBCRYPTO
 	ZFS_AC_CONFIG_USER_LIBAIO
 	ZFS_AC_CONFIG_USER_LIBATOMIC
 	ZFS_AC_CONFIG_USER_LIBFETCH
 	ZFS_AC_CONFIG_USER_AIO_H
 	ZFS_AC_CONFIG_USER_CLOCK_GETTIME
 	ZFS_AC_CONFIG_USER_PAM
 	ZFS_AC_CONFIG_USER_BACKTRACE
 	ZFS_AC_CONFIG_USER_LIBUNWIND
 	ZFS_AC_CONFIG_USER_RUNSTATEDIR
 	ZFS_AC_CONFIG_USER_MAKEDEV_IN_SYSMACROS
 	ZFS_AC_CONFIG_USER_MAKEDEV_IN_MKDEV
 	ZFS_AC_CONFIG_USER_ZFSEXEC
 
-	AC_CHECK_FUNCS([execvpe issetugid mlockall strlcat strlcpy gettid])
+	AC_CHECK_FUNCS([execvpe issetugid mlockall strerror_l strlcat strlcpy gettid])
 
 	AC_SUBST(RM)
 ])
diff --git a/sys/contrib/openzfs/contrib/debian/Makefile.am b/sys/contrib/openzfs/contrib/debian/Makefile.am
index f76b59645ead..99d512312df6 100644
--- a/sys/contrib/openzfs/contrib/debian/Makefile.am
+++ b/sys/contrib/openzfs/contrib/debian/Makefile.am
@@ -1,48 +1,48 @@
 dist_noinst_DATA += %D%/changelog.in
 dist_noinst_DATA += %D%/clean
 dist_noinst_DATA += %D%/control
 dist_noinst_DATA += %D%/control.modules.in
 dist_noinst_DATA += %D%/copyright
 dist_noinst_DATA += %D%/Makefile.am
 dist_noinst_DATA += %D%/not-installed
 dist_noinst_DATA += %D%/openzfs-libnvpair3.docs
 dist_noinst_DATA += %D%/openzfs-libnvpair3.install.in
 dist_noinst_DATA += %D%/openzfs-libpam-zfs.install
 dist_noinst_DATA += %D%/openzfs-libpam-zfs.postinst
 dist_noinst_DATA += %D%/openzfs-libpam-zfs.prerm
 dist_noinst_DATA += %D%/openzfs-libuutil3.docs
 dist_noinst_DATA += %D%/openzfs-libuutil3.install.in
-dist_noinst_DATA += %D%/openzfs-libzfs4.docs
-dist_noinst_DATA += %D%/openzfs-libzfs4.install.in
+dist_noinst_DATA += %D%/openzfs-libzfs6.docs
+dist_noinst_DATA += %D%/openzfs-libzfs6.install.in
 dist_noinst_DATA += %D%/openzfs-libzfsbootenv1.docs
 dist_noinst_DATA += %D%/openzfs-libzfsbootenv1.install.in
 dist_noinst_DATA += %D%/openzfs-libzfs-dev.docs
 dist_noinst_DATA += %D%/openzfs-libzfs-dev.install.in
-dist_noinst_DATA += %D%/openzfs-libzpool5.docs
-dist_noinst_DATA += %D%/openzfs-libzpool5.install.in
+dist_noinst_DATA += %D%/openzfs-libzpool6.docs
+dist_noinst_DATA += %D%/openzfs-libzpool6.install.in
 dist_noinst_DATA += %D%/openzfs-python3-pyzfs.install
 dist_noinst_DATA += %D%/openzfs-zfs-dkms.config
 dist_noinst_DATA += %D%/openzfs-zfs-dkms.dkms
 dist_noinst_DATA += %D%/openzfs-zfs-dkms.docs
 dist_noinst_DATA += %D%/openzfs-zfs-dkms.install
 dist_noinst_DATA += %D%/openzfs-zfs-dkms.postinst
 dist_noinst_DATA += %D%/openzfs-zfs-dkms.prerm
 dist_noinst_DATA += %D%/openzfs-zfs-dkms.templates
 dist_noinst_DATA += %D%/openzfs-zfs-dkms.triggers
 dist_noinst_DATA += %D%/openzfs-zfs-dracut.install
 dist_noinst_DATA += %D%/openzfs-zfs-initramfs.install
 dist_noinst_DATA += %D%/openzfs-zfs-modules-_KVERS_-di.install.in
 dist_noinst_DATA += %D%/openzfs-zfs-modules-_KVERS_.install.in
 dist_noinst_DATA += %D%/openzfs-zfs-modules-_KVERS_.postinst.in
 dist_noinst_DATA += %D%/openzfs-zfs-modules-_KVERS_.postrm.in
 dist_noinst_DATA += %D%/openzfs-zfs-test.install
 dist_noinst_DATA += %D%/openzfs-zfsutils.docs
 dist_noinst_DATA += %D%/openzfs-zfsutils.examples
 dist_noinst_DATA += %D%/openzfs-zfsutils.install
 dist_noinst_DATA += %D%/openzfs-zfsutils.postinst
 dist_noinst_DATA += %D%/openzfs-zfs-zed.install
 dist_noinst_DATA += %D%/openzfs-zfs-zed.postinst
 dist_noinst_DATA += %D%/openzfs-zfs-zed.postrm
 dist_noinst_DATA += %D%/rules.in
 dist_noinst_DATA += %D%/source
 dist_noinst_DATA += %D%/tree
diff --git a/sys/contrib/openzfs/contrib/debian/clean b/sys/contrib/openzfs/contrib/debian/clean
index 3100d693aeba..4f52d01b8108 100644
--- a/sys/contrib/openzfs/contrib/debian/clean
+++ b/sys/contrib/openzfs/contrib/debian/clean
@@ -1,11 +1,11 @@
 bin/
 cmd/zed/zed.d/history_event-zfs-list-cacher.sh
 contrib/pyzfs/build/
 contrib/pyzfs/libzfs_core/__pycache__/
 contrib/pyzfs/libzfs_core/bindings/__pycache__/
 contrib/pyzfs/pyzfs.egg-info/
 debian/openzfs-libnvpair3.install
 debian/openzfs-libuutil3.install
-debian/openzfs-libzfs4.install
+debian/openzfs-libzfs6.install
 debian/openzfs-libzfs-dev.install
-debian/openzfs-libzpool5.install
+debian/openzfs-libzpool6.install
diff --git a/sys/contrib/openzfs/contrib/debian/control b/sys/contrib/openzfs/contrib/debian/control
index e56fbf0f1c93..6829c0ccdf93 100644
--- a/sys/contrib/openzfs/contrib/debian/control
+++ b/sys/contrib/openzfs/contrib/debian/control
@@ -1,326 +1,326 @@
 Source: openzfs-linux
 Section: contrib/kernel
 Priority: optional
 Maintainer: ZFS on Linux specific mailing list <zfs-discuss@list.zfsonlinux.org>
 Build-Depends: debhelper-compat (= 12),
                dh-python,
                dh-sequence-dkms | dkms (>> 2.1.1.2-5),
                libaio-dev,
                libblkid-dev,
                libcurl4-openssl-dev,
                libelf-dev,
                libpam0g-dev,
                libssl-dev | libssl1.0-dev,
                libtool,
                libudev-dev,
                lsb-release,
                po-debconf,
                python3-all-dev,
                python3-cffi,
                python3-setuptools,
                python3-sphinx,
                uuid-dev,
                zlib1g-dev
 Standards-Version: 4.5.1
 Homepage: https://openzfs.org/
 Vcs-Git: https://github.com/openzfs/zfs.git
 Vcs-Browser: https://github.com/openzfs/zfs
 Rules-Requires-Root: no
 XS-Autobuild: yes
 
 Package: openzfs-libnvpair3
 Section: contrib/libs
 Architecture: linux-any
 Depends: ${misc:Depends}, ${shlibs:Depends}
 Breaks: libnvpair1, libnvpair3
 Replaces: libnvpair1, libnvpair3, libnvpair3linux
 Conflicts: libnvpair3linux
 Description: Solaris name-value library for Linux
  This library provides routines for packing and unpacking nv pairs for
  transporting data across process boundaries, transporting between
  kernel and userland, and possibly saving onto disk files.
 
 Package: openzfs-libpam-zfs
 Section: contrib/admin
 Architecture: linux-any
 Depends: libpam-runtime, ${misc:Depends}, ${shlibs:Depends}
 Replaces: libpam-zfs
 Conflicts: libpam-zfs
 Description: PAM module for managing encryption keys for ZFS
  OpenZFS is a storage platform that encompasses the functionality of
  traditional filesystems and volume managers. It supports data checksums,
  compression, encryption, snapshots, and more.
  .
  This provides a Pluggable Authentication Module (PAM) that automatically
  unlocks encrypted ZFS datasets upon login.
 
 Package: openzfs-libuutil3
 Section: contrib/libs
 Architecture: linux-any
 Depends: ${misc:Depends}, ${shlibs:Depends}
 Breaks: libuutil1, libuutil3
 Replaces: libuutil1, libuutil3, libuutil3linux
 Conflicts: libuutil3linux
 Description: Solaris userland utility library for Linux
  This library provides a variety of glue functions for ZFS on Linux:
   * 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.
 
 Package: openzfs-libzfs-dev
 Section: contrib/libdevel
 Architecture: linux-any
 Depends: libssl-dev | libssl1.0-dev,
          openzfs-libnvpair3 (= ${binary:Version}),
          openzfs-libuutil3 (= ${binary:Version}),
-         openzfs-libzfs4 (= ${binary:Version}),
+         openzfs-libzfs6 (= ${binary:Version}),
          openzfs-libzfsbootenv1 (= ${binary:Version}),
-         openzfs-libzpool5 (= ${binary:Version}),
+         openzfs-libzpool6 (= ${binary:Version}),
          ${misc:Depends}
 Replaces: libzfslinux-dev
 Conflicts: libzfslinux-dev
 Provides: libnvpair-dev, libuutil-dev
 Description: OpenZFS filesystem development files for Linux
  Header files and static libraries for compiling software against
  libraries of OpenZFS filesystem.
  .
  This package includes the development files of libnvpair3, libuutil3,
- libzpool5 and libzfs4.
+ libzpool6 and libzfs6.
 
-Package: openzfs-libzfs4
+Package: openzfs-libzfs6
 Section: contrib/libs
 Architecture: linux-any
 Depends: ${misc:Depends}, ${shlibs:Depends}
 # The libcurl4 is loaded through dlopen("libcurl.so.4").
 # https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=988521
 Recommends: libcurl4
-Breaks: libzfs2, libzfs4
-Replaces: libzfs2, libzfs4, libzfs4linux
-Conflicts: libzfs4linux
+Breaks: libzfs2, libzfs4, libzfs4linux, libzfs6linux
+Replaces: libzfs2, libzfs4, libzfs4linux, libzfs6linux
+Conflicts: libzfs6linux
 Description: OpenZFS filesystem library for Linux - general support
  OpenZFS is a storage platform that encompasses the functionality of
  traditional filesystems and volume managers. It supports data checksums,
  compression, encryption, snapshots, and more.
  .
  The OpenZFS library provides support for managing OpenZFS filesystems.
 
 Package: openzfs-libzfsbootenv1
 Section: contrib/libs
 Architecture: linux-any
 Depends: ${misc:Depends}, ${shlibs:Depends}
 Breaks: libzfs2, libzfs4
 Replaces: libzfs2, libzfs4, libzfsbootenv1linux
 Conflicts: libzfsbootenv1linux
 Description: OpenZFS filesystem library for Linux - label info support
  OpenZFS is a storage platform that encompasses the functionality of
  traditional filesystems and volume managers. It supports data checksums,
  compression, encryption, snapshots, and more.
  .
  The zfsbootenv library provides support for modifying ZFS label information.
 
-Package: openzfs-libzpool5
+Package: openzfs-libzpool6
 Section: contrib/libs
 Architecture: linux-any
 Depends: ${misc:Depends}, ${shlibs:Depends}
-Breaks: libzpool2, libzpool5
-Replaces: libzpool2, libzpool5, libzpool5linux
-Conflicts: libzpool5linux
+Breaks: libzpool2, libzpool5, libzpool5linux, libzpool6linux
+Replaces: libzpool2, libzpool5, libzpool5linux, libzpool6linux
+Conflicts: libzpool6linux
 Description: OpenZFS pool library for Linux
  OpenZFS is a storage platform that encompasses the functionality of
  traditional filesystems and volume managers. It supports data checksums,
  compression, encryption, snapshots, and more.
  .
  This zpool library provides support for managing zpools.
 
 Package: openzfs-python3-pyzfs
 Section: contrib/python
 Architecture: linux-any
 Depends: python3-cffi,
          openzfs-zfsutils (= ${binary:Version}),
          ${misc:Depends},
          ${python3:Depends}
 Replaces: python3-pyzfs
 Conflicts: python3-pyzfs
 Description: wrapper for libzfs_core C library
  libzfs_core is intended to be a stable interface for programmatic
  administration of ZFS. This wrapper provides one-to-one wrappers for
  libzfs_core API functions, but the signatures and types are more natural to
  Python.
  .
  nvlists are wrapped as dictionaries or lists depending on their usage.
  Some parameters have default values depending on typical use for
  increased convenience. Enumerations and bit flags become strings and lists
  of strings in Python. Errors are reported as exceptions rather than integer
  errno-style error codes.  The wrapper takes care to provide one-to-many
  mapping of the error codes to the exceptions by interpreting a context
  in which the error code is produced.
 
 Package: openzfs-pyzfs-doc
 Section: contrib/doc
 Architecture: all
 Depends: ${misc:Depends}, ${sphinxdoc:Depends}
 Recommends: openzfs-python3-pyzfs
 Replaces: pyzfs-doc
 Conflicts: pyzfs-doc
 Description: wrapper for libzfs_core C library (documentation)
  libzfs_core is intended to be a stable interface for programmatic
  administration of ZFS. This wrapper provides one-to-one wrappers for
  libzfs_core API functions, but the signatures and types are more natural to
  Python.
  .
  nvlists are wrapped as dictionaries or lists depending on their usage.
  Some parameters have default values depending on typical use for
  increased convenience. Enumerations and bit flags become strings and lists
  of strings in Python. Errors are reported as exceptions rather than integer
  errno-style error codes.  The wrapper takes care to provide one-to-many
  mapping of the error codes to the exceptions by interpreting a context
  in which the error code is produced.
  .
  This package contains the documentation.
 
 Package: openzfs-zfs-dkms
 Architecture: all
 Depends: dkms (>> 2.1.1.2-5),
          file,
          libc6-dev | libc-dev,
          lsb-release,
          python3 (>> 3.12) | python3-distutils | libpython3-stdlib (<< 3.6.4),
          ${misc:Depends},
          ${perl:Depends}
 Recommends: openzfs-zfs-zed, openzfs-zfsutils (>= ${source:Version}), ${linux:Recommends}
 # suggests debhelper because e.g. `dkms mkdeb -m zfs -v 0.8.2` needs dh_testdir (#909183)
 Suggests: debhelper
 Breaks: spl-dkms (<< 0.8.0~rc1)
 Replaces: spl-dkms, zfs-dkms
 Provides: openzfs-zfs-modules
 Description: OpenZFS filesystem kernel modules for Linux
  OpenZFS is a storage platform that encompasses the functionality of
  traditional filesystems and volume managers. It supports data checksums,
  compression, encryption, snapshots, and more.
  .
  This DKMS package includes the SPA, DMU, ZVOL, and ZPL components of
  OpenZFS.
 
 Package: openzfs-zfs-initramfs
 Architecture: all
 Depends: busybox-initramfs | busybox-static | busybox,
          initramfs-tools,
          openzfs-zfs-modules | openzfs-zfs-dkms,
          openzfs-zfsutils (>= ${source:Version}),
          ${misc:Depends}
 Breaks: zfsutils-linux (<= 0.7.11-2)
 Replaces: zfsutils-linux (<= 0.7.11-2), zfs-initramfs
 Conflicts: zfs-initramfs
 Description: OpenZFS root filesystem capabilities for Linux - initramfs
  OpenZFS is a storage platform that encompasses the functionality of
  traditional filesystems and volume managers. It supports data checksums,
  compression, encryption, snapshots, and more.
  .
  This package adds OpenZFS to the system initramfs with a hook
  for the initramfs-tools infrastructure.
 
 Package: openzfs-zfs-dracut
 Architecture: all
 Depends: dracut,
          openzfs-zfs-modules | openzfs-zfs-dkms,
          openzfs-zfsutils (>= ${source:Version}),
          ${misc:Depends}
 Conflicts: zfs-dracut
 Replaces: zfs-dracut
 Description: OpenZFS root filesystem capabilities for Linux - dracut
  OpenZFS is a storage platform that encompasses the functionality of
  traditional filesystems and volume managers. It supports data checksums,
  compression, encryption, snapshots, and more.
  .
  This package adds OpenZFS to the system initramfs with a hook
  for the dracut infrastructure.
 
 Package: openzfs-zfsutils
 Section: contrib/admin
 Architecture: linux-any
 Pre-Depends: ${misc:Pre-Depends}
 Depends: openzfs-libnvpair3 (= ${binary:Version}),
          openzfs-libuutil3 (= ${binary:Version}),
-         openzfs-libzfs4 (= ${binary:Version}),
-         openzfs-libzpool5 (= ${binary:Version}),
+         openzfs-libzfs6 (= ${binary:Version}),
+         openzfs-libzpool6 (= ${binary:Version}),
          python3,
          ${misc:Depends},
          ${shlibs:Depends}
 Recommends: lsb-base, openzfs-zfs-modules | openzfs-zfs-dkms, openzfs-zfs-zed
 Breaks: openrc,
         spl (<< 0.7.9-2),
         spl-dkms (<< 0.8.0~rc1),
         openzfs-zfs-dkms (<< ${source:Version}),
         openzfs-zfs-dkms (>> ${source:Version}...)
 Replaces: spl (<< 0.7.9-2), spl-dkms, zfsutils-linux
 Conflicts: zfs, zfs-fuse, zfsutils-linux
 Suggests: nfs-kernel-server,
           samba-common-bin (>= 3.0.23),
           openzfs-zfs-initramfs | openzfs-zfs-dracut
 Provides: openzfsutils
 Description: command-line tools to manage OpenZFS filesystems
  OpenZFS is a storage platform that encompasses the functionality of
  traditional filesystems and volume managers. It supports data checksums,
  compression, encryption, snapshots, and more.
  .
  This package provides the zfs and zpool commands to create and administer
  OpenZFS filesystems.
 
 Package: openzfs-zfs-zed
 Section: contrib/admin
 Architecture: linux-any
 Pre-Depends: ${misc:Pre-Depends}
 Depends: openzfs-zfs-modules | openzfs-zfs-dkms,
          openzfs-zfsutils (>= ${binary:Version}),
          ${misc:Depends},
          ${shlibs:Depends}
 Conflicts: zfs, zfs-zed
 Replaces: zfs-zed
 Description: OpenZFS Event Daemon
  OpenZFS is a storage platform that encompasses the functionality of
  traditional filesystems and volume managers. It supports data checksums,
  compression, encryption, snapshots, and more.
  .
  ZED (ZFS Event Daemon) monitors events generated by the ZFS kernel
  module. When a zevent (ZFS Event) is posted, ZED will run any ZEDLETs
  (ZFS Event Daemon Linkage for Executable Tasks) that have been enabled
  for the corresponding zevent class.
  .
  This package provides the OpenZFS Event Daemon (zed).
 
 Package: openzfs-zfs-test
 Section: contrib/admin
 Architecture: linux-any
 Depends: acl,
          attr,
          bc,
          fio,
          ksh,
          lsscsi,
          mdadm,
          parted,
          python3,
          openzfs-python3-pyzfs,
          sudo,
          sysstat,
          openzfs-zfs-modules | openzfs-zfs-dkms,
          openzfs-zfsutils (>=${binary:Version}),
          ${misc:Depends},
          ${shlibs:Depends}
 Recommends: nfs-kernel-server
 Breaks: zfsutils-linux (<= 0.7.9-2)
 Replaces: zfsutils-linux (<= 0.7.9-2), zfs-test
 Conflicts: zutils, zfs-test
 Description: OpenZFS test infrastructure and support scripts
  OpenZFS is a storage platform that encompasses the functionality of
  traditional filesystems and volume managers. It supports data checksums,
  compression, encryption, snapshots, and more.
  .
  This package provides the OpenZFS test infrastructure for destructively
  testing and validating a system using OpenZFS. It is entirely optional
  and should only be installed and used in test environments.
diff --git a/sys/contrib/openzfs/contrib/debian/openzfs-libzfs4.docs b/sys/contrib/openzfs/contrib/debian/openzfs-libzfs6.docs
similarity index 100%
rename from sys/contrib/openzfs/contrib/debian/openzfs-libzfs4.docs
rename to sys/contrib/openzfs/contrib/debian/openzfs-libzfs6.docs
diff --git a/sys/contrib/openzfs/contrib/debian/openzfs-libzfs4.install.in b/sys/contrib/openzfs/contrib/debian/openzfs-libzfs6.install.in
similarity index 100%
rename from sys/contrib/openzfs/contrib/debian/openzfs-libzfs4.install.in
rename to sys/contrib/openzfs/contrib/debian/openzfs-libzfs6.install.in
diff --git a/sys/contrib/openzfs/contrib/debian/openzfs-libzpool5.docs b/sys/contrib/openzfs/contrib/debian/openzfs-libzpool6.docs
similarity index 100%
rename from sys/contrib/openzfs/contrib/debian/openzfs-libzpool5.docs
rename to sys/contrib/openzfs/contrib/debian/openzfs-libzpool6.docs
diff --git a/sys/contrib/openzfs/contrib/debian/openzfs-libzpool5.install.in b/sys/contrib/openzfs/contrib/debian/openzfs-libzpool6.install.in
similarity index 100%
rename from sys/contrib/openzfs/contrib/debian/openzfs-libzpool5.install.in
rename to sys/contrib/openzfs/contrib/debian/openzfs-libzpool6.install.in
diff --git a/sys/contrib/openzfs/contrib/debian/openzfs-zfsutils.install b/sys/contrib/openzfs/contrib/debian/openzfs-zfsutils.install
index d51e4ef003e6..546745930bff 100644
--- a/sys/contrib/openzfs/contrib/debian/openzfs-zfsutils.install
+++ b/sys/contrib/openzfs/contrib/debian/openzfs-zfsutils.install
@@ -1,138 +1,140 @@
 etc/default/zfs
 etc/zfs/zfs-functions
 etc/zfs/zpool.d/
 lib/systemd/system-generators/
 lib/systemd/system-preset/
 lib/systemd/system/zfs-import-cache.service
 lib/systemd/system/zfs-import-scan.service
 lib/systemd/system/zfs-import.target
 lib/systemd/system/zfs-load-key.service
 lib/systemd/system/zfs-mount.service
 lib/systemd/system/zfs-scrub-monthly@.timer
 lib/systemd/system/zfs-scrub-weekly@.timer
 lib/systemd/system/zfs-scrub@.service
 lib/systemd/system/zfs-trim-monthly@.timer
 lib/systemd/system/zfs-trim-weekly@.timer
 lib/systemd/system/zfs-trim@.service
 lib/systemd/system/zfs-share.service
 lib/systemd/system/zfs-volume-wait.service
 lib/systemd/system/zfs-volumes.target
 lib/systemd/system/zfs.target
 lib/udev/
 sbin/fsck.zfs
 sbin/mount.zfs
 sbin/zdb
 sbin/zfs
 sbin/zfs_ids_to_path
 sbin/zgenhostid
 sbin/zhack
 sbin/zinject
 sbin/zpool
 sbin/zstream
 sbin/zstreamdump
 usr/bin/zvol_wait
 usr/lib/modules-load.d/ lib/
 usr/lib/zfs-linux/zpool.d/
 usr/lib/zfs-linux/zpool_influxdb
 usr/lib/zfs-linux/zfs_prepare_disk
 usr/sbin/arc_summary
 usr/sbin/arcstat
 usr/sbin/dbufstat
 usr/sbin/zilstat
 usr/share/zfs/compatibility.d/
 usr/share/bash-completion/completions
 usr/share/man/man1/arcstat.1
 usr/share/man/man1/zhack.1
 usr/share/man/man1/zvol_wait.1
 usr/share/man/man5/
 usr/share/man/man8/fsck.zfs.8
 usr/share/man/man8/mount.zfs.8
 usr/share/man/man8/vdev_id.8
 usr/share/man/man8/zdb.8
 usr/share/man/man8/zfs-allow.8
 usr/share/man/man8/zfs-bookmark.8
 usr/share/man/man8/zfs-change-key.8
 usr/share/man/man8/zfs-clone.8
 usr/share/man/man8/zfs-create.8
 usr/share/man/man8/zfs-destroy.8
 usr/share/man/man8/zfs-diff.8
 usr/share/man/man8/zfs-get.8
 usr/share/man/man8/zfs-groupspace.8
 usr/share/man/man8/zfs-hold.8
 usr/share/man/man8/zfs-inherit.8
 usr/share/man/man8/zfs-list.8
 usr/share/man/man8/zfs-load-key.8
 usr/share/man/man8/zfs-mount-generator.8
 usr/share/man/man8/zfs-mount.8
 usr/share/man/man8/zfs-program.8
 usr/share/man/man8/zfs-project.8
 usr/share/man/man8/zfs-projectspace.8
 usr/share/man/man8/zfs-promote.8
 usr/share/man/man8/zfs-receive.8
 usr/share/man/man8/zfs-recv.8
 usr/share/man/man8/zfs-redact.8
 usr/share/man/man8/zfs-release.8
 usr/share/man/man8/zfs-rename.8
 usr/share/man/man8/zfs-rollback.8
 usr/share/man/man8/zfs-send.8
 usr/share/man/man8/zfs-set.8
 usr/share/man/man8/zfs-share.8
 usr/share/man/man8/zfs-snapshot.8
 usr/share/man/man8/zfs-unallow.8
 usr/share/man/man8/zfs-unload-key.8
 usr/share/man/man8/zfs-unmount.8
 usr/share/man/man8/zfs-unzone.8
 usr/share/man/man8/zfs-upgrade.8
 usr/share/man/man8/zfs-userspace.8
 usr/share/man/man8/zfs-wait.8
 usr/share/man/man8/zfs-zone.8
 usr/share/man/man8/zfs.8
 usr/share/man/man8/zfs_ids_to_path.8
 usr/share/man/man8/zfs_prepare_disk.8
 usr/share/man/man7/zfsconcepts.7
 usr/share/man/man7/zfsprops.7
 usr/share/man/man8/zgenhostid.8
 usr/share/man/man8/zinject.8
 usr/share/man/man8/zpool-add.8
 usr/share/man/man8/zpool-attach.8
 usr/share/man/man8/zpool-checkpoint.8
 usr/share/man/man8/zpool-clear.8
 usr/share/man/man8/zpool-create.8
+usr/share/man/man8/zpool-ddtprune.8
 usr/share/man/man8/zpool-destroy.8
 usr/share/man/man8/zpool-detach.8
 usr/share/man/man8/zpool-ddtprune.8
 usr/share/man/man8/zpool-events.8
 usr/share/man/man8/zpool-export.8
 usr/share/man/man8/zpool-get.8
 usr/share/man/man8/zpool-history.8
 usr/share/man/man8/zpool-import.8
 usr/share/man/man8/zpool-initialize.8
 usr/share/man/man8/zpool-iostat.8
 usr/share/man/man8/zpool-labelclear.8
 usr/share/man/man8/zpool-list.8
 usr/share/man/man8/zpool-offline.8
 usr/share/man/man8/zpool-online.8
 usr/share/man/man8/zpool-prefetch.8
+usr/share/man/man8/zpool-prefetch.8
 usr/share/man/man8/zpool-reguid.8
 usr/share/man/man8/zpool-remove.8
 usr/share/man/man8/zpool-reopen.8
 usr/share/man/man8/zpool-replace.8
 usr/share/man/man8/zpool-resilver.8
 usr/share/man/man8/zpool-scrub.8
 usr/share/man/man8/zpool-set.8
 usr/share/man/man8/zpool-split.8
 usr/share/man/man8/zpool-status.8
 usr/share/man/man8/zpool-sync.8
 usr/share/man/man8/zpool-trim.8
 usr/share/man/man8/zpool-upgrade.8
 usr/share/man/man8/zpool-wait.8
 usr/share/man/man8/zpool.8
 usr/share/man/man7/vdevprops.7
 usr/share/man/man7/zpoolconcepts.7
 usr/share/man/man7/zpoolprops.7
 usr/share/man/man8/zstream.8
 usr/share/man/man8/zstreamdump.8
 usr/share/man/man4/spl.4
 usr/share/man/man4/zfs.4
 usr/share/man/man7/zpool-features.7
 usr/share/man/man8/zpool_influxdb.8
diff --git a/sys/contrib/openzfs/contrib/initramfs/scripts/zfs b/sys/contrib/openzfs/contrib/initramfs/scripts/zfs
index 0a2bd2efda7a..c569b2528368 100644
--- a/sys/contrib/openzfs/contrib/initramfs/scripts/zfs
+++ b/sys/contrib/openzfs/contrib/initramfs/scripts/zfs
@@ -1,1022 +1,1021 @@
 # ZFS boot stub for initramfs-tools.
 #
 # In the initramfs environment, the /init script sources this stub to
 # override the default functions in the /scripts/local script.
 #
 # Enable this by passing boot=zfs on the kernel command line.
 #
 # $quiet, $root, $rpool, $bootfs come from the cmdline:
 # shellcheck disable=SC2154
 
 # Source the common functions
 . /etc/zfs/zfs-functions
 
 # Start interactive shell.
 # Use debian's panic() if defined, because it allows to prevent shell access
 # by setting panic in cmdline (e.g. panic=0 or panic=15).
 # See "4.5 Disable root prompt on the initramfs" of Securing Debian Manual:
 # https://www.debian.org/doc/manuals/securing-debian-howto/ch4.en.html
 shell() {
 	if command -v panic > /dev/null 2>&1; then
 		panic
 	else
 		/bin/sh
 	fi
 }
 
 # This runs any scripts that should run before we start importing
 # pools and mounting any filesystems.
 pre_mountroot()
 {
 	if command -v run_scripts > /dev/null 2>&1
 	then
 		if [ -f "/scripts/local-top" ] || [ -d "/scripts/local-top" ]
 		then
 			[ "$quiet" != "y" ] && \
 			    zfs_log_begin_msg "Running /scripts/local-top"
 			run_scripts /scripts/local-top
 			[ "$quiet" != "y" ] && zfs_log_end_msg
 		fi
 
 	  if [ -f "/scripts/local-premount" ] || [ -d "/scripts/local-premount" ]
 	  then
 			[ "$quiet" != "y" ] && \
 			    zfs_log_begin_msg "Running /scripts/local-premount"
 			run_scripts /scripts/local-premount
 			[ "$quiet" != "y" ] && zfs_log_end_msg
 		fi
 	fi
 }
 
 # If plymouth is available, hide the splash image.
 disable_plymouth()
 {
 	if [ -x /bin/plymouth ] && /bin/plymouth --ping
 	then
 		/bin/plymouth hide-splash >/dev/null 2>&1
 	fi
 }
 
 # Get a ZFS filesystem property value.
 get_fs_value()
 {
 	fs="$1"
 	value=$2
 
 	"${ZFS}" get -H -ovalue "$value" "$fs" 2> /dev/null
 }
 
 # Find the 'bootfs' property on pool $1.
 # If the property does not contain '/', then ignore this
 # pool by exporting it again.
 find_rootfs()
 {
 	pool="$1"
 
 	# If 'POOL_IMPORTED' isn't set, no pool imported and therefore
 	# we won't be able to find a root fs.
 	[ -z "${POOL_IMPORTED}" ] && return 1
 
 	# If it's already specified, just keep it mounted and exit
 	# User (kernel command line) must be correct.
 	if [ -n "${ZFS_BOOTFS}" ] && [ "${ZFS_BOOTFS}" != "zfs:AUTO" ]; then
 		return 0
 	fi
 
 	# Not set, try to find it in the 'bootfs' property of the pool.
 	# NOTE: zpool does not support 'get -H -ovalue bootfs'...
 	ZFS_BOOTFS=$("${ZPOOL}" list -H -obootfs "$pool")
 
 	# Make sure it's not '-' and that it starts with /.
 	if [ "${ZFS_BOOTFS}" != "-" ] && \
 		get_fs_value "${ZFS_BOOTFS}" mountpoint | grep -q '^/$'
 	then
 		# Keep it mounted
 		POOL_IMPORTED=1
 		return 0
 	fi
 
 	# Not boot fs here, export it and later try again..
 	"${ZPOOL}" export "$pool"
 	POOL_IMPORTED=
 	ZFS_BOOTFS=
 	return 1
 }
 
 # Support function to get a list of all pools, separated with ';'
 find_pools()
 {
 	pools=$("$@" 2> /dev/null | \
 		sed -Ee '/pool:|^[a-zA-Z0-9]/!d' -e 's@.*: @@' | \
 		tr '\n' ';')
 
 	echo "${pools%%;}" # Return without the last ';'.
 }
 
 # Get a list of all available pools
 get_pools()
 {
 	if [ -n "${ZFS_POOL_IMPORT}" ]; then
 		echo "$ZFS_POOL_IMPORT"
 		return 0
 	fi
 
 	# Get the base list of available pools.
 	available_pools=$(find_pools "$ZPOOL" import)
 
 	# Just in case - seen it happen (that a pool isn't visible/found
 	# with a simple "zpool import" but only when using the "-d"
 	# option or setting ZPOOL_IMPORT_PATH).
 	if [ -d "/dev/disk/by-id" ]
 	then
 		npools=$(find_pools "$ZPOOL" import -d /dev/disk/by-id)
 		if [ -n "$npools" ]
 		then
 			# Because we have found extra pool(s) here, which wasn't
 			# found 'normally', we need to force USE_DISK_BY_ID to
 			# make sure we're able to actually import it/them later.
 			USE_DISK_BY_ID='yes'
 
 			if [ -n "$available_pools" ]
 			then
 				# Filter out duplicates (pools found with the simple
 				# "zpool import" but which is also found with the
 				# "zpool import -d ...").
 				npools=$(echo "$npools" | sed "s,$available_pools,,")
 
 				# Add the list to the existing list of
 				# available pools
 				available_pools="$available_pools;$npools"
 			else
 				available_pools="$npools"
 			fi
 		fi
 	fi
 
 	# Filter out any exceptions...
 	if [ -n "$ZFS_POOL_EXCEPTIONS" ]
 	then
 		found=""
 		apools=""
 		OLD_IFS="$IFS" ; IFS=";"
 
 		for pool in $available_pools
 		do
 			for exception in $ZFS_POOL_EXCEPTIONS
 			do
 				[ "$pool" = "$exception" ] && continue 2
 				found="$pool"
 			done
 
 			if [ -n "$found" ]
 			then
 				if [ -n "$apools" ]
 				then
 					apools="$apools;$pool"
 				else
 					apools="$pool"
 				fi
 			fi
 		done
 
 		IFS="$OLD_IFS"
 		available_pools="$apools"
 	fi
 
 	# Return list of available pools.
 	echo "$available_pools"
 }
 
 # Import given pool $1
 import_pool()
 {
 	pool="$1"
 
 	# Verify that the pool isn't already imported
 	# Make as sure as we can to not require '-f' to import.
 	"${ZPOOL}" get -H -o value name,guid 2>/dev/null | grep -Fxq "$pool" && return 0
 
 	# For backwards compatibility, make sure that ZPOOL_IMPORT_PATH is set
 	# to something we can use later with the real import(s). We want to
 	# make sure we find all by* dirs, BUT by-vdev should be first (if it
 	# exists).
 	if [ -n "$USE_DISK_BY_ID" ] && [ -z "$ZPOOL_IMPORT_PATH" ]
 	then
 		dirs="$(for dir in /dev/disk/by-*
 		do
 			# Ignore by-vdev here - we want it first!
 			echo "$dir" | grep -q /by-vdev && continue
 			[ ! -d "$dir" ] && continue
 
 			printf "%s" "$dir:"
 		done | sed 's,:$,,g')"
 
 		if [ -d "/dev/disk/by-vdev" ]
 		then
 			# Add by-vdev at the beginning.
 			ZPOOL_IMPORT_PATH="/dev/disk/by-vdev:"
 		fi
 
 		# ... and /dev at the very end, just for good measure.
 		ZPOOL_IMPORT_PATH="$ZPOOL_IMPORT_PATH$dirs:/dev"
 	fi
 
 	# Needs to be exported for "zpool" to catch it.
 	[ -n "$ZPOOL_IMPORT_PATH" ] && export ZPOOL_IMPORT_PATH
 
 
 	[ "$quiet" != "y" ] && zfs_log_begin_msg \
 		"Importing pool '${pool}' using defaults"
 
 	ZFS_CMD="${ZPOOL} import -N ${ZPOOL_FORCE} ${ZPOOL_IMPORT_OPTS}"
 	ZFS_STDERR="$($ZFS_CMD "$pool" 2>&1)"
 	ZFS_ERROR="$?"
 	if [ "${ZFS_ERROR}" != 0 ]
 	then
 		[ "$quiet" != "y" ] && zfs_log_failure_msg "${ZFS_ERROR}"
 
 		if [ -f "${ZPOOL_CACHE}" ]
 		then
 			[ "$quiet" != "y" ] && zfs_log_begin_msg \
 				"Importing pool '${pool}' using cachefile."
 
 			ZFS_CMD="${ZPOOL} import -c ${ZPOOL_CACHE} -N ${ZPOOL_FORCE} ${ZPOOL_IMPORT_OPTS}"
 			ZFS_STDERR="$($ZFS_CMD "$pool" 2>&1)"
 			ZFS_ERROR="$?"
 		fi
 
 		if [ "${ZFS_ERROR}" != 0 ]
 		then
 			[ "$quiet" != "y" ] && zfs_log_failure_msg "${ZFS_ERROR}"
 
 			disable_plymouth
 			echo ""
 			echo "Command: ${ZFS_CMD} '$pool'"
 			echo "Message: $ZFS_STDERR"
 			echo "Error: $ZFS_ERROR"
 			echo ""
 			echo "Failed to import pool '$pool'."
 			echo "Manually import the pool and exit."
 			shell
 		fi
 	fi
 
 	[ "$quiet" != "y" ] && zfs_log_end_msg
 
 	POOL_IMPORTED=1
 	return 0
 }
 
 # Load ZFS modules
 # Loading a module in a initrd require a slightly different approach,
 # with more logging etc.
 load_module_initrd()
 {
 	ZFS_INITRD_PRE_MOUNTROOT_SLEEP=${ROOTDELAY:-0}
 
 	if [ "$ZFS_INITRD_PRE_MOUNTROOT_SLEEP" -gt 0 ]; then
 		[ "$quiet" != "y" ] && zfs_log_begin_msg "Delaying for up to '${ZFS_INITRD_PRE_MOUNTROOT_SLEEP}' seconds."
 	fi
 
 	START=$(/bin/date -u +%s)
 	END=$((START+ZFS_INITRD_PRE_MOUNTROOT_SLEEP))
 	while true; do
 
 		# Wait for all of the /dev/{hd,sd}[a-z] device nodes to appear.
 		if command -v wait_for_udev > /dev/null 2>&1 ; then
 			wait_for_udev 10
 		elif command -v wait_for_dev > /dev/null 2>&1 ; then
 			wait_for_dev
 		fi
 
 		#
 		# zpool import refuse to import without a valid
 		# /proc/self/mounts
 		#
 		[ ! -f /proc/self/mounts ] && mount proc /proc
 
 		# Load the module
 		if load_module "zfs"; then
 			ret=0
 			break
 		else
 			ret=1
 		fi
 
 		[ "$(/bin/date -u +%s)" -gt "$END" ] && break
 		sleep 1
 
 	done
 	if [ "$ZFS_INITRD_PRE_MOUNTROOT_SLEEP" -gt 0 ]; then
 		[ "$quiet" != "y" ] && zfs_log_end_msg
 	fi
 
 	[ "$ret" -ne 0 ] && return 1
 
 	if [ "$ZFS_INITRD_POST_MODPROBE_SLEEP" -gt 0 ] 2>/dev/null
 	then
 		if [ "$quiet" != "y" ]; then
 			zfs_log_begin_msg "Sleeping for" \
 				"$ZFS_INITRD_POST_MODPROBE_SLEEP seconds..."
 		fi
 		sleep "$ZFS_INITRD_POST_MODPROBE_SLEEP"
 		[ "$quiet" != "y" ] && zfs_log_end_msg
 	fi
 
 	return 0
 }
 
 # Mount a given filesystem
 mount_fs()
 {
 	fs="$1"
 
 	# Check that the filesystem exists
 	"${ZFS}" list -oname -tfilesystem -H "${fs}" > /dev/null 2>&1 ||  return 1
 
 	# Skip filesystems with canmount=off.  The root fs should not have
 	# canmount=off, but ignore it for backwards compatibility just in case.
 	if [ "$fs" != "${ZFS_BOOTFS}" ]
 	then
 		canmount=$(get_fs_value "$fs" canmount)
 		[ "$canmount" = "off" ] && return 0
 	fi
 
 	# Need the _original_ datasets mountpoint!
 	mountpoint=$(get_fs_value "$fs" mountpoint)
-	ZFS_CMD="mount -o zfsutil -t zfs"
+	ZFS_CMD="mount.zfs -o zfsutil"
 	if [ "$mountpoint" = "legacy" ] || [ "$mountpoint" = "none" ]; then
 		# Can't use the mountpoint property. Might be one of our
 		# clones. Check the 'org.zol:mountpoint' property set in
 		# clone_snap() if that's usable.
 		mountpoint1=$(get_fs_value "$fs" org.zol:mountpoint)
 		if [ "$mountpoint1" = "legacy" ] ||
 		   [ "$mountpoint1" = "none" ] ||
 		   [ "$mountpoint1" = "-" ]
 		then
 			if [ "$fs" != "${ZFS_BOOTFS}" ]; then
 				# We don't have a proper mountpoint and this
 				# isn't the root fs.
 				return 0
 			fi
-			# Don't use mount.zfs -o zfsutils for legacy mountpoint
 			if [ "$mountpoint" = "legacy" ]; then
-				ZFS_CMD="mount -t zfs"
+				ZFS_CMD="mount.zfs"
 			fi
 			# Last hail-mary: Hope 'rootmnt' is set!
 			mountpoint=""
 		else
 			mountpoint="$mountpoint1"
 		fi
 	fi
 
 	# Possibly decrypt a filesystem using native encryption.
 	decrypt_fs "$fs"
 
 	[ "$quiet" != "y" ] && \
 	    zfs_log_begin_msg "Mounting '${fs}' on '${rootmnt}/${mountpoint}'"
 	[ -n "${ZFS_DEBUG}" ] && \
 	    zfs_log_begin_msg "CMD: '$ZFS_CMD ${fs} ${rootmnt}/${mountpoint}'"
 
 	ZFS_STDERR=$(${ZFS_CMD} "${fs}" "${rootmnt}/${mountpoint}" 2>&1)
 	ZFS_ERROR=$?
 	if [ "${ZFS_ERROR}" != 0 ]
 	then
 		[ "$quiet" != "y" ] && zfs_log_failure_msg "${ZFS_ERROR}"
 
 		disable_plymouth
 		echo ""
 		echo "Command: ${ZFS_CMD} ${fs} ${rootmnt}/${mountpoint}"
 		echo "Message: $ZFS_STDERR"
 		echo "Error: $ZFS_ERROR"
 		echo ""
 		echo "Failed to mount ${fs} on ${rootmnt}/${mountpoint}."
 		echo "Manually mount the filesystem and exit."
 		shell
 	else
 		[ "$quiet" != "y" ] && zfs_log_end_msg
 	fi
 
 	return 0
 }
 
 # Unlock a ZFS native encrypted filesystem.
 decrypt_fs()
 {
 	fs="$1"
 
 	# If pool encryption is active and the zfs command understands '-o encryption'
 	if [ "$(zpool list -H -o feature@encryption "${fs%%/*}")" = 'active' ]; then
 
 		# Determine dataset that holds key for root dataset
 		ENCRYPTIONROOT="$(get_fs_value "${fs}" encryptionroot)"
 		KEYLOCATION="$(get_fs_value "${ENCRYPTIONROOT}" keylocation)"
 
 		echo "${ENCRYPTIONROOT}" > /run/zfs_fs_name
 
 		# If root dataset is encrypted...
 		if ! [ "${ENCRYPTIONROOT}" = "-" ]; then
 			KEYSTATUS="$(get_fs_value "${ENCRYPTIONROOT}" keystatus)"
 			# Continue only if the key needs to be loaded
 			[ "$KEYSTATUS" = "unavailable" ] || return 0
 
 			# Try extensions first
 			for f in "/etc/zfs/initramfs-tools-load-key" "/etc/zfs/initramfs-tools-load-key.d/"*; do
 				[ -r "$f" ] || continue
 				(. "$f") && {
 					# Successful return and actually-loaded key: we're done
 					KEYSTATUS="$(get_fs_value "${ENCRYPTIONROOT}" keystatus)"
 					[ "$KEYSTATUS" = "unavailable" ] || return 0
 				}
 			done
 
 			# Do not prompt if key is stored noninteractively,
 			if ! [ "${KEYLOCATION}" = "prompt" ]; then
 				$ZFS load-key "${ENCRYPTIONROOT}"
 
 			# Prompt with plymouth, if active
 			elif /bin/plymouth --ping 2>/dev/null; then
 				echo "plymouth" > /run/zfs_console_askpwd_cmd
 				for _ in 1 2 3; do
 					plymouth ask-for-password --prompt "Encrypted ZFS password for ${ENCRYPTIONROOT}" | \
 						$ZFS load-key "${ENCRYPTIONROOT}" && break
 				done
 
 			# Prompt with systemd, if active
 			elif [ -e /run/systemd/system ]; then
 				echo "systemd-ask-password" > /run/zfs_console_askpwd_cmd
 				for _ in 1 2 3; do
 					systemd-ask-password --no-tty "Encrypted ZFS password for ${ENCRYPTIONROOT}" | \
 						$ZFS load-key "${ENCRYPTIONROOT}" && break
 				done
 
 			# Prompt with ZFS tty, otherwise
 			else
 				# Temporarily setting "printk" to "7" allows the prompt to appear even when the "quiet" kernel option has been used
 				echo "load-key" > /run/zfs_console_askpwd_cmd
 				read -r storeprintk _ < /proc/sys/kernel/printk
 				echo 7 > /proc/sys/kernel/printk
 				$ZFS load-key "${ENCRYPTIONROOT}"
 				echo "$storeprintk" > /proc/sys/kernel/printk
 			fi
 		fi
 	fi
 
 	return 0
 }
 
 # Destroy a given filesystem.
 destroy_fs()
 {
 	fs="$1"
 
 	[ "$quiet" != "y" ] && \
 	    zfs_log_begin_msg "Destroying '$fs'"
 
 	ZFS_CMD="${ZFS} destroy $fs"
 	ZFS_STDERR="$(${ZFS_CMD} 2>&1)"
 	ZFS_ERROR="$?"
 	if [ "${ZFS_ERROR}" != 0 ]
 	then
 		[ "$quiet" != "y" ] && zfs_log_failure_msg "${ZFS_ERROR}"
 
 		disable_plymouth
 		echo ""
 		echo "Command: $ZFS_CMD"
 		echo "Message: $ZFS_STDERR"
 		echo "Error: $ZFS_ERROR"
 		echo ""
 		echo "Failed to destroy '$fs'. Please make sure that '$fs' is not available."
 		echo "Hint: Try:  zfs destroy -Rfn $fs"
 		echo "If this dryrun looks good, then remove the 'n' from '-Rfn' and try again."
 		shell
 	else
 		[ "$quiet" != "y" ] && zfs_log_end_msg
 	fi
 
 	return 0
 }
 
 # Clone snapshot $1 to destination filesystem $2
 # Set 'canmount=noauto' and 'mountpoint=none' so that we get to keep
 # manual control over it's mounting (i.e., make sure it's not automatically
 # mounted with a 'zfs mount -a' in the init/systemd scripts).
 clone_snap()
 {
 	snap="$1"
 	destfs="$2"
 	mountpoint="$3"
 
 	[ "$quiet" != "y" ] && zfs_log_begin_msg "Cloning '$snap' to '$destfs'"
 
 	# Clone the snapshot into a dataset we can boot from
 	# + We don't want this filesystem to be automatically mounted, we
 	#   want control over this here and nowhere else.
 	# + We don't need any mountpoint set for the same reason.
 	# We use the 'org.zol:mountpoint' property to remember the mountpoint.
 	ZFS_CMD="${ZFS} clone -o canmount=noauto -o mountpoint=none"
 	ZFS_CMD="${ZFS_CMD} -o org.zol:mountpoint=${mountpoint}"
 	ZFS_CMD="${ZFS_CMD} $snap $destfs"
 	ZFS_STDERR="$(${ZFS_CMD} 2>&1)"
 	ZFS_ERROR="$?"
 	if [ "${ZFS_ERROR}" != 0 ]
 	then
 		[ "$quiet" != "y" ] && zfs_log_failure_msg "${ZFS_ERROR}"
 
 		disable_plymouth
 		echo ""
 		echo "Command: $ZFS_CMD"
 		echo "Message: $ZFS_STDERR"
 		echo "Error: $ZFS_ERROR"
 		echo ""
 		echo "Failed to clone snapshot."
 		echo "Make sure that any problems are corrected and then make sure"
 		echo "that the dataset '$destfs' exists and is bootable."
 		shell
 	else
 		[ "$quiet" != "y" ] && zfs_log_end_msg
 	fi
 
 	return 0
 }
 
 # Rollback a given snapshot.
 rollback_snap()
 {
 	snap="$1"
 
 	[ "$quiet" != "y" ] && zfs_log_begin_msg "Rollback $snap"
 
 	ZFS_CMD="${ZFS} rollback -Rf $snap"
 	ZFS_STDERR="$(${ZFS_CMD} 2>&1)"
 	ZFS_ERROR="$?"
 	if [ "${ZFS_ERROR}" != 0 ]
 	then
 		[ "$quiet" != "y" ] && zfs_log_failure_msg "${ZFS_ERROR}"
 
 		disable_plymouth
 		echo ""
 		echo "Command: $ZFS_CMD"
 		echo "Message: $ZFS_STDERR"
 		echo "Error: $ZFS_ERROR"
 		echo ""
 		echo "Failed to rollback snapshot."
 		shell
 	else
 		[ "$quiet" != "y" ] && zfs_log_end_msg
 	fi
 
 	return 0
 }
 
 # Get a list of snapshots, give them as a numbered list
 # to the user to choose from.
 ask_user_snap()
 {
 	fs="$1"
 
 	# We need to temporarily disable debugging. Set 'debug' so we
 	# remember to enabled it again.
 	if [ -n "${ZFS_DEBUG}" ]; then
 		unset ZFS_DEBUG
 		set +x
 		debug=1
 	fi
 
 	# Because we need the resulting snapshot, which is sent on
 	# stdout to the caller, we use stderr for our questions.
 	echo "What snapshot do you want to boot from?" > /dev/stderr
 	# shellcheck disable=SC2046
 	IFS="
 " set -- $("${ZFS}" list -H -oname -tsnapshot -r "${fs}")
 
 	i=1
 	for snap in "$@"; do
 		echo "  $i: $snap"
 		i=$((i + 1))
 	done > /dev/stderr
 
 	# expr instead of test here because [ a -lt 0 ] errors out,
 	# but expr falls back to lexicographical, which works out right
 	snapnr=0
 	while expr "$snapnr" "<" 1 > /dev/null ||
 	    expr "$snapnr" ">" "$#" > /dev/null
 	do
 		printf "%s" "Snap nr [1-$#]? " > /dev/stderr
 		read -r snapnr
 	done
 
 	# Re-enable debugging.
 	if [ -n "${debug}" ]; then
 		ZFS_DEBUG=1
 		set -x
 	fi
 
 	eval echo '$'"$snapnr"
 }
 
 setup_snapshot_booting()
 {
 	snap="$1"
 	retval=0
 
 	# Make sure that the snapshot specified actually exists.
 	if [ -z "$(get_fs_value "${snap}" type)" ]
 	then
 		# Snapshot does not exist (...@<null> ?)
 		# ask the user for a snapshot to use.
 		snap="$(ask_user_snap "${snap%%@*}")"
 	fi
 
 	# Separate the full snapshot ('$snap') into it's filesystem and
 	# snapshot names. Would have been nice with a split() function..
 	rootfs="${snap%%@*}"
 	snapname="${snap##*@}"
 	ZFS_BOOTFS="${rootfs}_${snapname}"
 
 	if ! grep -qiE '(^|[^\\](\\\\)* )(rollback)=(on|yes|1)( |$)' /proc/cmdline
 	then
 		# If the destination dataset for the clone
 		# already exists, destroy it. Recursively
 		if [ -n "$(get_fs_value "${rootfs}_${snapname}" type)" ]
 		then
 			filesystems=$("${ZFS}" list -oname -tfilesystem -H \
 			    -r -Sname "${ZFS_BOOTFS}")
 			for fs in $filesystems; do
 				destroy_fs "${fs}"
 			done
 		fi
 	fi
 
 	# Get all snapshots, recursively (might need to clone /usr, /var etc
 	# as well).
 	for s in $("${ZFS}" list -H -oname -tsnapshot -r "${rootfs}" | \
 	    grep "${snapname}")
 	do
 		if grep -qiE '(^|[^\\](\\\\)* )(rollback)=(on|yes|1)( |$)' /proc/cmdline
 		then
 			# Rollback snapshot
 			rollback_snap "$s" || retval=$((retval + 1))
 			ZFS_BOOTFS="${rootfs}"
 		else
 			# Setup a destination filesystem name.
 			# Ex: Called with 'rpool/ROOT/debian@snap2'
 			#       rpool/ROOT/debian@snap2		=> rpool/ROOT/debian_snap2
 			#       rpool/ROOT/debian/boot@snap2	=> rpool/ROOT/debian_snap2/boot
 			#       rpool/ROOT/debian/usr@snap2	=> rpool/ROOT/debian_snap2/usr
 			#       rpool/ROOT/debian/var@snap2	=> rpool/ROOT/debian_snap2/var
 			subfs="${s##"$rootfs"}"
 			subfs="${subfs%%@"$snapname"}"
 
 			destfs="${rootfs}_${snapname}" # base fs.
 			[ -n "$subfs" ] && destfs="${destfs}$subfs" # + sub fs.
 
 			# Get the mountpoint of the filesystem, to be used
 			# with clone_snap(). If legacy or none, then use
 			# the sub fs value.
 			mountpoint=$(get_fs_value "${s%%@*}" mountpoint)
 			if [ "$mountpoint" = "legacy" ] || \
 			   [ "$mountpoint" = "none" ]
 			then
 				if [ -n "${subfs}" ]; then
 					mountpoint="${subfs}"
 				else
 					mountpoint="/"
 				fi
 			fi
 
 			# Clone the snapshot into its own
 			# filesystem
 			clone_snap "$s" "${destfs}" "${mountpoint}" || \
 			    retval=$((retval + 1))
 		fi
 	done
 
 	# If we haven't return yet, we have a problem...
 	return "${retval}"
 }
 
 # ================================================================
 
 # This is the main function.
 mountroot()
 {
 	# ----------------------------------------------------------------
 	# I N I T I A L   S E T U P
 
 	# ------------
 	# Run the pre-mount scripts from /scripts/local-top.
 	pre_mountroot
 
 	# ------------
 	# Source the default setup variables.
 	[ -r '/etc/default/zfs' ] && . /etc/default/zfs
 
 	# ------------
 	# Support debug option
 	if grep -qiE '(^|[^\\](\\\\)* )(zfs_debug|zfs\.debug|zfsdebug)=(on|yes|1)( |$)' /proc/cmdline
 	then
 		ZFS_DEBUG=1
 		mkdir /var/log
 		#exec 2> /var/log/boot.debug
 		set -x
 	fi
 
 	# ------------
 	# Load ZFS module etc.
 	if ! load_module_initrd; then
 		disable_plymouth
 		echo ""
 		echo "Failed to load ZFS modules."
 		echo "Manually load the modules and exit."
 		shell
 	fi
 
 	# ------------
 	# Look for the cache file (if any).
 	[ -f "${ZPOOL_CACHE}" ] || unset ZPOOL_CACHE
 	[ -s "${ZPOOL_CACHE}" ] || unset ZPOOL_CACHE
 
 	# ------------
 	# Compatibility: 'ROOT' is for Debian GNU/Linux (etc),
 	#		 'root' is for Redhat/Fedora (etc),
 	#		 'REAL_ROOT' is for Gentoo
 	if [ -z "$ROOT" ]
 	then
 		[ -n "$root" ] && ROOT=${root}
 
 		[ -n "$REAL_ROOT" ] && ROOT=${REAL_ROOT}
 	fi
 
 	# ------------
 	# Where to mount the root fs in the initrd - set outside this script
 	# Compatibility: 'rootmnt' is for Debian GNU/Linux (etc),
 	#		 'NEWROOT' is for RedHat/Fedora (etc),
 	#		 'NEW_ROOT' is for Gentoo
 	if [ -z "$rootmnt" ]
 	then
 		[ -n "$NEWROOT" ] && rootmnt=${NEWROOT}
 
 		[ -n "$NEW_ROOT" ] && rootmnt=${NEW_ROOT}
 	fi
 
 	# ------------
 	# No longer set in the defaults file, but it could have been set in
 	# get_pools() in some circumstances. If it's something, but not 'yes',
 	# it's no good to us.
 	[ -n "$USE_DISK_BY_ID" ] && [ "$USE_DISK_BY_ID" != 'yes' ] && \
 	    unset USE_DISK_BY_ID
 
 	# ----------------------------------------------------------------
 	# P A R S E   C O M M A N D   L I N E   O P T I O N S
 
 	# This part is the really ugly part - there's so many options and permutations
 	# 'out there', and if we should make this the 'primary' source for ZFS initrd
 	# scripting, we need/should support them all.
 	#
 	# Supports the following kernel command line argument combinations
 	# (in this order - first match win):
 	#
 	#	rpool=<pool>			(tries to finds bootfs automatically)
 	#	bootfs=<pool>/<dataset>		(uses this for rpool - first part)
 	#	rpool=<pool> bootfs=<pool>/<dataset>
 	#	-B zfs-bootfs=<pool>/<fs>	(uses this for rpool - first part)
 	#	rpool=rpool			(default if none of the above is used)
 	#	root=<pool>/<dataset>		(uses this for rpool - first part)
 	#	root=ZFS=<pool>/<dataset>	(uses this for rpool - first part, without 'ZFS=')
 	#	root=zfs:AUTO			(tries to detect both pool and rootfs)
 	#	root=zfs:<pool>/<dataset>	(uses this for rpool - first part, without 'zfs:')
 	#
 	# Option <dataset> could also be <snapshot>
 	# Option <pool> could also be <guid>
 
 	# ------------
 	# Support force option
 	# In addition, setting one of zfs_force, zfs.force or zfsforce to
 	# 'yes', 'on' or '1' will make sure we force import the pool.
 	# This should (almost) never be needed, but it's here for
 	# completeness.
 	ZPOOL_FORCE=""
 	if grep -qiE '(^|[^\\](\\\\)* )(zfs_force|zfs\.force|zfsforce)=(on|yes|1)( |$)' /proc/cmdline
 	then
 		ZPOOL_FORCE="-f"
 	fi
 
 	# ------------
 	# Look for 'rpool' and 'bootfs' parameter
 	[ -n "$rpool" ] && ZFS_RPOOL="${rpool#rpool=}"
 	[ -n "$bootfs" ] && ZFS_BOOTFS="${bootfs#bootfs=}"
 
 	# ------------
 	# If we have 'ROOT' (see above), but not 'ZFS_BOOTFS', then use
 	# 'ROOT'
 	[ -n "$ROOT" ] && [ -z "${ZFS_BOOTFS}" ] && ZFS_BOOTFS="$ROOT"
 
 	# ------------
 	# Check for the `-B zfs-bootfs=%s/%u,...` kind of parameter.
 	# NOTE: Only use the pool name and dataset. The rest is not
 	#       supported by OpenZFS (whatever it's for).
 	if [ -z "$ZFS_RPOOL" ]
 	then
 		# The ${zfs-bootfs} variable is set at the kernel command
 		# line, usually by GRUB, but it cannot be referenced here
 		# directly because bourne variable names cannot contain a
 		# hyphen.
 		#
 		# Reassign the variable by dumping the environment and
 		# stripping the zfs-bootfs= prefix.  Let the shell handle
 		# quoting through the eval command:
 		# shellcheck disable=SC2046
 		eval ZFS_RPOOL=$(set | sed -n -e 's,^zfs-bootfs=,,p')
 	fi
 
 	# ------------
 	# No root fs or pool specified - do auto detect.
 	if [ -z "$ZFS_RPOOL" ] && [ -z "${ZFS_BOOTFS}" ]
 	then
 		# Do auto detect. Do this by 'cheating' - set 'root=zfs:AUTO'
 		# which will be caught later
 		ROOT='zfs:AUTO'
 	fi
 
 	# ----------------------------------------------------------------
 	# F I N D   A N D   I M P O R T   C O R R E C T   P O O L
 
 	# ------------
 	if [ "$ROOT" = "zfs:AUTO" ]
 	then
 		# Try to detect both pool and root fs.
 
 		# If we got here, that means we don't have a hint so as to
 		# the root dataset, but with root=zfs:AUTO on cmdline,
 		# this says "zfs:AUTO" here and interferes with checks later
 		ZFS_BOOTFS=
 
 		[ "$quiet" != "y" ] && \
 		    zfs_log_begin_msg "Attempting to import additional pools."
 
 		# Get a list of pools available for import
 		if [ -n "$ZFS_RPOOL" ]
 		then
 			# We've specified a pool - check only that
 			POOLS=$ZFS_RPOOL
 		else
 			POOLS=$(get_pools)
 		fi
 
 		OLD_IFS="$IFS" ; IFS=";"
 		for pool in $POOLS
 		do
 			[ -z "$pool" ] && continue
 
 			IFS="$OLD_IFS" import_pool "$pool"
 			IFS="$OLD_IFS" find_rootfs "$pool" && break
 		done
 		IFS="$OLD_IFS"
 
 		[ "$quiet" != "y" ] && zfs_log_end_msg "$ZFS_ERROR"
 	else
 		# No auto - use value from the command line option.
 
 		# Strip 'zfs:' and 'ZFS='.
 		ZFS_BOOTFS="${ROOT#*[:=]}"
 
 		# Strip everything after the first slash.
 		ZFS_RPOOL="${ZFS_BOOTFS%%/*}"
 	fi
 
 	# Import the pool (if not already done so in the AUTO check above).
 	if [ -n "$ZFS_RPOOL" ] && [ -z "${POOL_IMPORTED}" ]
 	then
 		[ "$quiet" != "y" ] && \
 		    zfs_log_begin_msg "Importing ZFS root pool '$ZFS_RPOOL'"
 
 		import_pool "${ZFS_RPOOL}"
 		find_rootfs "${ZFS_RPOOL}"
 
 		[ "$quiet" != "y" ] && zfs_log_end_msg
 	fi
 
 	if [ -z "${POOL_IMPORTED}" ]
 	then
 		# No pool imported, this is serious!
 		disable_plymouth
 		echo ""
 		echo "Command: $ZFS_CMD"
 		echo "Message: $ZFS_STDERR"
 		echo "Error: $ZFS_ERROR"
 		echo ""
 		echo "No pool imported. Manually import the root pool"
 		echo "at the command prompt and then exit."
 		echo "Hint: Try:  zpool import -N ${ZFS_RPOOL}"
 		shell
 	fi
 
 	# In case the pool was specified as guid, resolve guid to name
 	pool="$("${ZPOOL}" get -H -o name,value name,guid | \
 	    awk -v pool="${ZFS_RPOOL}" '$2 == pool { print $1 }')"
 	if [ -n "$pool" ]; then
 		# If $ZFS_BOOTFS contains guid, replace the guid portion with $pool
 		ZFS_BOOTFS=$(echo "$ZFS_BOOTFS" | \
 			sed -e "s/$("${ZPOOL}" get -H -o value guid "$pool")/$pool/g")
 		ZFS_RPOOL="${pool}"
 	fi
 
 
 	# ----------------------------------------------------------------
 	# P R E P A R E   R O O T   F I L E S Y S T E M
 
 	if [ -n "${ZFS_BOOTFS}" ]
 	then
 		# Booting from a snapshot?
 		# Will overwrite the ZFS_BOOTFS variable like so:
 		#   rpool/ROOT/debian@snap2 => rpool/ROOT/debian_snap2
 		echo "${ZFS_BOOTFS}" | grep -q '@' && \
 		    setup_snapshot_booting "${ZFS_BOOTFS}"
 	fi
 
 	if [ -z "${ZFS_BOOTFS}" ]
 	then
 		# Still nothing! Let the user sort this out.
 		disable_plymouth
 		echo ""
 		echo "Error: Unknown root filesystem - no 'bootfs' pool property and"
 		echo "       not specified on the kernel command line."
 		echo ""
 		echo "Manually mount the root filesystem on $rootmnt and then exit."
 		echo "Hint: Try:  mount -o zfsutil -t zfs ${ZFS_RPOOL-rpool}/ROOT/system $rootmnt"
 		shell
 	fi
 
 	# ----------------------------------------------------------------
 	# M O U N T   F I L E S Y S T E M S
 
 	# * Ideally, the root filesystem would be mounted like this:
 	#
 	#     zpool import -R "$rootmnt" -N "$ZFS_RPOOL"
 	#     zfs mount -o mountpoint=/ "${ZFS_BOOTFS}"
 	#
 	#   but the MOUNTPOINT prefix is preserved on descendent filesystem
 	#   after the pivot into the regular root, which later breaks things
 	#   like `zfs mount -a` and the /proc/self/mounts refresh.
 	#
 	# * Mount additional filesystems required
 	#   Such as /usr, /var, /usr/local etc.
 	#   NOTE: Mounted in the order specified in the
 	#         ZFS_INITRD_ADDITIONAL_DATASETS variable so take care!
 
 	# Go through the complete list (recursively) of all filesystems below
 	# the real root dataset
 	filesystems="$("${ZFS}" list -oname -tfilesystem -H -r "${ZFS_BOOTFS}")"
 	OLD_IFS="$IFS" ; IFS="
 "
 	for fs in $filesystems; do
 		IFS="$OLD_IFS" mount_fs "$fs"
 	done
 	IFS="$OLD_IFS"
 	for fs in $ZFS_INITRD_ADDITIONAL_DATASETS; do
 		mount_fs "$fs"
 	done
 
 	touch /run/zfs_unlock_complete
 	if [ -e /run/zfs_unlock_complete_notify ]; then
 		read -r < /run/zfs_unlock_complete_notify
 	fi
 
 	# ------------
 	# Debugging information
 	if [ -n "${ZFS_DEBUG}" ]
 	then
 		#exec 2>&1-
 
 		echo "DEBUG: imported pools:"
 		"${ZPOOL}" list -H
 		echo
 
 		echo "DEBUG: mounted ZFS filesystems:"
 		mount | grep zfs
 		echo
 
 		echo "=> waiting for ENTER before continuing because of 'zfsdebug=1'. "
 		printf "%s" "   'c' for shell, 'r' for reboot, 'ENTER' to continue. "
 		read -r b
 
 		[ "$b" = "c" ] && /bin/sh
 		[ "$b" = "r" ] && reboot -f
 
 		set +x
 	fi
 
 	# ------------
 	# Run local bottom script
 	if command -v run_scripts > /dev/null 2>&1
 	then
 		if [ -f "/scripts/local-bottom" ] || [ -d "/scripts/local-bottom" ]
 		then
 			[ "$quiet" != "y" ] && \
 			    zfs_log_begin_msg "Running /scripts/local-bottom"
 			run_scripts /scripts/local-bottom
 			[ "$quiet" != "y" ] && zfs_log_end_msg
 		fi
 	fi
 }
diff --git a/sys/contrib/openzfs/include/libzutil.h b/sys/contrib/openzfs/include/libzutil.h
index e2108ceeaa44..f8712340cc5e 100644
--- a/sys/contrib/openzfs/include/libzutil.h
+++ b/sys/contrib/openzfs/include/libzutil.h
@@ -1,286 +1,290 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2018, 2024 by Delphix. All rights reserved.
  */
 
 #ifndef	_LIBZUTIL_H
 #define	_LIBZUTIL_H extern __attribute__((visibility("default")))
 
 #include <string.h>
 #include <locale.h>
 #include <sys/nvpair.h>
 #include <sys/fs/zfs.h>
 
 #ifdef	__cplusplus
 extern "C" {
 #endif
 
 /*
  * Default wait time in milliseconds 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.
  */
 _LIBZUTIL_H pool_config_ops_t libzfs_config_ops;
 _LIBZUTIL_H pool_config_ops_t libzpool_config_ops;
 
 typedef enum lpc_error {
 	LPC_SUCCESS = 0,	/* no error -- success */
 	LPC_BADCACHE = 2000,	/* out of memory */
 	LPC_BADPATH,	/* must be an absolute path */
 	LPC_NOMEM,	/* out of memory */
 	LPC_EACCESS,	/* some devices require root privileges */
 	LPC_UNKNOWN
 } lpc_error_t;
 
 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.)	*/
 	boolean_t do_destroyed;
 	boolean_t do_all;
 } importargs_t;
 
 typedef struct libpc_handle {
 	int lpc_error;
 	boolean_t lpc_printerr;
 	boolean_t lpc_open_access_error;
 	boolean_t lpc_desc_active;
 	char lpc_desc[1024];
 	pool_config_ops_t *lpc_ops;
 	void *lpc_lib_handle;
 } libpc_handle_t;
 
 _LIBZUTIL_H const char *libpc_error_description(libpc_handle_t *);
 _LIBZUTIL_H nvlist_t *zpool_search_import(libpc_handle_t *, importargs_t *);
 _LIBZUTIL_H int zpool_find_config(libpc_handle_t *, const char *, nvlist_t **,
     importargs_t *);
 
 _LIBZUTIL_H const char * const * zpool_default_search_paths(size_t *count);
 _LIBZUTIL_H int zpool_read_label(int, nvlist_t **, int *);
 _LIBZUTIL_H int zpool_label_disk_wait(const char *, int);
 _LIBZUTIL_H int zpool_disk_wait(const char *);
 
 struct udev_device;
 
 _LIBZUTIL_H int zfs_device_get_devid(struct udev_device *, char *, size_t);
 _LIBZUTIL_H int zfs_device_get_physical(struct udev_device *, char *, size_t);
 
 _LIBZUTIL_H 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"
 
 _LIBZUTIL_H int zfs_append_partition(char *path, size_t max_len);
 _LIBZUTIL_H int zfs_resolve_shortname(const char *name, char *path,
     size_t pathlen);
 
 _LIBZUTIL_H char *zfs_strip_partition(const char *);
 _LIBZUTIL_H const char *zfs_strip_path(const char *);
 
 _LIBZUTIL_H int zfs_strcmp_pathname(const char *, const char *, int);
 
 _LIBZUTIL_H boolean_t zfs_dev_is_dm(const char *);
 _LIBZUTIL_H boolean_t zfs_dev_is_whole_disk(const char *);
 _LIBZUTIL_H int zfs_dev_flush(int);
 _LIBZUTIL_H char *zfs_get_underlying_path(const char *);
 _LIBZUTIL_H char *zfs_get_enclosure_sysfs_path(const char *);
 
 _LIBZUTIL_H boolean_t is_mpath_whole_disk(const char *);
 
 _LIBZUTIL_H 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.
  */
 _LIBZUTIL_H void zfs_nicebytes(uint64_t, char *, size_t);
 _LIBZUTIL_H void zfs_nicenum(uint64_t, char *, size_t);
 _LIBZUTIL_H void zfs_nicenum_format(uint64_t, char *, size_t,
     enum zfs_nicenum_format);
 _LIBZUTIL_H void zfs_nicetime(uint64_t, char *, size_t);
 _LIBZUTIL_H void zfs_niceraw(uint64_t, char *, size_t);
 
 #define	nicenum(num, buf, size)	zfs_nicenum(num, buf, size)
 
 _LIBZUTIL_H void zpool_dump_ddt(const ddt_stat_t *, const ddt_histogram_t *);
 _LIBZUTIL_H int zpool_history_unpack(char *, uint64_t, uint64_t *, nvlist_t ***,
     uint_t *);
 _LIBZUTIL_H void fsleep(float sec);
 _LIBZUTIL_H int zpool_getenv_int(const char *env, int default_val);
 
 struct zfs_cmd;
 
 /*
  * List of colors to use
  */
 #define	ANSI_BLACK	"\033[0;30m"
 #define	ANSI_RED	"\033[0;31m"
 #define	ANSI_GREEN	"\033[0;32m"
 #define	ANSI_YELLOW	"\033[0;33m"
 #define	ANSI_BLUE	"\033[0;34m"
 #define	ANSI_BOLD_BLUE	"\033[1;34m" /* light blue */
 #define	ANSI_MAGENTA	"\033[0;35m"
 #define	ANSI_CYAN	"\033[0;36m"
 #define	ANSI_GRAY	"\033[0;37m"
 
 #define	ANSI_RESET	"\033[0m"
 #define	ANSI_BOLD	"\033[1m"
 
 _LIBZUTIL_H int use_color(void);
 _LIBZUTIL_H void color_start(const char *color);
 _LIBZUTIL_H void color_end(void);
 _LIBZUTIL_H int printf_color(const char *color, const char *format, ...);
 
 _LIBZUTIL_H const char *zfs_basename(const char *path);
 _LIBZUTIL_H ssize_t zfs_dirnamelen(const char *path);
 #ifdef __linux__
 extern char **environ;
 _LIBZUTIL_H void zfs_setproctitle_init(int argc, char *argv[], char *envp[]);
 _LIBZUTIL_H void zfs_setproctitle(const char *fmt, ...);
 #else
 #define	zfs_setproctitle(fmt, ...)	setproctitle(fmt, ##__VA_ARGS__)
 #define	zfs_setproctitle_init(x, y, z)	((void)0)
 #endif
 
 /*
  * 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_macro_helper_func(void *zhp_data, nvlist_t *nv, void *data);
 int for_each_real_leaf_vdev_macro_helper_func(void *zhp_data, nvlist_t *nv,
     void *data);
 /*
  * Often you'll want to iterate over all the vdevs in the pool, but don't want
  * to use for_each_vdev() since it requires a callback function.
  *
  * Instead you can use FOR_EACH_VDEV():
  *
  *     zpool_handle_t *zhp      // Assume this is initialized
  *     nvlist_t *nv
  *     ...
  *     FOR_EACH_VDEV(zhp, nv) {
  *	 const char *path = NULL;
  *	 nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path);
  *	 printf("Looking at vdev %s\n", path);
  *     }
  *
  * Note: FOR_EACH_VDEV runs in O(n^2) time where n = number of vdevs.  However,
  * there's an upper limit of 256 vdevs per dRAID top-level vdevs (TLDs), 255 for
  * raidz2 TLDs, a real world limit of ~500 vdevs for mirrors, so this shouldn't
  * really be an issue.
  *
  * Here are some micro-benchmarks of a complete FOR_EACH_VDEV loop on a RAID0
  * pool:
  *
  * 100  vdevs = 0.7ms
  * 500  vdevs = 17ms
  * 750  vdevs = 40ms
  * 1000 vdevs = 82ms
  *
  * The '__nv += 0' at the end of the for() loop gets around a "comma or
  * semicolon followed by non-blank" checkstyle error.  Note on most compliers
  * the '__nv += 0' can just be replaced with 'NULL', but gcc on Centos 7
  * will give a 'warning: statement with no effect' error if you do that.
  */
 #define	__FOR_EACH_VDEV(__zhp, __nv, __func) { \
 	__nv = zpool_get_config(__zhp, NULL); \
 	VERIFY0(nvlist_lookup_nvlist(__nv, ZPOOL_CONFIG_VDEV_TREE, &__nv)); \
 	} \
 	for (nvlist_t *__root_nv = __nv, *__state = (nvlist_t *)0; \
 	    for_each_vdev_cb(&__state, __root_nv, __func, &__nv) == 1; \
 	    __nv += 0)
 
 #define	FOR_EACH_VDEV(__zhp, __nv) \
 	__FOR_EACH_VDEV(__zhp, __nv, for_each_vdev_macro_helper_func)
 
 /*
  * "real leaf" vdevs are leaf vdevs that are real devices (disks or files).
  * This excludes leaf vdevs like like draid spares.
  */
 #define	FOR_EACH_REAL_LEAF_VDEV(__zhp, __nv) \
 	__FOR_EACH_VDEV(__zhp, __nv, for_each_real_leaf_vdev_macro_helper_func)
 
 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);
 _LIBZUTIL_H void update_vdev_config_dev_sysfs_path(nvlist_t *nv,
     const char *path, const char *key);
 
 /*
  * Thread-safe strerror() for use in ZFS libraries
  */
 static inline char *zfs_strerror(int errnum) {
+#ifdef HAVE_STRERROR_L
 	return (strerror_l(errnum, uselocale(0)));
+#else
+	return (strerror(errnum));
+#endif
 }
 
 #ifdef	__cplusplus
 }
 #endif
 
 #endif	/* _LIBZUTIL_H */
diff --git a/sys/contrib/openzfs/include/os/linux/spl/sys/taskq.h b/sys/contrib/openzfs/include/os/linux/spl/sys/taskq.h
index f63a397f293d..4cb3a055c3c4 100644
--- a/sys/contrib/openzfs/include/os/linux/spl/sys/taskq.h
+++ b/sys/contrib/openzfs/include/os/linux/spl/sys/taskq.h
@@ -1,214 +1,213 @@
 /*
  *  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/>.
  */
 /*
  * Copyright (c) 2024, Klara Inc.
  * Copyright (c) 2024, Syneto
  */
 
 #ifndef _SPL_TASKQ_H
 #define	_SPL_TASKQ_H
 
 #include <linux/module.h>
 #include <linux/gfp.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/kthread.h>
 #include <sys/types.h>
 #include <sys/thread.h>
 #include <sys/rwlock.h>
 #include <sys/wait.h>
 #include <sys/wmsum.h>
-
-typedef struct kstat_s kstat_t;
+#include <sys/kstat.h>
 
 #define	TASKQ_NAMELEN		31
 
 #define	TASKQ_PREPOPULATE	0x00000001
 #define	TASKQ_CPR_SAFE		0x00000002
 #define	TASKQ_DYNAMIC		0x00000004
 #define	TASKQ_THREADS_CPU_PCT	0x00000008
 #define	TASKQ_DC_BATCH		0x00000010
 #define	TASKQ_ACTIVE		0x80000000
 
 /*
  * Flags for taskq_dispatch. TQ_SLEEP/TQ_NOSLEEP should be same as
  * KM_SLEEP/KM_NOSLEEP.  TQ_NOQUEUE/TQ_NOALLOC are set particularly
  * large so as not to conflict with already used GFP_* defines.
  */
 #define	TQ_SLEEP		0x00000000
 #define	TQ_NOSLEEP		0x00000001
 #define	TQ_PUSHPAGE		0x00000002
 #define	TQ_NOQUEUE		0x01000000
 #define	TQ_NOALLOC		0x02000000
 #define	TQ_NEW			0x04000000
 #define	TQ_FRONT		0x08000000
 
 /*
  * Reserved taskqid values.
  */
 #define	TASKQID_INVALID		((taskqid_t)0)
 #define	TASKQID_INITIAL		((taskqid_t)1)
 
 /*
  * spin_lock(lock) and spin_lock_nested(lock,0) are equivalent,
  * so TQ_LOCK_DYNAMIC must not evaluate to 0
  */
 typedef enum tq_lock_role {
 	TQ_LOCK_GENERAL =	0,
 	TQ_LOCK_DYNAMIC =	1,
 } tq_lock_role_t;
 
 typedef unsigned long taskqid_t;
 typedef void (task_func_t)(void *);
 
 typedef struct taskq_sums {
 	/* gauges (inc/dec counters, current value) */
 	wmsum_t tqs_threads_active;		/* threads running a task */
 	wmsum_t tqs_threads_idle;		/* threads waiting for work */
 	wmsum_t tqs_threads_total;		/* total threads */
 	wmsum_t tqs_tasks_pending;		/* tasks waiting to execute */
 	wmsum_t tqs_tasks_priority;		/* hi-pri tasks waiting */
 	wmsum_t tqs_tasks_total;		/* total waiting tasks */
 	wmsum_t tqs_tasks_delayed;		/* tasks deferred to future */
 	wmsum_t tqs_entries_free;		/* task entries on free list */
 
 	/* counters (inc only, since taskq creation) */
 	wmsum_t tqs_threads_created;		/* threads created */
 	wmsum_t tqs_threads_destroyed;		/* threads destroyed */
 	wmsum_t tqs_tasks_dispatched;		/* tasks dispatched */
 	wmsum_t tqs_tasks_dispatched_delayed;	/* tasks delayed to future */
 	wmsum_t tqs_tasks_executed_normal;	/* normal pri tasks executed */
 	wmsum_t tqs_tasks_executed_priority;	/* high pri tasks executed */
 	wmsum_t tqs_tasks_executed;		/* total tasks executed */
 	wmsum_t tqs_tasks_delayed_requeued;	/* delayed tasks requeued */
 	wmsum_t tqs_tasks_cancelled;		/* tasks cancelled before run */
 	wmsum_t tqs_thread_wakeups;		/* total thread wakeups */
 	wmsum_t tqs_thread_wakeups_nowork;	/* thread woken but no tasks */
 	wmsum_t tqs_thread_sleeps;		/* total thread sleeps */
 } taskq_sums_t;
 
 typedef struct taskq {
 	spinlock_t		tq_lock;	/* protects taskq_t */
 	char			*tq_name;	/* taskq name */
 	int			tq_instance;	/* instance of tq_name */
 	struct list_head	tq_thread_list;	/* list of all threads */
 	struct list_head	tq_active_list;	/* list of active threads */
 	int			tq_nactive;	/* # of active threads */
 	int			tq_nthreads;	/* # of existing threads */
 	int			tq_nspawn;	/* # of threads being spawned */
 	int			tq_maxthreads;	/* # of threads maximum */
 	/* If PERCPU flag is set, percent of NCPUs to have as threads */
 	int			tq_cpu_pct;
 	int			tq_pri;		/* priority */
 	int			tq_minalloc;	/* min taskq_ent_t pool size */
 	int			tq_maxalloc;	/* max taskq_ent_t pool size */
 	int			tq_nalloc;	/* cur taskq_ent_t pool size */
 	uint_t			tq_flags;	/* flags */
 	taskqid_t		tq_next_id;	/* next pend/work id */
 	taskqid_t		tq_lowest_id;	/* lowest pend/work id */
 	struct list_head	tq_free_list;	/* free taskq_ent_t's */
 	struct list_head	tq_pend_list;	/* pending taskq_ent_t's */
 	struct list_head	tq_prio_list;	/* priority taskq_ent_t's */
 	struct list_head	tq_delay_list;	/* delayed taskq_ent_t's */
 	struct list_head	tq_taskqs;	/* all taskq_t's */
 	wait_queue_head_t	tq_work_waitq;	/* new work waitq */
 	wait_queue_head_t	tq_wait_waitq;	/* wait waitq */
 	tq_lock_role_t		tq_lock_class;	/* class when taking tq_lock */
 	/* list node for the cpu hotplug callback */
 	struct hlist_node	tq_hp_cb_node;
 	boolean_t		tq_hp_support;
 	unsigned long		lastspawnstop;	/* when to purge dynamic */
 	taskq_sums_t		tq_sums;
 	kstat_t			*tq_ksp;
 } taskq_t;
 
 typedef struct taskq_ent {
 	spinlock_t		tqent_lock;
 	wait_queue_head_t	tqent_waitq;
 	struct timer_list	tqent_timer;
 	struct list_head	tqent_list;
 	taskqid_t		tqent_id;
 	task_func_t		*tqent_func;
 	void			*tqent_arg;
 	taskq_t			*tqent_taskq;
 	uintptr_t		tqent_flags;
 	unsigned long		tqent_birth;
 } taskq_ent_t;
 
 #define	TQENT_FLAG_PREALLOC	0x1
 #define	TQENT_FLAG_CANCEL	0x2
 
 /* bits 2-3 are which list tqent is on */
 #define	TQENT_LIST_NONE		0x0
 #define	TQENT_LIST_PENDING	0x4
 #define	TQENT_LIST_PRIORITY	0x8
 #define	TQENT_LIST_DELAY	0xc
 #define	TQENT_LIST_MASK		0xc
 
 typedef struct taskq_thread {
 	struct list_head	tqt_thread_list;
 	struct list_head	tqt_active_list;
 	struct task_struct	*tqt_thread;
 	taskq_t			*tqt_tq;
 	taskqid_t		tqt_id;
 	taskq_ent_t		*tqt_task;
 	uintptr_t		tqt_flags;
 } taskq_thread_t;
 
 /* Global system-wide dynamic task queue available for all consumers */
 extern taskq_t *system_taskq;
 /* Global dynamic task queue for long delay */
 extern taskq_t *system_delay_taskq;
 
 /* List of all taskqs */
 extern struct list_head tq_list;
 extern struct rw_semaphore tq_list_sem;
 
 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 taskq_t *taskq_create(const char *, int, pri_t, int, int, uint_t);
 extern taskq_t *taskq_create_synced(const char *, int, pri_t, int, int, uint_t,
     kthread_t ***);
 extern void taskq_destroy(taskq_t *);
 extern void taskq_wait_id(taskq_t *, taskqid_t);
 extern void taskq_wait_outstanding(taskq_t *, taskqid_t);
 extern void taskq_wait(taskq_t *);
 extern int taskq_cancel_id(taskq_t *, taskqid_t);
 extern int taskq_member(taskq_t *, kthread_t *);
 extern taskq_t *taskq_of_curthread(void);
 
 #define	taskq_create_proc(name, nthreads, pri, min, max, proc, flags) \
     taskq_create(name, nthreads, pri, min, max, flags)
 #define	taskq_create_sysdc(name, nthreads, min, max, proc, dc, flags) \
 	((void) sizeof (dc), \
 	    taskq_create(name, nthreads, maxclsyspri, min, max, flags))
 
 int spl_taskq_init(void);
 void spl_taskq_fini(void);
 
 #endif  /* _SPL_TASKQ_H */
diff --git a/sys/contrib/openzfs/include/os/linux/zfs/sys/abd_os.h b/sys/contrib/openzfs/include/os/linux/zfs/sys/abd_os.h
index 606e8bf682e8..3eed968e90c0 100644
--- a/sys/contrib/openzfs/include/os/linux/zfs/sys/abd_os.h
+++ b/sys/contrib/openzfs/include/os/linux/zfs/sys/abd_os.h
@@ -1,65 +1,65 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 /*
  * Copyright (c) 2014 by Chunwei Chen. All rights reserved.
  * Copyright (c) 2016, 2019 by Delphix. All rights reserved.
  */
 
 #ifndef _ABD_OS_H
 #define	_ABD_OS_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+struct abd;
+
 struct abd_scatter {
 	uint_t		abd_offset;
 	uint_t		abd_nents;
 	struct scatterlist *abd_sgl;
 };
 
 struct abd_linear {
 	void		*abd_buf;
 	struct scatterlist *abd_sgl; /* for LINEAR_PAGE */
 };
 
-typedef struct abd abd_t;
-
 typedef int abd_iter_page_func_t(struct page *, size_t, size_t, void *);
-int abd_iterate_page_func(abd_t *, size_t, size_t, abd_iter_page_func_t *,
+int abd_iterate_page_func(struct abd *, size_t, size_t, abd_iter_page_func_t *,
     void *);
 
 /*
  * Linux ABD bio functions
  * Note: these are only needed to support vdev_classic. See comment in
  * vdev_disk.c.
  */
-unsigned int abd_bio_map_off(struct bio *, abd_t *, unsigned int, size_t);
-unsigned long abd_nr_pages_off(abd_t *, unsigned int, size_t);
+unsigned int abd_bio_map_off(struct bio *, struct abd *, unsigned int, size_t);
+unsigned long abd_nr_pages_off(struct abd *, unsigned int, size_t);
 
 __attribute__((malloc))
-abd_t *abd_alloc_from_pages(struct page **, unsigned long, uint64_t);
+struct abd *abd_alloc_from_pages(struct page **, unsigned long, uint64_t);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif	/* _ABD_H */
diff --git a/sys/contrib/openzfs/include/os/linux/zfs/sys/zfs_vfsops_os.h b/sys/contrib/openzfs/include/os/linux/zfs/sys/zfs_vfsops_os.h
index 7067eb17900d..30aa3a103d33 100644
--- a/sys/contrib/openzfs/include/os/linux/zfs/sys/zfs_vfsops_os.h
+++ b/sys/contrib/openzfs/include/os/linux/zfs/sys/zfs_vfsops_os.h
@@ -1,256 +1,257 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2013, 2018 by Delphix. All rights reserved.
  */
 
 #ifndef	_SYS_FS_ZFS_VFSOPS_H
 #define	_SYS_FS_ZFS_VFSOPS_H
 
 #include <sys/dataset_kstats.h>
 #include <sys/isa_defs.h>
 #include <sys/types32.h>
 #include <sys/list.h>
 #include <sys/vfs.h>
 #include <sys/zil.h>
 #include <sys/sa.h>
 #include <sys/rrwlock.h>
 #include <sys/dsl_dataset.h>
 #include <sys/zfs_ioctl.h>
 #include <sys/objlist.h>
 
 #ifdef	__cplusplus
 extern "C" {
 #endif
 
 typedef struct zfsvfs zfsvfs_t;
 struct znode;
 
 /*
  * This structure emulates the vfs_t from other platforms.  It's purpose
  * is to facilitate the handling of mount options and minimize structural
  * differences between the platforms.
  */
 typedef struct vfs {
 	struct zfsvfs	*vfs_data;
 	char		*vfs_mntpoint;	/* Primary mount point */
 	uint64_t	vfs_xattr;
 	boolean_t	vfs_readonly;
 	boolean_t	vfs_do_readonly;
 	boolean_t	vfs_setuid;
 	boolean_t	vfs_do_setuid;
 	boolean_t	vfs_exec;
 	boolean_t	vfs_do_exec;
 	boolean_t	vfs_devices;
 	boolean_t	vfs_do_devices;
 	boolean_t	vfs_do_xattr;
 	boolean_t	vfs_atime;
 	boolean_t	vfs_do_atime;
 	boolean_t	vfs_relatime;
 	boolean_t	vfs_do_relatime;
 	boolean_t	vfs_nbmand;
 	boolean_t	vfs_do_nbmand;
+	kmutex_t	vfs_mntpt_lock;
 } vfs_t;
 
 typedef struct zfs_mnt {
 	const char	*mnt_osname;	/* Objset name */
 	char		*mnt_data;	/* Raw mount options */
 } zfs_mnt_t;
 
 struct zfsvfs {
 	vfs_t		*z_vfs;		/* generic fs struct */
 	struct super_block *z_sb;	/* generic super_block */
 	struct zfsvfs	*z_parent;	/* parent fs */
 	objset_t	*z_os;		/* objset reference */
 	uint64_t	z_flags;	/* super_block flags */
 	uint64_t	z_root;		/* id of root znode */
 	uint64_t	z_unlinkedobj;	/* id of unlinked zapobj */
 	uint64_t	z_max_blksz;	/* maximum block size for files */
 	uint64_t	z_fuid_obj;	/* fuid table object number */
 	uint64_t	z_fuid_size;	/* fuid table size */
 	avl_tree_t	z_fuid_idx;	/* fuid tree keyed by index */
 	avl_tree_t	z_fuid_domain;	/* fuid tree keyed by domain */
 	krwlock_t	z_fuid_lock;	/* fuid lock */
 	boolean_t	z_fuid_loaded;	/* fuid tables are loaded */
 	boolean_t	z_fuid_dirty;   /* need to sync fuid table ? */
 	struct zfs_fuid_info	*z_fuid_replay; /* fuid info for replay */
 	zilog_t		*z_log;		/* intent log pointer */
 	uint_t		z_acl_mode;	/* acl chmod/mode behavior */
 	uint_t		z_acl_inherit;	/* acl inheritance behavior */
 	uint_t		z_acl_type;	/* type of ACL usable on this FS */
 	zfs_case_t	z_case;		/* case-sense */
 	boolean_t	z_utf8;		/* utf8-only */
 	int		z_norm;		/* normalization flags */
 	boolean_t	z_relatime;	/* enable relatime mount option */
 	boolean_t	z_unmounted;	/* unmounted */
 	rrmlock_t	z_teardown_lock;
 	krwlock_t	z_teardown_inactive_lock;
 	list_t		z_all_znodes;	/* all znodes in the fs */
 	unsigned long	z_rollback_time; /* last online rollback time */
 	unsigned long	z_snap_defer_time; /* last snapshot unmount deferral */
 	kmutex_t	z_znodes_lock;	/* lock for z_all_znodes */
 	arc_prune_t	*z_arc_prune;	/* called by ARC to prune caches */
 	struct inode	*z_ctldir;	/* .zfs directory inode */
 	uint_t		z_show_ctldir;	/* how to expose .zfs in the root dir */
 	boolean_t	z_issnap;	/* true if this is a snapshot */
 	boolean_t	z_use_fuids;	/* version allows fuids */
 	boolean_t	z_replay;	/* set during ZIL replay */
 	boolean_t	z_use_sa;	/* version allow system attributes */
 	boolean_t	z_xattr_sa;	/* allow xattrs to be stores as SA */
 	boolean_t	z_draining;	/* is true when drain is active */
 	boolean_t	z_drain_cancel; /* signal the unlinked drain to stop */
 	boolean_t	z_longname;	/* Dataset supports long names */
 	uint64_t	z_version;	/* ZPL version */
 	uint64_t	z_shares_dir;	/* hidden shares dir */
 	dataset_kstats_t	z_kstat;	/* fs kstats */
 	kmutex_t	z_lock;
 	uint64_t	z_userquota_obj;
 	uint64_t	z_groupquota_obj;
 	uint64_t	z_userobjquota_obj;
 	uint64_t	z_groupobjquota_obj;
 	uint64_t	z_projectquota_obj;
 	uint64_t	z_projectobjquota_obj;
 	uint64_t	z_replay_eof;	/* New end of file - replay only */
 	sa_attr_type_t	*z_attr_table;	/* SA attr mapping->id */
 	uint64_t	z_hold_size;	/* znode hold array size */
 	avl_tree_t	*z_hold_trees;	/* znode hold trees */
 	kmutex_t	*z_hold_locks;	/* znode hold locks */
 	taskqid_t	z_drain_task;	/* task id for the unlink drain task */
 };
 
 #define	ZFS_TEARDOWN_INIT(zfsvfs)		\
 	rrm_init(&(zfsvfs)->z_teardown_lock, B_FALSE)
 
 #define	ZFS_TEARDOWN_DESTROY(zfsvfs)		\
 	rrm_destroy(&(zfsvfs)->z_teardown_lock)
 
 #define	ZFS_TEARDOWN_ENTER_READ(zfsvfs, tag)	\
 	rrm_enter_read(&(zfsvfs)->z_teardown_lock, tag);
 
 #define	ZFS_TEARDOWN_EXIT_READ(zfsvfs, tag)	\
 	rrm_exit(&(zfsvfs)->z_teardown_lock, tag)
 
 #define	ZFS_TEARDOWN_ENTER_WRITE(zfsvfs, tag)	\
 	rrm_enter(&(zfsvfs)->z_teardown_lock, RW_WRITER, tag)
 
 #define	ZFS_TEARDOWN_EXIT_WRITE(zfsvfs)		\
 	rrm_exit(&(zfsvfs)->z_teardown_lock, tag)
 
 #define	ZFS_TEARDOWN_EXIT(zfsvfs, tag)		\
 	rrm_exit(&(zfsvfs)->z_teardown_lock, tag)
 
 #define	ZFS_TEARDOWN_READ_HELD(zfsvfs)		\
 	RRM_READ_HELD(&(zfsvfs)->z_teardown_lock)
 
 #define	ZFS_TEARDOWN_WRITE_HELD(zfsvfs)		\
 	RRM_WRITE_HELD(&(zfsvfs)->z_teardown_lock)
 
 #define	ZFS_TEARDOWN_HELD(zfsvfs)		\
 	RRM_LOCK_HELD(&(zfsvfs)->z_teardown_lock)
 
 #define	ZSB_XATTR	0x0001		/* Enable user xattrs */
 
 /*
  * Allow a maximum number of links.  While ZFS does not internally limit
  * this the inode->i_nlink member is defined as an unsigned int.  To be
  * safe we use 2^31-1 as the limit.
  */
 #define	ZFS_LINK_MAX		((1U << 31) - 1U)
 
 /*
  * Normal filesystems (those not under .zfs/snapshot) have a total
  * file ID size limited to 12 bytes (including the length field) due to
  * NFSv2 protocol's limitation of 32 bytes for a filehandle.  For historical
  * reasons, this same limit is being imposed by the Solaris NFSv3 implementation
  * (although the NFSv3 protocol actually permits a maximum of 64 bytes).  It
  * is not possible to expand beyond 12 bytes without abandoning support
  * of NFSv2.
  *
  * For normal filesystems, we partition up the available space as follows:
  *	2 bytes		fid length (required)
  *	6 bytes		object number (48 bits)
  *	4 bytes		generation number (32 bits)
  *
  * We reserve only 48 bits for the object number, as this is the limit
  * currently defined and imposed by the DMU.
  */
 typedef struct zfid_short {
 	uint16_t	zf_len;
 	uint8_t		zf_object[6];		/* obj[i] = obj >> (8 * i) */
 	uint8_t		zf_gen[4];		/* gen[i] = gen >> (8 * i) */
 } zfid_short_t;
 
 /*
  * Filesystems under .zfs/snapshot have a total file ID size of 22 bytes
  * (including the length field).  This makes files under .zfs/snapshot
  * accessible by NFSv3 and NFSv4, but not NFSv2.
  *
  * For files under .zfs/snapshot, we partition up the available space
  * as follows:
  *	2 bytes		fid length (required)
  *	6 bytes		object number (48 bits)
  *	4 bytes		generation number (32 bits)
  *	6 bytes		objset id (48 bits)
  *	4 bytes		currently just zero (32 bits)
  *
  * We reserve only 48 bits for the object number and objset id, as these are
  * the limits currently defined and imposed by the DMU.
  */
 typedef struct zfid_long {
 	zfid_short_t	z_fid;
 	uint8_t		zf_setid[6];		/* obj[i] = obj >> (8 * i) */
 	uint8_t		zf_setgen[4];		/* gen[i] = gen >> (8 * i) */
 } zfid_long_t;
 
 #define	SHORT_FID_LEN	(sizeof (zfid_short_t) - sizeof (uint16_t))
 #define	LONG_FID_LEN	(sizeof (zfid_long_t) - sizeof (uint16_t))
 
 extern void zfs_init(void);
 extern void zfs_fini(void);
 
 extern int zfs_suspend_fs(zfsvfs_t *zfsvfs);
 extern int zfs_resume_fs(zfsvfs_t *zfsvfs, struct dsl_dataset *ds);
 extern int zfs_end_fs(zfsvfs_t *zfsvfs, struct dsl_dataset *ds);
 extern void zfs_exit_fs(zfsvfs_t *zfsvfs);
 extern int zfs_set_version(zfsvfs_t *zfsvfs, uint64_t newvers);
 extern int zfsvfs_create(const char *name, boolean_t readony, zfsvfs_t **zfvp);
 extern int zfsvfs_create_impl(zfsvfs_t **zfvp, zfsvfs_t *zfsvfs, objset_t *os);
 extern void zfsvfs_free(zfsvfs_t *zfsvfs);
 extern int zfs_check_global_label(const char *dsname, const char *hexsl);
 
 extern boolean_t zfs_is_readonly(zfsvfs_t *zfsvfs);
 extern int zfs_domount(struct super_block *sb, zfs_mnt_t *zm, int silent);
 extern void zfs_preumount(struct super_block *sb);
 extern int zfs_umount(struct super_block *sb);
 extern int zfs_remount(struct super_block *sb, int *flags, zfs_mnt_t *zm);
 extern int zfs_statvfs(struct inode *ip, struct kstatfs *statp);
 extern int zfs_vget(struct super_block *sb, struct inode **ipp, fid_t *fidp);
 extern int zfs_prune(struct super_block *sb, unsigned long nr_to_scan,
     int *objects);
 extern int zfs_get_temporary_prop(dsl_dataset_t *ds, zfs_prop_t zfs_prop,
     uint64_t *val, char *setpoint);
 
 #ifdef	__cplusplus
 }
 #endif
 
 #endif	/* _SYS_FS_ZFS_VFSOPS_H */
diff --git a/sys/contrib/openzfs/include/sys/fm/fs/zfs.h b/sys/contrib/openzfs/include/sys/fm/fs/zfs.h
index 55b150c044ee..43d6e3f96ea3 100644
--- a/sys/contrib/openzfs/include/sys/fm/fs/zfs.h
+++ b/sys/contrib/openzfs/include/sys/fm/fs/zfs.h
@@ -1,139 +1,140 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 /*
  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
  */
 
 /*
  *  Copyright (c) 2020 by Delphix. All rights reserved.
  */
 
 #ifndef	_SYS_FM_FS_ZFS_H
 #define	_SYS_FM_FS_ZFS_H
 
 #ifdef	__cplusplus
 extern "C" {
 #endif
 
 #define	ZFS_ERROR_CLASS				"fs.zfs"
 
 #define	FM_EREPORT_ZFS_CHECKSUM			"checksum"
 #define	FM_EREPORT_ZFS_AUTHENTICATION		"authentication"
 #define	FM_EREPORT_ZFS_IO			"io"
 #define	FM_EREPORT_ZFS_DATA			"data"
 #define	FM_EREPORT_ZFS_DELAY			"delay"
 #define	FM_EREPORT_ZFS_DEADMAN			"deadman"
-#define	FM_EREPORT_ZFS_DIO_VERIFY		"dio_verify"
+#define	FM_EREPORT_ZFS_DIO_VERIFY_WR		"dio_verify_wr"
+#define	FM_EREPORT_ZFS_DIO_VERIFY_RD		"dio_verify_rd"
 #define	FM_EREPORT_ZFS_POOL			"zpool"
 #define	FM_EREPORT_ZFS_DEVICE_UNKNOWN		"vdev.unknown"
 #define	FM_EREPORT_ZFS_DEVICE_OPEN_FAILED	"vdev.open_failed"
 #define	FM_EREPORT_ZFS_DEVICE_CORRUPT_DATA	"vdev.corrupt_data"
 #define	FM_EREPORT_ZFS_DEVICE_NO_REPLICAS	"vdev.no_replicas"
 #define	FM_EREPORT_ZFS_DEVICE_BAD_GUID_SUM	"vdev.bad_guid_sum"
 #define	FM_EREPORT_ZFS_DEVICE_TOO_SMALL		"vdev.too_small"
 #define	FM_EREPORT_ZFS_DEVICE_BAD_LABEL		"vdev.bad_label"
 #define	FM_EREPORT_ZFS_DEVICE_BAD_ASHIFT	"vdev.bad_ashift"
 #define	FM_EREPORT_ZFS_IO_FAILURE		"io_failure"
 #define	FM_EREPORT_ZFS_PROBE_FAILURE		"probe_failure"
 #define	FM_EREPORT_ZFS_LOG_REPLAY		"log_replay"
 #define	FM_EREPORT_ZFS_CONFIG_CACHE_WRITE	"config_cache_write"
 
 #define	FM_EREPORT_PAYLOAD_ZFS_POOL		"pool"
 #define	FM_EREPORT_PAYLOAD_ZFS_POOL_FAILMODE	"pool_failmode"
 #define	FM_EREPORT_PAYLOAD_ZFS_POOL_GUID	"pool_guid"
 #define	FM_EREPORT_PAYLOAD_ZFS_POOL_CONTEXT	"pool_context"
 #define	FM_EREPORT_PAYLOAD_ZFS_POOL_STATE	"pool_state"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_GUID	"vdev_guid"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_TYPE	"vdev_type"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_PATH	"vdev_path"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_PHYSPATH	"vdev_physpath"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_ENC_SYSFS_PATH	"vdev_enc_sysfs_path"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_DEVID	"vdev_devid"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_FRU		"vdev_fru"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_STATE	"vdev_state"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_LASTSTATE	"vdev_laststate"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_ASHIFT	"vdev_ashift"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_COMP_TS	"vdev_complete_ts"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_DELTA_TS	"vdev_delta_ts"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_SPARE_PATHS	"vdev_spare_paths"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_SPARE_GUIDS	"vdev_spare_guids"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_READ_ERRORS	"vdev_read_errors"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_WRITE_ERRORS "vdev_write_errors"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_CKSUM_ERRORS "vdev_cksum_errors"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_CKSUM_N	"vdev_cksum_n"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_CKSUM_T	"vdev_cksum_t"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_IO_N	"vdev_io_n"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_IO_T	"vdev_io_t"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_SLOW_IO_N	"vdev_slow_io_n"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_SLOW_IO_T	"vdev_slow_io_t"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_DIO_VERIFY_ERRORS "dio_verify_errors"
 #define	FM_EREPORT_PAYLOAD_ZFS_VDEV_DELAYS	"vdev_delays"
 #define	FM_EREPORT_PAYLOAD_ZFS_PARENT_GUID	"parent_guid"
 #define	FM_EREPORT_PAYLOAD_ZFS_PARENT_TYPE	"parent_type"
 #define	FM_EREPORT_PAYLOAD_ZFS_PARENT_PATH	"parent_path"
 #define	FM_EREPORT_PAYLOAD_ZFS_PARENT_DEVID	"parent_devid"
 #define	FM_EREPORT_PAYLOAD_ZFS_ZIO_OBJSET	"zio_objset"
 #define	FM_EREPORT_PAYLOAD_ZFS_ZIO_OBJECT	"zio_object"
 #define	FM_EREPORT_PAYLOAD_ZFS_ZIO_LEVEL	"zio_level"
 #define	FM_EREPORT_PAYLOAD_ZFS_ZIO_BLKID	"zio_blkid"
 #define	FM_EREPORT_PAYLOAD_ZFS_ZIO_ERR		"zio_err"
 #define	FM_EREPORT_PAYLOAD_ZFS_ZIO_OFFSET	"zio_offset"
 #define	FM_EREPORT_PAYLOAD_ZFS_ZIO_SIZE		"zio_size"
 #define	FM_EREPORT_PAYLOAD_ZFS_ZIO_FLAGS	"zio_flags"
 #define	FM_EREPORT_PAYLOAD_ZFS_ZIO_STAGE	"zio_stage"
 #define	FM_EREPORT_PAYLOAD_ZFS_ZIO_PRIORITY	"zio_priority"
 #define	FM_EREPORT_PAYLOAD_ZFS_ZIO_PIPELINE	"zio_pipeline"
 #define	FM_EREPORT_PAYLOAD_ZFS_ZIO_DELAY	"zio_delay"
 #define	FM_EREPORT_PAYLOAD_ZFS_ZIO_TIMESTAMP	"zio_timestamp"
 #define	FM_EREPORT_PAYLOAD_ZFS_ZIO_DELTA	"zio_delta"
 #define	FM_EREPORT_PAYLOAD_ZFS_PREV_STATE	"prev_state"
 #define	FM_EREPORT_PAYLOAD_ZFS_CKSUM_ALGO	"cksum_algorithm"
 #define	FM_EREPORT_PAYLOAD_ZFS_CKSUM_BYTESWAP	"cksum_byteswap"
 #define	FM_EREPORT_PAYLOAD_ZFS_BAD_OFFSET_RANGES "bad_ranges"
 #define	FM_EREPORT_PAYLOAD_ZFS_BAD_RANGE_MIN_GAP "bad_ranges_min_gap"
 #define	FM_EREPORT_PAYLOAD_ZFS_BAD_RANGE_SETS	"bad_range_sets"
 #define	FM_EREPORT_PAYLOAD_ZFS_BAD_RANGE_CLEARS	"bad_range_clears"
 #define	FM_EREPORT_PAYLOAD_ZFS_BAD_SET_BITS	"bad_set_bits"
 #define	FM_EREPORT_PAYLOAD_ZFS_BAD_CLEARED_BITS	"bad_cleared_bits"
 #define	FM_EREPORT_PAYLOAD_ZFS_SNAPSHOT_NAME	"snapshot_name"
 #define	FM_EREPORT_PAYLOAD_ZFS_DEVICE_NAME	"device_name"
 #define	FM_EREPORT_PAYLOAD_ZFS_RAW_DEVICE_NAME	"raw_name"
 #define	FM_EREPORT_PAYLOAD_ZFS_VOLUME	"volume"
 
 #define	FM_EREPORT_FAILMODE_WAIT		"wait"
 #define	FM_EREPORT_FAILMODE_CONTINUE		"continue"
 #define	FM_EREPORT_FAILMODE_PANIC		"panic"
 
 #define	FM_RESOURCE_REMOVED			"removed"
 #define	FM_RESOURCE_AUTOREPLACE			"autoreplace"
 #define	FM_RESOURCE_STATECHANGE			"statechange"
 
 #define	FM_RESOURCE_ZFS_SNAPSHOT_MOUNT		"snapshot_mount"
 #define	FM_RESOURCE_ZFS_SNAPSHOT_UNMOUNT		"snapshot_unmount"
 #define	FM_RESOURCE_ZVOL_CREATE_SYMLINK		"zvol_create"
 #define	FM_RESOURCE_ZVOL_REMOVE_SYMLINK		"zvol_remove"
 
 #ifdef	__cplusplus
 }
 #endif
 
 #endif	/* _SYS_FM_FS_ZFS_H */
diff --git a/sys/contrib/openzfs/include/sys/vdev_raidz.h b/sys/contrib/openzfs/include/sys/vdev_raidz.h
index a34bc00ca4df..64f484e9aa13 100644
--- a/sys/contrib/openzfs/include/sys/vdev_raidz.h
+++ b/sys/contrib/openzfs/include/sys/vdev_raidz.h
@@ -1,176 +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 https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 /*
  * Copyright (C) 2016 Gvozden Neskovic <neskovic@compeng.uni-frankfurt.de>.
  */
 
 #ifndef _SYS_VDEV_RAIDZ_H
 #define	_SYS_VDEV_RAIDZ_H
 
 #include <sys/types.h>
 #include <sys/zfs_rlock.h>
 
 #ifdef	__cplusplus
 extern "C" {
 #endif
 
 struct zio;
 struct raidz_col;
 struct raidz_row;
 struct raidz_map;
 struct vdev_raidz;
 struct uberblock;
 #if !defined(_KERNEL)
 struct kernel_param {};
 #endif
 
 /*
  * vdev_raidz interface
  */
 struct raidz_map *vdev_raidz_map_alloc(struct zio *, uint64_t, uint64_t,
     uint64_t);
 struct raidz_map *vdev_raidz_map_alloc_expanded(struct zio *,
     uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, boolean_t);
 void vdev_raidz_map_free(struct raidz_map *);
 void vdev_raidz_free(struct vdev_raidz *);
 void vdev_raidz_generate_parity_row(struct raidz_map *, struct raidz_row *);
 void vdev_raidz_generate_parity(struct raidz_map *);
 void vdev_raidz_reconstruct(struct raidz_map *, const int *, int);
 void vdev_raidz_child_done(zio_t *);
 void vdev_raidz_io_done(zio_t *);
 void vdev_raidz_checksum_error(zio_t *, struct raidz_col *, abd_t *);
-struct raidz_row *vdev_raidz_row_alloc(int);
+struct raidz_row *vdev_raidz_row_alloc(int, zio_t *);
 void vdev_raidz_reflow_copy_scratch(spa_t *);
 void raidz_dtl_reassessed(vdev_t *);
 
 extern const zio_vsd_ops_t vdev_raidz_vsd_ops;
 
 /*
  * vdev_raidz_math interface
  */
 void vdev_raidz_math_init(void);
 void vdev_raidz_math_fini(void);
 const struct raidz_impl_ops *vdev_raidz_math_get_ops(void);
 int vdev_raidz_math_generate(struct raidz_map *, struct raidz_row *);
 int vdev_raidz_math_reconstruct(struct raidz_map *, struct raidz_row *,
     const int *, const int *, const int);
 int vdev_raidz_impl_set(const char *);
 
 typedef struct vdev_raidz_expand {
 	uint64_t vre_vdev_id;
 
 	kmutex_t vre_lock;
 	kcondvar_t vre_cv;
 
 	/*
 	 * How much i/o is outstanding (issued and not completed).
 	 */
 	uint64_t vre_outstanding_bytes;
 
 	/*
 	 * Next offset to issue i/o for.
 	 */
 	uint64_t vre_offset;
 
 	/*
 	 * Lowest offset of a failed expansion i/o.  The expansion will retry
 	 * from here.  Once the expansion thread notices the failure and exits,
 	 * vre_failed_offset is reset back to UINT64_MAX, and
 	 * vre_waiting_for_resilver will be set.
 	 */
 	uint64_t vre_failed_offset;
 	boolean_t vre_waiting_for_resilver;
 
 	/*
 	 * Offset that is completing each txg
 	 */
 	uint64_t vre_offset_pertxg[TXG_SIZE];
 
 	/*
 	 * Bytes copied in each txg.
 	 */
 	uint64_t vre_bytes_copied_pertxg[TXG_SIZE];
 
 	/*
 	 * The rangelock prevents normal read/write zio's from happening while
 	 * there are expansion (reflow) i/os in progress to the same offsets.
 	 */
 	zfs_rangelock_t vre_rangelock;
 
 	/*
 	 * These fields are stored on-disk in the vdev_top_zap:
 	 */
 	dsl_scan_state_t vre_state;
 	uint64_t vre_start_time;
 	uint64_t vre_end_time;
 	uint64_t vre_bytes_copied;
 } vdev_raidz_expand_t;
 
 typedef struct vdev_raidz {
 	/*
 	 * Number of child vdevs when this raidz vdev was created (i.e. before
 	 * any raidz expansions).
 	 */
 	int vd_original_width;
 
 	/*
 	 * The current number of child vdevs, which may be more than the
 	 * original width if an expansion is in progress or has completed.
 	 */
 	int vd_physical_width;
 
 	int vd_nparity;
 
 	/*
 	 * Tree of reflow_node_t's.  The lock protects the avl tree only.
 	 * The reflow_node_t's describe completed expansions, and are used
 	 * to determine the logical width given a block's birth time.
 	 */
 	avl_tree_t vd_expand_txgs;
 	kmutex_t vd_expand_lock;
 
 	/*
 	 * If this vdev is being expanded, spa_raidz_expand is set to this
 	 */
 	vdev_raidz_expand_t vn_vre;
 } vdev_raidz_t;
 
 extern int vdev_raidz_attach_check(vdev_t *);
 extern void vdev_raidz_attach_sync(void *, dmu_tx_t *);
 extern void spa_start_raidz_expansion_thread(spa_t *);
 extern int spa_raidz_expand_get_stats(spa_t *, pool_raidz_expand_stat_t *);
 extern int vdev_raidz_load(vdev_t *);
 
 /* RAIDZ scratch area pause points (for testing) */
 #define	RAIDZ_EXPAND_PAUSE_NONE	0
 #define	RAIDZ_EXPAND_PAUSE_PRE_SCRATCH_1 1
 #define	RAIDZ_EXPAND_PAUSE_PRE_SCRATCH_2 2
 #define	RAIDZ_EXPAND_PAUSE_PRE_SCRATCH_3 3
 #define	RAIDZ_EXPAND_PAUSE_SCRATCH_VALID 4
 #define	RAIDZ_EXPAND_PAUSE_SCRATCH_REFLOWED 5
 #define	RAIDZ_EXPAND_PAUSE_SCRATCH_POST_REFLOW_1 6
 #define	RAIDZ_EXPAND_PAUSE_SCRATCH_POST_REFLOW_2 7
 
 #ifdef	__cplusplus
 }
 #endif
 
 #endif /* _SYS_VDEV_RAIDZ_H */
diff --git a/sys/contrib/openzfs/include/sys/zio.h b/sys/contrib/openzfs/include/sys/zio.h
index f9409433e031..46f5d68aed4a 100644
--- a/sys/contrib/openzfs/include/sys/zio.h
+++ b/sys/contrib/openzfs/include/sys/zio.h
@@ -1,734 +1,735 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 
 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
  * Copyright (c) 2012, 2024 by Delphix. All rights reserved.
  * Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
  * Copyright (c) 2013, Joyent, Inc. All rights reserved.
  * Copyright 2016 Toomas Soome <tsoome@me.com>
  * Copyright (c) 2019, Allan Jude
  * Copyright (c) 2019, 2023, 2024, Klara Inc.
  * Copyright (c) 2019-2020, Michael Niewöhner
  * Copyright (c) 2024 by George Melikov. All rights reserved.
  */
 
 #ifndef _ZIO_H
 #define	_ZIO_H
 
 #include <sys/zio_priority.h>
 #include <sys/zfs_context.h>
 #include <sys/spa.h>
 #include <sys/txg.h>
 #include <sys/avl.h>
 #include <sys/fs/zfs.h>
 #include <sys/zio_impl.h>
 
 #ifdef	__cplusplus
 extern "C" {
 #endif
 
 /*
  * Embedded checksum
  */
 #define	ZEC_MAGIC	0x210da7ab10c7a11ULL
 
 typedef struct zio_eck {
 	uint64_t	zec_magic;	/* for validation, endianness	*/
 	zio_cksum_t	zec_cksum;	/* 256-bit checksum		*/
 } zio_eck_t;
 
 /*
  * Gang block headers are self-checksumming and contain an array
  * of block pointers.
  */
 #define	SPA_GANGBLOCKSIZE	SPA_MINBLOCKSIZE
 #define	SPA_GBH_NBLKPTRS	((SPA_GANGBLOCKSIZE - \
 	sizeof (zio_eck_t)) / sizeof (blkptr_t))
 #define	SPA_GBH_FILLER		((SPA_GANGBLOCKSIZE - \
 	sizeof (zio_eck_t) - \
 	(SPA_GBH_NBLKPTRS * sizeof (blkptr_t))) /\
 	sizeof (uint64_t))
 
 typedef struct zio_gbh {
 	blkptr_t		zg_blkptr[SPA_GBH_NBLKPTRS];
 	uint64_t		zg_filler[SPA_GBH_FILLER];
 	zio_eck_t		zg_tail;
 } zio_gbh_phys_t;
 
 enum zio_checksum {
 	ZIO_CHECKSUM_INHERIT = 0,
 	ZIO_CHECKSUM_ON,
 	ZIO_CHECKSUM_OFF,
 	ZIO_CHECKSUM_LABEL,
 	ZIO_CHECKSUM_GANG_HEADER,
 	ZIO_CHECKSUM_ZILOG,
 	ZIO_CHECKSUM_FLETCHER_2,
 	ZIO_CHECKSUM_FLETCHER_4,
 	ZIO_CHECKSUM_SHA256,
 	ZIO_CHECKSUM_ZILOG2,
 	ZIO_CHECKSUM_NOPARITY,
 	ZIO_CHECKSUM_SHA512,
 	ZIO_CHECKSUM_SKEIN,
 	ZIO_CHECKSUM_EDONR,
 	ZIO_CHECKSUM_BLAKE3,
 	ZIO_CHECKSUM_FUNCTIONS
 };
 
 /*
  * The number of "legacy" compression functions which can be set on individual
  * objects.
  */
 #define	ZIO_CHECKSUM_LEGACY_FUNCTIONS ZIO_CHECKSUM_ZILOG2
 
 #define	ZIO_CHECKSUM_ON_VALUE	ZIO_CHECKSUM_FLETCHER_4
 #define	ZIO_CHECKSUM_DEFAULT	ZIO_CHECKSUM_ON
 
 #define	ZIO_CHECKSUM_MASK	0xffULL
 #define	ZIO_CHECKSUM_VERIFY	(1U << 8)
 
 #define	ZIO_DEDUPCHECKSUM	ZIO_CHECKSUM_SHA256
 
 /* macros defining encryption lengths */
 #define	ZIO_OBJSET_MAC_LEN		32
 #define	ZIO_DATA_IV_LEN			12
 #define	ZIO_DATA_SALT_LEN		8
 #define	ZIO_DATA_MAC_LEN		16
 
 /*
  * The number of "legacy" compression functions which can be set on individual
  * objects.
  */
 #define	ZIO_COMPRESS_LEGACY_FUNCTIONS ZIO_COMPRESS_LZ4
 
 /*
  * The meaning of "compress = on" selected by the compression features enabled
  * on a given pool.
  */
 #define	ZIO_COMPRESS_LEGACY_ON_VALUE	ZIO_COMPRESS_LZJB
 #define	ZIO_COMPRESS_LZ4_ON_VALUE	ZIO_COMPRESS_LZ4
 
 #define	ZIO_COMPRESS_DEFAULT		ZIO_COMPRESS_ON
 
 #define	BOOTFS_COMPRESS_VALID(compress)			\
 	((compress) == ZIO_COMPRESS_LZJB ||		\
 	(compress) == ZIO_COMPRESS_LZ4 ||		\
 	(compress) == ZIO_COMPRESS_GZIP_1 ||		\
 	(compress) == ZIO_COMPRESS_GZIP_2 ||		\
 	(compress) == ZIO_COMPRESS_GZIP_3 ||		\
 	(compress) == ZIO_COMPRESS_GZIP_4 ||		\
 	(compress) == ZIO_COMPRESS_GZIP_5 ||		\
 	(compress) == ZIO_COMPRESS_GZIP_6 ||		\
 	(compress) == ZIO_COMPRESS_GZIP_7 ||		\
 	(compress) == ZIO_COMPRESS_GZIP_8 ||		\
 	(compress) == ZIO_COMPRESS_GZIP_9 ||		\
 	(compress) == ZIO_COMPRESS_ZLE ||		\
 	(compress) == ZIO_COMPRESS_ZSTD ||		\
 	(compress) == ZIO_COMPRESS_ON ||		\
 	(compress) == ZIO_COMPRESS_OFF)
 
 
 #define	ZIO_COMPRESS_ALGO(x)	(x & SPA_COMPRESSMASK)
 #define	ZIO_COMPRESS_LEVEL(x)	((x & ~SPA_COMPRESSMASK) >> SPA_COMPRESSBITS)
 #define	ZIO_COMPRESS_RAW(type, level)	(type | ((level) << SPA_COMPRESSBITS))
 
 #define	ZIO_COMPLEVEL_ZSTD(level)	\
 	ZIO_COMPRESS_RAW(ZIO_COMPRESS_ZSTD, level)
 
 #define	ZIO_FAILURE_MODE_WAIT		0
 #define	ZIO_FAILURE_MODE_CONTINUE	1
 #define	ZIO_FAILURE_MODE_PANIC		2
 
 typedef enum zio_suspend_reason {
 	ZIO_SUSPEND_NONE = 0,
 	ZIO_SUSPEND_IOERR,
 	ZIO_SUSPEND_MMP,
 } zio_suspend_reason_t;
 
 /*
  * This was originally an enum type. However, those are 32-bit and there is no
  * way to make a 64-bit enum type. Since we ran out of bits for flags, we were
  * forced to upgrade it to a uint64_t.
  *
  * NOTE: PLEASE UPDATE THE BITFIELD STRINGS IN zfs_valstr.c IF YOU ADD ANOTHER
  * FLAG.
  */
 typedef uint64_t zio_flag_t;
 	/*
 	 * Flags inherited by gang, ddt, and vdev children,
 	 * and that must be equal for two zios to aggregate
 	 */
 #define	ZIO_FLAG_DONT_AGGREGATE	(1ULL << 0)
 #define	ZIO_FLAG_IO_REPAIR	(1ULL << 1)
 #define	ZIO_FLAG_SELF_HEAL	(1ULL << 2)
 #define	ZIO_FLAG_RESILVER	(1ULL << 3)
 #define	ZIO_FLAG_SCRUB		(1ULL << 4)
 #define	ZIO_FLAG_SCAN_THREAD	(1ULL << 5)
 #define	ZIO_FLAG_PHYSICAL	(1ULL << 6)
 
 #define	ZIO_FLAG_AGG_INHERIT	(ZIO_FLAG_CANFAIL - 1)
 
 	/*
 	 * Flags inherited by ddt, gang, and vdev children.
 	 */
 #define	ZIO_FLAG_CANFAIL	(1ULL << 7)	/* must be first for INHERIT */
 #define	ZIO_FLAG_SPECULATIVE	(1ULL << 8)
 #define	ZIO_FLAG_CONFIG_WRITER	(1ULL << 9)
 #define	ZIO_FLAG_DONT_RETRY	(1ULL << 10)
 #define	ZIO_FLAG_NODATA		(1ULL << 12)
 #define	ZIO_FLAG_INDUCE_DAMAGE	(1ULL << 13)
 #define	ZIO_FLAG_IO_ALLOCATING	(1ULL << 14)
 
 #define	ZIO_FLAG_DDT_INHERIT	(ZIO_FLAG_IO_RETRY - 1)
 #define	ZIO_FLAG_GANG_INHERIT	(ZIO_FLAG_IO_RETRY - 1)
 
 	/*
 	 * Flags inherited by vdev children.
 	 */
 #define	ZIO_FLAG_IO_RETRY	(1ULL << 15)	/* must be first for INHERIT */
 #define	ZIO_FLAG_PROBE		(1ULL << 16)
 #define	ZIO_FLAG_TRYHARD	(1ULL << 17)
 #define	ZIO_FLAG_OPTIONAL	(1ULL << 18)
-
+#define	ZIO_FLAG_DIO_READ	(1ULL << 19)
 #define	ZIO_FLAG_VDEV_INHERIT	(ZIO_FLAG_DONT_QUEUE - 1)
 
 	/*
 	 * Flags not inherited by any children.
 	 */
-#define	ZIO_FLAG_DONT_QUEUE	(1ULL << 19)	/* must be first for INHERIT */
-#define	ZIO_FLAG_DONT_PROPAGATE	(1ULL << 20)
-#define	ZIO_FLAG_IO_BYPASS	(1ULL << 21)
-#define	ZIO_FLAG_IO_REWRITE	(1ULL << 22)
-#define	ZIO_FLAG_RAW_COMPRESS	(1ULL << 23)
-#define	ZIO_FLAG_RAW_ENCRYPT	(1ULL << 24)
-#define	ZIO_FLAG_GANG_CHILD	(1ULL << 25)
-#define	ZIO_FLAG_DDT_CHILD	(1ULL << 26)
-#define	ZIO_FLAG_GODFATHER	(1ULL << 27)
-#define	ZIO_FLAG_NOPWRITE	(1ULL << 28)
-#define	ZIO_FLAG_REEXECUTED	(1ULL << 29)
-#define	ZIO_FLAG_DELEGATED	(1ULL << 30)
-#define	ZIO_FLAG_DIO_CHKSUM_ERR	(1ULL << 31)
+#define	ZIO_FLAG_DONT_QUEUE	(1ULL << 20)	/* must be first for INHERIT */
+#define	ZIO_FLAG_DONT_PROPAGATE	(1ULL << 21)
+#define	ZIO_FLAG_IO_BYPASS	(1ULL << 22)
+#define	ZIO_FLAG_IO_REWRITE	(1ULL << 23)
+#define	ZIO_FLAG_RAW_COMPRESS	(1ULL << 24)
+#define	ZIO_FLAG_RAW_ENCRYPT	(1ULL << 25)
+#define	ZIO_FLAG_GANG_CHILD	(1ULL << 26)
+#define	ZIO_FLAG_DDT_CHILD	(1ULL << 27)
+#define	ZIO_FLAG_GODFATHER	(1ULL << 28)
+#define	ZIO_FLAG_NOPWRITE	(1ULL << 29)
+#define	ZIO_FLAG_REEXECUTED	(1ULL << 30)
+#define	ZIO_FLAG_DELEGATED	(1ULL << 31)
+#define	ZIO_FLAG_DIO_CHKSUM_ERR	(1ULL << 32)
 
 #define	ZIO_ALLOCATOR_NONE	(-1)
 #define	ZIO_HAS_ALLOCATOR(zio)	((zio)->io_allocator != ZIO_ALLOCATOR_NONE)
 
 #define	ZIO_FLAG_MUSTSUCCEED		0
 #define	ZIO_FLAG_RAW	(ZIO_FLAG_RAW_COMPRESS | ZIO_FLAG_RAW_ENCRYPT)
 
 #define	ZIO_DDT_CHILD_FLAGS(zio)				\
 	(((zio)->io_flags & ZIO_FLAG_DDT_INHERIT) |		\
 	ZIO_FLAG_DDT_CHILD | ZIO_FLAG_CANFAIL)
 
 #define	ZIO_GANG_CHILD_FLAGS(zio)				\
 	(((zio)->io_flags & ZIO_FLAG_GANG_INHERIT) |		\
 	ZIO_FLAG_GANG_CHILD | ZIO_FLAG_CANFAIL)
 
 #define	ZIO_VDEV_CHILD_FLAGS(zio)				\
 	(((zio)->io_flags & ZIO_FLAG_VDEV_INHERIT) |		\
 	ZIO_FLAG_DONT_PROPAGATE | ZIO_FLAG_CANFAIL)
 
 #define	ZIO_CHILD_BIT(x)		(1U << (x))
 #define	ZIO_CHILD_BIT_IS_SET(val, x)	((val) & (1U << (x)))
 
 enum zio_child {
 	ZIO_CHILD_VDEV = 0,
 	ZIO_CHILD_GANG,
 	ZIO_CHILD_DDT,
 	ZIO_CHILD_LOGICAL,
 	ZIO_CHILD_TYPES
 };
 
 #define	ZIO_CHILD_VDEV_BIT		ZIO_CHILD_BIT(ZIO_CHILD_VDEV)
 #define	ZIO_CHILD_GANG_BIT		ZIO_CHILD_BIT(ZIO_CHILD_GANG)
 #define	ZIO_CHILD_DDT_BIT		ZIO_CHILD_BIT(ZIO_CHILD_DDT)
 #define	ZIO_CHILD_LOGICAL_BIT		ZIO_CHILD_BIT(ZIO_CHILD_LOGICAL)
 #define	ZIO_CHILD_ALL_BITS					\
 	(ZIO_CHILD_VDEV_BIT | ZIO_CHILD_GANG_BIT |		\
 	ZIO_CHILD_DDT_BIT | ZIO_CHILD_LOGICAL_BIT)
 
 enum zio_wait_type {
 	ZIO_WAIT_READY = 0,
 	ZIO_WAIT_DONE,
 	ZIO_WAIT_TYPES
 };
 
 typedef void zio_done_func_t(zio_t *zio);
 
 extern int zio_exclude_metadata;
 extern int zio_dva_throttle_enabled;
 extern const char *const zio_type_name[ZIO_TYPES];
 
 /*
  * A bookmark is a four-tuple <objset, object, level, blkid> that uniquely
  * identifies any block in the pool.  By convention, the meta-objset (MOS)
  * is objset 0, and the meta-dnode is object 0.  This covers all blocks
  * except root blocks and ZIL blocks, which are defined as follows:
  *
  * Root blocks (objset_phys_t) are object 0, level -1:  <objset, 0, -1, 0>.
  * ZIL blocks are bookmarked <objset, 0, -2, blkid == ZIL sequence number>.
  * dmu_sync()ed ZIL data blocks are bookmarked <objset, object, -2, blkid>.
  * dnode visit bookmarks are <objset, object id of dnode, -3, 0>.
  *
  * Note: this structure is called a bookmark because its original purpose
  * was to remember where to resume a pool-wide traverse.
  *
  * Note: this structure is passed between userland and the kernel, and is
  * stored on disk (by virtue of being incorporated into other on-disk
  * structures, e.g. dsl_scan_phys_t).
  *
  * If the head_errlog feature is enabled a different on-disk format for error
  * logs is used. This introduces the use of an error bookmark, a four-tuple
  * <object, level, blkid, birth> that uniquely identifies any error block
  * in the pool. The birth transaction group is used to track whether the block
  * has been overwritten by newer data or added to a snapshot since its marking
  * as an error.
  */
 struct zbookmark_phys {
 	uint64_t	zb_objset;
 	uint64_t	zb_object;
 	int64_t		zb_level;
 	uint64_t	zb_blkid;
 };
 
 struct zbookmark_err_phys {
 	uint64_t	zb_object;
 	int64_t		zb_level;
 	uint64_t	zb_blkid;
 	uint64_t	zb_birth;
 };
 
 #define	SET_BOOKMARK(zb, objset, object, level, blkid)  \
 {                                                       \
 	(zb)->zb_objset = objset;                       \
 	(zb)->zb_object = object;                       \
 	(zb)->zb_level = level;                         \
 	(zb)->zb_blkid = blkid;                         \
 }
 
 #define	ZB_DESTROYED_OBJSET	(-1ULL)
 
 #define	ZB_ROOT_OBJECT		(0ULL)
 #define	ZB_ROOT_LEVEL		(-1LL)
 #define	ZB_ROOT_BLKID		(0ULL)
 
 #define	ZB_ZIL_OBJECT		(0ULL)
 #define	ZB_ZIL_LEVEL		(-2LL)
 
 #define	ZB_DNODE_LEVEL		(-3LL)
 #define	ZB_DNODE_BLKID		(0ULL)
 
 #define	ZB_IS_ZERO(zb)						\
 	((zb)->zb_objset == 0 && (zb)->zb_object == 0 &&	\
 	(zb)->zb_level == 0 && (zb)->zb_blkid == 0)
 #define	ZB_IS_ROOT(zb)				\
 	((zb)->zb_object == ZB_ROOT_OBJECT &&	\
 	(zb)->zb_level == ZB_ROOT_LEVEL &&	\
 	(zb)->zb_blkid == ZB_ROOT_BLKID)
 
 typedef struct zio_prop {
 	enum zio_checksum	zp_checksum;
 	enum zio_compress	zp_compress;
 	uint8_t			zp_complevel;
 	uint8_t			zp_level;
 	uint8_t			zp_copies;
 	dmu_object_type_t	zp_type;
 	boolean_t		zp_dedup;
 	boolean_t		zp_dedup_verify;
 	boolean_t		zp_nopwrite;
 	boolean_t		zp_brtwrite;
 	boolean_t		zp_encrypt;
 	boolean_t		zp_byteorder;
 	boolean_t		zp_direct_write;
 	uint8_t			zp_salt[ZIO_DATA_SALT_LEN];
 	uint8_t			zp_iv[ZIO_DATA_IV_LEN];
 	uint8_t			zp_mac[ZIO_DATA_MAC_LEN];
 	uint32_t		zp_zpl_smallblk;
 	dmu_object_type_t	zp_storage_type;
 } zio_prop_t;
 
 typedef struct zio_cksum_report zio_cksum_report_t;
 
 typedef void zio_cksum_finish_f(zio_cksum_report_t *rep,
     const abd_t *good_data);
 typedef void zio_cksum_free_f(void *cbdata, size_t size);
 
 struct zio_bad_cksum;				/* defined in zio_checksum.h */
 struct dnode_phys;
 struct abd;
 
 struct zio_cksum_report {
 	struct zio_cksum_report *zcr_next;
 	nvlist_t		*zcr_ereport;
 	nvlist_t		*zcr_detector;
 	void			*zcr_cbdata;
 	size_t			zcr_cbinfo;	/* passed to zcr_free() */
 	uint64_t		zcr_sector;
 	uint64_t		zcr_align;
 	uint64_t		zcr_length;
 	zio_cksum_finish_f	*zcr_finish;
 	zio_cksum_free_f	*zcr_free;
 
 	/* internal use only */
 	struct zio_bad_cksum	*zcr_ckinfo;	/* information from failure */
 };
 
 typedef struct zio_vsd_ops {
 	zio_done_func_t		*vsd_free;
 } zio_vsd_ops_t;
 
 typedef struct zio_gang_node {
 	zio_gbh_phys_t		*gn_gbh;
 	struct zio_gang_node	*gn_child[SPA_GBH_NBLKPTRS];
 } zio_gang_node_t;
 
 typedef zio_t *zio_gang_issue_func_t(zio_t *zio, blkptr_t *bp,
     zio_gang_node_t *gn, struct abd *data, uint64_t offset);
 
 typedef void zio_transform_func_t(zio_t *zio, struct abd *data, uint64_t size);
 
 typedef struct zio_transform {
 	struct abd		*zt_orig_abd;
 	uint64_t		zt_orig_size;
 	uint64_t		zt_bufsize;
 	zio_transform_func_t	*zt_transform;
 	struct zio_transform	*zt_next;
 } zio_transform_t;
 
 typedef zio_t *zio_pipe_stage_t(zio_t *zio);
 
 /*
  * The io_reexecute flags are distinct from io_flags because the child must
  * be able to propagate them to the parent.  The normal io_flags are local
  * to the zio, not protected by any lock, and not modifiable by children;
  * the reexecute flags are protected by io_lock, modifiable by children,
  * and always propagated -- even when ZIO_FLAG_DONT_PROPAGATE is set.
  */
 #define	ZIO_REEXECUTE_NOW	0x01
 #define	ZIO_REEXECUTE_SUSPEND	0x02
 
 /*
  * The io_trim flags are used to specify the type of TRIM to perform.  They
  * only apply to ZIO_TYPE_TRIM zios are distinct from io_flags.
  */
 enum trim_flag {
 	ZIO_TRIM_SECURE		= 1U << 0,
 };
 
 typedef struct zio_alloc_list {
 	list_t  zal_list;
 	uint64_t zal_size;
 } zio_alloc_list_t;
 
 typedef struct zio_link {
 	zio_t		*zl_parent;
 	zio_t		*zl_child;
 	list_node_t	zl_parent_node;
 	list_node_t	zl_child_node;
 } zio_link_t;
 
 enum zio_qstate {
 	ZIO_QS_NONE = 0,
 	ZIO_QS_QUEUED,
 	ZIO_QS_ACTIVE,
 };
 
 struct zio {
 	/* Core information about this I/O */
 	zbookmark_phys_t	io_bookmark;
 	zio_prop_t	io_prop;
 	zio_type_t	io_type;
 	enum zio_child	io_child_type;
 	enum trim_flag	io_trim_flags;
 	zio_priority_t	io_priority;
 	uint8_t		io_reexecute;
 	uint8_t		io_state[ZIO_WAIT_TYPES];
 	uint64_t	io_txg;
 	spa_t		*io_spa;
 	blkptr_t	*io_bp;
 	blkptr_t	*io_bp_override;
 	blkptr_t	io_bp_copy;
 	list_t		io_parent_list;
 	list_t		io_child_list;
 	zio_t		*io_logical;
 	zio_transform_t *io_transform_stack;
 
 	/* Callback info */
 	zio_done_func_t	*io_ready;
 	zio_done_func_t	*io_children_ready;
 	zio_done_func_t	*io_done;
 	void		*io_private;
 	int64_t		io_prev_space_delta;	/* DMU private */
 	blkptr_t	io_bp_orig;
 	/* io_lsize != io_orig_size iff this is a raw write */
 	uint64_t	io_lsize;
 
 	/* Data represented by this I/O */
 	struct abd	*io_abd;
 	struct abd	*io_orig_abd;
 	uint64_t	io_size;
 	uint64_t	io_orig_size;
 
 	/* Stuff for the vdev stack */
 	vdev_t		*io_vd;
 	void		*io_vsd;
 	const zio_vsd_ops_t *io_vsd_ops;
 	metaslab_class_t *io_metaslab_class;	/* dva throttle class */
 
 	enum zio_qstate	io_queue_state;	/* vdev queue state */
 	union {
 		list_node_t l;
 		avl_node_t a;
 	} io_queue_node ____cacheline_aligned;	/* allocator and vdev queues */
 	avl_node_t	io_offset_node;	/* vdev offset queues */
 	uint64_t	io_offset;
 	hrtime_t	io_timestamp;	/* submitted at */
 	hrtime_t	io_queued_timestamp;
 	hrtime_t	io_target_timestamp;
 	hrtime_t	io_delta;	/* vdev queue service delta */
 	hrtime_t	io_delay;	/* Device access time (disk or */
 					/* file). */
 	zio_alloc_list_t 	io_alloc_list;
 
 	/* Internal pipeline state */
 	zio_flag_t	io_flags;
 	enum zio_stage	io_stage;
 	enum zio_stage	io_pipeline;
 	zio_flag_t	io_orig_flags;
 	enum zio_stage	io_orig_stage;
 	enum zio_stage	io_orig_pipeline;
 	enum zio_stage	io_pipeline_trace;
 	int		io_error;
 	int		io_child_error[ZIO_CHILD_TYPES];
 	uint64_t	io_children[ZIO_CHILD_TYPES][ZIO_WAIT_TYPES];
 	uint64_t	*io_stall;
 	zio_t		*io_gang_leader;
 	zio_gang_node_t	*io_gang_tree;
 	void		*io_executor;
 	void		*io_waiter;
 	void		*io_bio;
 	kmutex_t	io_lock;
 	kcondvar_t	io_cv;
 	int		io_allocator;
 
 	/* FMA state */
 	zio_cksum_report_t *io_cksum_report;
 	uint64_t	io_ena;
 
 	/* Taskq dispatching state */
 	taskq_ent_t	io_tqent;
 };
 
 enum blk_verify_flag {
 	BLK_VERIFY_ONLY,
 	BLK_VERIFY_LOG,
 	BLK_VERIFY_HALT
 };
 
 enum blk_config_flag {
 	BLK_CONFIG_HELD,   // SCL_VDEV held for writer
 	BLK_CONFIG_NEEDED, // SCL_VDEV should be obtained for reader
 	BLK_CONFIG_SKIP,   // skip checks which require SCL_VDEV
 };
 
 extern int zio_bookmark_compare(const void *, const void *);
 
 extern zio_t *zio_null(zio_t *pio, spa_t *spa, vdev_t *vd,
     zio_done_func_t *done, void *priv, zio_flag_t flags);
 
 extern zio_t *zio_root(spa_t *spa,
     zio_done_func_t *done, void *priv, zio_flag_t flags);
 
 extern void zio_destroy(zio_t *zio);
 
 extern zio_t *zio_read(zio_t *pio, spa_t *spa, const blkptr_t *bp,
     struct abd *data, uint64_t lsize, zio_done_func_t *done, void *priv,
     zio_priority_t priority, zio_flag_t flags, const zbookmark_phys_t *zb);
 
 extern zio_t *zio_write(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp,
     struct abd *data, uint64_t size, uint64_t psize, const zio_prop_t *zp,
     zio_done_func_t *ready, zio_done_func_t *children_ready,
     zio_done_func_t *done, void *priv, zio_priority_t priority,
     zio_flag_t flags, const zbookmark_phys_t *zb);
 
 extern zio_t *zio_rewrite(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp,
     struct abd *data, uint64_t size, zio_done_func_t *done, void *priv,
     zio_priority_t priority, zio_flag_t flags, zbookmark_phys_t *zb);
 
 extern void zio_write_override(zio_t *zio, blkptr_t *bp, int copies,
     boolean_t nopwrite, boolean_t brtwrite);
 
 extern void zio_free(spa_t *spa, uint64_t txg, const blkptr_t *bp);
 
 extern zio_t *zio_claim(zio_t *pio, spa_t *spa, uint64_t txg,
     const blkptr_t *bp,
     zio_done_func_t *done, void *priv, zio_flag_t flags);
 
 extern zio_t *zio_trim(zio_t *pio, vdev_t *vd, uint64_t offset, uint64_t size,
     zio_done_func_t *done, void *priv, zio_priority_t priority,
     zio_flag_t flags, enum trim_flag trim_flags);
 
 extern zio_t *zio_read_phys(zio_t *pio, vdev_t *vd, uint64_t offset,
     uint64_t size, struct abd *data, int checksum,
     zio_done_func_t *done, void *priv, zio_priority_t priority,
     zio_flag_t flags, boolean_t labels);
 
 extern zio_t *zio_write_phys(zio_t *pio, vdev_t *vd, uint64_t offset,
     uint64_t size, struct abd *data, int checksum,
     zio_done_func_t *done, void *priv, zio_priority_t priority,
     zio_flag_t flags, boolean_t labels);
 
 extern zio_t *zio_free_sync(zio_t *pio, spa_t *spa, uint64_t txg,
     const blkptr_t *bp, zio_flag_t flags);
 
 extern int zio_alloc_zil(spa_t *spa, objset_t *os, uint64_t txg,
     blkptr_t *new_bp, uint64_t size, boolean_t *slog);
 extern void zio_flush(zio_t *zio, vdev_t *vd);
 extern void zio_shrink(zio_t *zio, uint64_t size);
 
 extern size_t zio_get_compression_max_size(enum zio_compress compress,
     uint64_t gcd_alloc, uint64_t min_alloc, size_t s_len);
 extern int zio_wait(zio_t *zio);
 extern void zio_nowait(zio_t *zio);
 extern void zio_execute(void *zio);
 extern void zio_interrupt(void *zio);
 extern void zio_delay_init(zio_t *zio);
 extern void zio_delay_interrupt(zio_t *zio);
 extern void zio_deadman(zio_t *zio, const char *tag);
 
 extern zio_t *zio_walk_parents(zio_t *cio, zio_link_t **);
 extern zio_t *zio_walk_children(zio_t *pio, zio_link_t **);
 extern zio_t *zio_unique_parent(zio_t *cio);
 extern void zio_add_child(zio_t *pio, zio_t *cio);
 extern void zio_add_child_first(zio_t *pio, zio_t *cio);
 
 extern void *zio_buf_alloc(size_t size);
 extern void zio_buf_free(void *buf, size_t size);
 extern void *zio_data_buf_alloc(size_t size);
 extern void zio_data_buf_free(void *buf, size_t size);
 
 extern void zio_push_transform(zio_t *zio, struct abd *abd, uint64_t size,
     uint64_t bufsize, zio_transform_func_t *transform);
 extern void zio_pop_transforms(zio_t *zio);
 
 extern void zio_resubmit_stage_async(void *);
 
 extern zio_t *zio_vdev_child_io(zio_t *zio, blkptr_t *bp, vdev_t *vd,
     uint64_t offset, struct abd *data, uint64_t size, int type,
     zio_priority_t priority, zio_flag_t flags,
     zio_done_func_t *done, void *priv);
 
 extern zio_t *zio_vdev_delegated_io(vdev_t *vd, uint64_t offset,
     struct abd *data, uint64_t size, zio_type_t type, zio_priority_t priority,
     zio_flag_t flags, zio_done_func_t *done, void *priv);
 
 extern void zio_vdev_io_bypass(zio_t *zio);
 extern void zio_vdev_io_reissue(zio_t *zio);
 extern void zio_vdev_io_redone(zio_t *zio);
 
 extern void zio_change_priority(zio_t *pio, zio_priority_t priority);
 
 extern void zio_checksum_verified(zio_t *zio);
+extern void zio_dio_chksum_verify_error_report(zio_t *zio);
 extern int zio_worst_error(int e1, int e2);
 
 extern enum zio_checksum zio_checksum_select(enum zio_checksum child,
     enum zio_checksum parent);
 extern enum zio_checksum zio_checksum_dedup_select(spa_t *spa,
     enum zio_checksum child, enum zio_checksum parent);
 extern enum zio_compress zio_compress_select(spa_t *spa,
     enum zio_compress child, enum zio_compress parent);
 extern uint8_t zio_complevel_select(spa_t *spa, enum zio_compress compress,
     uint8_t child, uint8_t parent);
 
 extern void zio_suspend(spa_t *spa, zio_t *zio, zio_suspend_reason_t);
 extern int zio_resume(spa_t *spa);
 extern void zio_resume_wait(spa_t *spa);
 
 extern boolean_t zfs_blkptr_verify(spa_t *spa, const blkptr_t *bp,
     enum blk_config_flag blk_config, enum blk_verify_flag blk_verify);
 
 /*
  * Initial setup and teardown.
  */
 extern void zio_init(void);
 extern void zio_fini(void);
 
 /*
  * Fault injection
  */
 struct zinject_record;
 extern uint32_t zio_injection_enabled;
 extern int zio_inject_fault(char *name, int flags, int *id,
     struct zinject_record *record);
 extern int zio_inject_list_next(int *id, char *name, size_t buflen,
     struct zinject_record *record);
 extern int zio_clear_fault(int id);
 extern void zio_handle_panic_injection(spa_t *spa, const char *tag,
     uint64_t type);
 extern int zio_handle_decrypt_injection(spa_t *spa, const zbookmark_phys_t *zb,
     uint64_t type, int error);
 extern int zio_handle_fault_injection(zio_t *zio, int error);
 extern int zio_handle_device_injection(vdev_t *vd, zio_t *zio, int error);
 extern int zio_handle_device_injections(vdev_t *vd, zio_t *zio, int err1,
     int err2);
 extern int zio_handle_label_injection(zio_t *zio, int error);
 extern void zio_handle_ignored_writes(zio_t *zio);
 extern hrtime_t zio_handle_io_delay(zio_t *zio);
 extern void zio_handle_import_delay(spa_t *spa, hrtime_t elapsed);
 extern void zio_handle_export_delay(spa_t *spa, hrtime_t elapsed);
 
 /*
  * Checksum ereport functions
  */
 extern int zfs_ereport_start_checksum(spa_t *spa, vdev_t *vd,
     const zbookmark_phys_t *zb, struct zio *zio, uint64_t offset,
     uint64_t length, struct zio_bad_cksum *info);
 extern void zfs_ereport_finish_checksum(zio_cksum_report_t *report,
     const abd_t *good_data, const abd_t *bad_data, boolean_t drop_if_identical);
 
 extern void zfs_ereport_free_checksum(zio_cksum_report_t *report);
 
 /* If we have the good data in hand, this function can be used */
 extern int zfs_ereport_post_checksum(spa_t *spa, vdev_t *vd,
     const zbookmark_phys_t *zb, struct zio *zio, uint64_t offset,
     uint64_t length, const abd_t *good_data, const abd_t *bad_data,
     struct zio_bad_cksum *info);
 
 void zio_vsd_default_cksum_report(zio_t *zio, zio_cksum_report_t *zcr);
 extern void zfs_ereport_snapshot_post(const char *subclass, spa_t *spa,
     const char *name);
 
 /* Called from spa_sync(), but primarily an injection handler */
 extern void spa_handle_ignored_writes(spa_t *spa);
 
 /* zbookmark_phys functions */
 boolean_t zbookmark_subtree_completed(const struct dnode_phys *dnp,
     const zbookmark_phys_t *subtree_root, const zbookmark_phys_t *last_block);
 boolean_t zbookmark_subtree_tbd(const struct dnode_phys *dnp,
     const zbookmark_phys_t *subtree_root, const zbookmark_phys_t *last_block);
 int zbookmark_compare(uint16_t dbss1, uint8_t ibs1, uint16_t dbss2,
     uint8_t ibs2, const zbookmark_phys_t *zb1, const zbookmark_phys_t *zb2);
 
 #ifdef	__cplusplus
 }
 #endif
 
 #endif	/* _ZIO_H */
diff --git a/sys/contrib/openzfs/lib/libspl/backtrace.c b/sys/contrib/openzfs/lib/libspl/backtrace.c
index d26d742106e2..6e8b3b12122d 100644
--- a/sys/contrib/openzfs/lib/libspl/backtrace.c
+++ b/sys/contrib/openzfs/lib/libspl/backtrace.c
@@ -1,119 +1,270 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 /*
  * Copyright (c) 2024, Rob Norris <robn@despairlabs.com>
  * Copyright (c) 2024, Klara Inc.
  */
 
 #include <sys/backtrace.h>
 #include <sys/types.h>
+#include <sys/debug.h>
 #include <unistd.h>
 
 /*
- * libspl_backtrace() must be safe to call from inside a signal hander. This
- * mostly means it must not allocate, and so we can't use things like printf.
+ * Output helpers. libspl_backtrace() must not block, must be thread-safe and
+ * must be safe to call from a signal handler. At least, that means not having
+ * printf, so we end up having to call write() directly on the fd. That's
+ * awkward, as we always have to pass through a length, and some systems will
+ * complain if we don't consume the return. So we have some macros to make
+ * things a little more palatable.
  */
+#define	spl_bt_write_n(fd, s, n) \
+	do { ssize_t r __maybe_unused = write(fd, s, n); } while (0)
+#define	spl_bt_write(fd, s)		spl_bt_write_n(fd, s, sizeof (s))
 
 #if defined(HAVE_LIBUNWIND)
 #define	UNW_LOCAL_ONLY
 #include <libunwind.h>
 
+/*
+ * Convert `v` to ASCII hex characters. The bottom `n` nybbles (4-bits ie one
+ * hex digit) will be written, up to `buflen`. The buffer will not be
+ * null-terminated. Returns the number of digits written.
+ */
 static size_t
-libspl_u64_to_hex_str(uint64_t v, size_t digits, char *buf, size_t buflen)
+spl_bt_u64_to_hex_str(uint64_t v, size_t n, char *buf, size_t buflen)
 {
 	static const char hexdigits[] = {
 	    '0', '1', '2', '3', '4', '5', '6', '7',
 	    '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
 	};
 
 	size_t pos = 0;
-	boolean_t want = (digits == 0);
+	boolean_t want = (n == 0);
 	for (int i = 15; i >= 0; i--) {
 		const uint64_t d = v >> (i * 4) & 0xf;
-		if (!want && (d != 0 || digits > i))
+		if (!want && (d != 0 || n > i))
 			want = B_TRUE;
 		if (want) {
 			buf[pos++] = hexdigits[d];
 			if (pos == buflen)
 				break;
 		}
 	}
 	return (pos);
 }
 
 void
 libspl_backtrace(int fd)
 {
-	ssize_t ret __attribute__((unused));
 	unw_context_t uc;
 	unw_cursor_t cp;
-	unw_word_t loc;
+	unw_word_t v;
 	char buf[128];
 	size_t n;
+	int err;
 
-	ret = write(fd, "Call trace:\n", 12);
+	/* Snapshot the current frame and state. */
 	unw_getcontext(&uc);
+
+	/*
+	 * TODO: walk back to the frame that tripped the assertion / the place
+	 *       where the signal was recieved.
+	 */
+
+	/*
+	 * Register dump. We're going to loop over all the registers in the
+	 * top frame, and show them, with names, in a nice three-column
+	 * layout, which keeps us within 80 columns.
+	 */
+	spl_bt_write(fd, "Registers:\n");
+
+	/* Initialise a frame cursor, starting at the current frame */
 	unw_init_local(&cp, &uc);
-	while (unw_step(&cp) > 0) {
-		unw_get_reg(&cp, UNW_REG_IP, &loc);
-		ret = write(fd, "  [0x", 5);
-		n = libspl_u64_to_hex_str(loc, 10, buf, sizeof (buf));
-		ret = write(fd, buf, n);
-		ret = write(fd, "] ", 2);
-		unw_get_proc_name(&cp, buf, sizeof (buf), &loc);
-		for (n = 0; n < sizeof (buf) && buf[n] != '\0'; n++) {}
-		ret = write(fd, buf, n);
-		ret = write(fd, "+0x", 3);
-		n = libspl_u64_to_hex_str(loc, 2, buf, sizeof (buf));
-		ret = write(fd, buf, n);
+
+	/*
+	 * libunwind's list of possible registers for this architecture is an
+	 * enum, unw_regnum_t. UNW_TDEP_LAST_REG is the highest-numbered
+	 * register in that list, however, not all register numbers in this
+	 * range are defined by the architecture, and not all defined registers
+	 * will be present on every implementation of that architecture.
+	 * Moreover, libunwind provides nice names for most, but not all
+	 * registers, but these are hardcoded; a name being available does not
+	 * mean that register is available.
+	 *
+	 * So, we have to pull this all together here. We try to get the value
+	 * of every possible register. If we get a value for it, then the
+	 * register must exist, and so we get its name. If libunwind has no
+	 * name for it, we synthesize something. These cases should be rare,
+	 * and they're usually for uninteresting or niche registers, so it
+	 * shouldn't really matter. We can see the value, and that's the main
+	 * thing.
+	 */
+	uint_t cols = 0;
+	for (uint_t regnum = 0; regnum <= UNW_TDEP_LAST_REG; regnum++) {
+		/*
+		 * Get the value. Any error probably means the register
+		 * doesn't exist, and we skip it.
+		 */
+		if (unw_get_reg(&cp, regnum, &v) < 0)
+			continue;
+
+		/*
+		 * Register name. If libunwind doesn't have a name for it,
+		 * it will return "???". As a shortcut, we just treat '?'
+		 * is an alternate end-of-string character.
+		 */
+		const char *name = unw_regname(regnum);
+		for (n = 0; name[n] != '\0' && name[n] != '?'; n++) {}
+		if (n == 0) {
+			/*
+			 * No valid name, so make one of the form "?xx", where
+			 * "xx" is the two-char hex of libunwind's register
+			 * number.
+			 */
+			buf[0] = '?';
+			n = spl_bt_u64_to_hex_str(regnum, 2,
+			    &buf[1], sizeof (buf)-1) + 1;
+			name = buf;
+		}
+
+		/*
+		 * Two spaces of padding before each column, plus extra
+		 * spaces to align register names shorter than three chars.
+		 */
+		spl_bt_write_n(fd, "      ", 5-MIN(n, 3));
+
+		/* Register name and column punctuation */
+		spl_bt_write_n(fd, name, n);
+		spl_bt_write(fd, ": 0x");
+
+		/*
+		 * Convert register value (from unw_get_reg()) to hex. We're
+		 * assuming that all registers are 64-bits wide, which is
+		 * probably fine for any general-purpose registers on any
+		 * machine currently in use. A more generic way would be to
+		 * look at the width of unw_word_t, but that would also
+		 * complicate the column code a bit. This is fine.
+		 */
+		n = spl_bt_u64_to_hex_str(v, 16, buf, sizeof (buf));
+		spl_bt_write_n(fd, buf, n);
+
+		/* Every third column, emit a newline */
+		if (!(++cols % 3))
+			spl_bt_write(fd, "\n");
+	}
+
+	/* If we finished before the third column, emit a newline. */
+	if (cols % 3)
+		spl_bt_write(fd, "\n");
+
+	/* Now the main event, the backtrace. */
+	spl_bt_write(fd, "Call trace:\n");
+
+	/* Reset the cursor to the top again. */
+	unw_init_local(&cp, &uc);
+
+	do {
+		/*
+		 * Getting the IP should never fail; libunwind handles it
+		 * specially, because its used a lot internally. Still, no
+		 * point being silly about it, as the last thing we want is
+		 * our crash handler to crash. So if it ever does fail, we'll
+		 * show an error line, but keep going to the next frame.
+		 */
+		if (unw_get_reg(&cp, UNW_REG_IP, &v) < 0) {
+			spl_bt_write(fd, "  [couldn't get IP register; "
+			    "corrupt frame?]");
+			continue;
+		}
+
+		/* IP & punctuation */
+		n = spl_bt_u64_to_hex_str(v, 16, buf, sizeof (buf));
+		spl_bt_write(fd, "  [0x");
+		spl_bt_write_n(fd, buf, n);
+		spl_bt_write(fd, "] ");
+
+		/*
+		 * Function ("procedure") name for the current frame. `v`
+		 * receives the offset from the named function to the IP, which
+		 * we show as a "+offset" suffix.
+		 *
+		 * If libunwind can't determine the name, we just show "???"
+		 * instead. We've already displayed the IP above; that will
+		 * have to do.
+		 *
+		 * unw_get_proc_name() will return ENOMEM if the buffer is too
+		 * small, instead truncating the name. So we treat that as a
+		 * success and use whatever is in the buffer.
+		 */
+		err = unw_get_proc_name(&cp, buf, sizeof (buf), &v);
+		if (err == 0 || err == -UNW_ENOMEM) {
+			for (n = 0; n < sizeof (buf) && buf[n] != '\0'; n++) {}
+			spl_bt_write_n(fd, buf, n);
+
+			/* Offset from proc name */
+			spl_bt_write(fd, "+0x");
+			n = spl_bt_u64_to_hex_str(v, 2, buf, sizeof (buf));
+			spl_bt_write_n(fd, buf, n);
+		} else
+			spl_bt_write(fd, "???");
+
 #ifdef HAVE_LIBUNWIND_ELF
-		ret = write(fd, " (in ", 5);
-		unw_get_elf_filename(&cp, buf, sizeof (buf), &loc);
-		for (n = 0; n < sizeof (buf) && buf[n] != '\0'; n++) {}
-		ret = write(fd, buf, n);
-		ret = write(fd, " +0x", 4);
-		n = libspl_u64_to_hex_str(loc, 2, buf, sizeof (buf));
-		ret = write(fd, buf, n);
-		ret = write(fd, ")", 1);
+		/*
+		 * Newer libunwind has unw_get_elf_filename(), which gets
+		 * the name of the ELF object that the frame was executing in.
+		 * Like `unw_get_proc_name()`, `v` recieves the offset within
+		 * the file, and UNW_ENOMEM indicates that a truncate filename
+		 * was left in the buffer.
+		 */
+		err = unw_get_elf_filename(&cp, buf, sizeof (buf), &v);
+		if (err == 0 || err == -UNW_ENOMEM) {
+			for (n = 0; n < sizeof (buf) && buf[n] != '\0'; n++) {}
+			spl_bt_write(fd, " (in ");
+			spl_bt_write_n(fd, buf, n);
+
+			/* Offset within file */
+			spl_bt_write(fd, " +0x");
+			n = spl_bt_u64_to_hex_str(v, 2, buf, sizeof (buf));
+			spl_bt_write_n(fd, buf, n);
+			spl_bt_write(fd, ")");
+		}
 #endif
-		ret = write(fd, "\n", 1);
-	}
+		spl_bt_write(fd, "\n");
+	} while (unw_step(&cp) > 0);
 }
 #elif defined(HAVE_BACKTRACE)
 #include <execinfo.h>
 
 void
 libspl_backtrace(int fd)
 {
-	ssize_t ret __attribute__((unused));
 	void *btptrs[64];
 	size_t nptrs = backtrace(btptrs, 64);
-	ret = write(fd, "Call trace:\n", 12);
+	spl_bt_write(fd, "Call trace:\n");
 	backtrace_symbols_fd(btptrs, nptrs, fd);
 }
 #else
-#include <sys/debug.h>
-
 void
 libspl_backtrace(int fd __maybe_unused)
 {
 }
 #endif
diff --git a/sys/contrib/openzfs/lib/libzfs/Makefile.am b/sys/contrib/openzfs/lib/libzfs/Makefile.am
index a976faaf9913..5f8963dccd1a 100644
--- a/sys/contrib/openzfs/lib/libzfs/Makefile.am
+++ b/sys/contrib/openzfs/lib/libzfs/Makefile.am
@@ -1,78 +1,78 @@
 libzfs_la_CFLAGS  = $(AM_CFLAGS) $(LIBRARY_CFLAGS)
 libzfs_la_CFLAGS += $(LIBCRYPTO_CFLAGS) $(ZLIB_CFLAGS)
 libzfs_la_CFLAGS += -fvisibility=hidden
 
 lib_LTLIBRARIES += libzfs.la
 CPPCHECKTARGETS += libzfs.la
 
 dist_libzfs_la_SOURCES = \
 	%D%/libzfs_impl.h \
 	%D%/libzfs_changelist.c \
 	%D%/libzfs_config.c \
 	%D%/libzfs_crypto.c \
 	%D%/libzfs_dataset.c \
 	%D%/libzfs_diff.c \
 	%D%/libzfs_import.c \
 	%D%/libzfs_iter.c \
 	%D%/libzfs_mount.c \
 	%D%/libzfs_pool.c \
 	%D%/libzfs_sendrecv.c \
 	%D%/libzfs_status.c \
 	%D%/libzfs_util.c
 
 if BUILD_FREEBSD
 dist_libzfs_la_SOURCES += \
 	%D%/os/freebsd/libzfs_compat.c \
 	%D%/os/freebsd/libzfs_zmount.c
 endif
 
 if BUILD_LINUX
 dist_libzfs_la_SOURCES += \
 	%D%/os/linux/libzfs_mount_os.c \
 	%D%/os/linux/libzfs_pool_os.c \
 	%D%/os/linux/libzfs_util_os.c
 endif
 
 nodist_libzfs_la_SOURCES = \
 	module/zcommon/cityhash.c \
 	module/zcommon/zfeature_common.c \
 	module/zcommon/zfs_comutil.c \
 	module/zcommon/zfs_deleg.c \
 	module/zcommon/zfs_fletcher.c \
 	module/zcommon/zfs_fletcher_aarch64_neon.c \
 	module/zcommon/zfs_fletcher_avx512.c \
 	module/zcommon/zfs_fletcher_intel.c \
 	module/zcommon/zfs_fletcher_sse.c \
 	module/zcommon/zfs_fletcher_superscalar.c \
 	module/zcommon/zfs_fletcher_superscalar4.c \
 	module/zcommon/zfs_namecheck.c \
 	module/zcommon/zfs_prop.c \
 	module/zcommon/zfs_valstr.c \
 	module/zcommon/zpool_prop.c \
 	module/zcommon/zprop_common.c
 
 libzfs_la_LIBADD = \
 	libshare.la \
 	libzfs_core.la \
 	libnvpair.la \
 	libzutil.la \
 	libuutil.la
 
 libzfs_la_LIBADD += -lrt -lm $(LIBCRYPTO_LIBS) $(ZLIB_LIBS) $(LIBFETCH_LIBS) $(LTLIBINTL)
 
 libzfs_la_LDFLAGS = -pthread
 
 if !ASAN_ENABLED
 libzfs_la_LDFLAGS += -Wl,-z,defs
 endif
 
 if BUILD_FREEBSD
 libzfs_la_LIBADD += -lutil -lgeom
 endif
 
-libzfs_la_LDFLAGS += -version-info 5:0:1
+libzfs_la_LDFLAGS += -version-info 6:0:0
 
 pkgconfig_DATA += %D%/libzfs.pc
 
 dist_noinst_DATA += %D%/libzfs.abi %D%/libzfs.suppr
 dist_noinst_DATA += %D%/THIRDPARTYLICENSE.openssl %D%/THIRDPARTYLICENSE.openssl.descrip
diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs.abi b/sys/contrib/openzfs/lib/libzfs/libzfs.abi
index 1a96460c2b84..ac9ae233c72d 100644
--- a/sys/contrib/openzfs/lib/libzfs/libzfs.abi
+++ b/sys/contrib/openzfs/lib/libzfs/libzfs.abi
@@ -1,10127 +1,10127 @@
-<abi-corpus version='2.0' architecture='elf-amd-x86_64' soname='libzfs.so.4'>
+<abi-corpus version='2.0' architecture='elf-amd-x86_64' soname='libzfs.so.6'>
   <elf-needed>
     <dependency name='libzfs_core.so.3'/>
     <dependency name='libnvpair.so.3'/>
     <dependency name='libunwind.so.8'/>
     <dependency name='libuuid.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.3'/>
     <dependency name='libz.so.1'/>
     <dependency name='libc.so.6'/>
     <dependency name='ld-linux-x86-64.so.2'/>
   </elf-needed>
   <elf-function-symbols>
     <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='bookmark_namecheck' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='cityhash1' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='cityhash2' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='cityhash3' 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='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='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_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_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='entity_namecheck' 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='format_timestamp' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='fsleep' 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='get_system_hostid' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='get_timestamp' 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='getprop_uint64' 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_mounted' 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='libpc_error_description' 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='libspl_backtrace' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='libspl_set_assert_ok' 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_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='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='membar_sync' 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='mountpoint_namecheck' 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='print_timestamp' 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='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_truncate_shares' 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='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_vdev_config_dev_sysfs_path' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='use_color' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='vdev_expand_proplist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='vdev_name_to_prop' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='vdev_prop_align_right' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='vdev_prop_column_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='vdev_prop_default_numeric' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='vdev_prop_default_string' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='vdev_prop_get_table' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='vdev_prop_get_type' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='vdev_prop_index_to_string' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='vdev_prop_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='vdev_prop_random_value' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='vdev_prop_readonly' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='vdev_prop_string_to_index' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='vdev_prop_to_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='vdev_prop_user' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='vdev_prop_values' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zcmd_print_json' 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_allocatable_devs' 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_basename' 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_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_destroy_snaps_nvl_os' 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_dirnamelen' 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_enclosure_sysfs_path' 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_underlying_path' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zfs_get_underlying_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_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_isnumber' 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_bookmarks_v2' 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_children_v2' 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_dependents_v2' 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_filesystems_v2' 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_snapshots_sorted_v2' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zfs_iter_snapshots_v2' 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_iter_snapspec_v2' 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_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_nicestrtonum' 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_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_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_set_list_flags' 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_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_resolve_shortname' 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_setproctitle' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zfs_setproctitle_init' 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_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_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='zfs_truncate_shares' 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_unshareall' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zfs_userns' 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_valstr_zio_flag' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zfs_valstr_zio_flag_bits' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zfs_valstr_zio_flag_pairs' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zfs_valstr_zio_priority' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zfs_valstr_zio_stage' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zfs_valstr_zio_stage_bits' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zfs_valstr_zio_stage_pairs' 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_nvlist' 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_add_propname' 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_collect_unsup_feat' 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_ddt_prune' 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_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_os' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zpool_disable_volume_os' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zpool_discard_checkpoint' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zpool_disk_wait' 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_enable_datasets' type='func-type' binding='global-binding' visibility='default-visibility' 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_config' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zpool_find_parent_vdev' 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_all_vdev_props' 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_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_get_userprop' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zpool_get_vdev_prop' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zpool_get_vdev_prop_value' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zpool_getenv_int' 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_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_label_disk_wait' 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_name_to_prop' 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_pool_state_to_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zpool_prefetch' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zpool_prepare_and_label_disk' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zpool_prepare_disk' 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_prop_vdev' 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_read_label' 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_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_search_import' 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_guid' 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_set_vdev_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_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_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_remove_wanted' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zpool_vdev_script_alloc_env' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zpool_vdev_script_free_env' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='zpool_vdev_set_removed_state' 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_collect_property' 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_nvlist_one_property' 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_char' 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='efi_debug' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <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='128' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='fletcher_4_avx512bw_ops' size='128' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='fletcher_4_avx512f_ops' size='128' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='fletcher_4_sse2_ops' size='128' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='fletcher_4_ssse3_ops' size='128' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='fletcher_4_superscalar4_ops' size='128' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='fletcher_4_superscalar_ops' size='128' 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='sa_protocol_names' size='16' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
     <elf-symbol name='spa_feature_table' size='2464' 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 address-size='64' path='lib/libefi/rdwr_efi.c' language='LANG_C99'>
     <typedef-decl name='uInt' type-id='f0981eeb' id='09110a74'/>
     <var-decl name='efi_debug' type-id='95e97e5e' mangled-name='efi_debug' visibility='default' elf-symbol-id='efi_debug'/>
     <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='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='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>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libshare/libshare.c' language='LANG_C99'>
     <array-type-def dimensions='1' type-id='b99c00c9' size-in-bits='128' id='2d6895a3'>
       <subrange length='2' type-id='7359adad' id='52efc4ef'/>
     </array-type-def>
     <var-decl name='sa_protocol_names' type-id='2d6895a3' mangled-name='sa_protocol_names' visibility='default' elf-symbol-id='sa_protocol_names'/>
     <type-decl name='unsigned long int' size-in-bits='64' id='7359adad'/>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libshare/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'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='memchr' 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='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='fchmod' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='e1c52942'/>
       <return type-id='95e97e5e'/>
     </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>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libshare/os/linux/nfs.c' language='LANG_C99'>
     <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_zfsname' type-id='80f4b756' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='64'>
         <var-decl name='sa_mountpoint' type-id='80f4b756' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='128'>
         <var-decl name='sa_shareopts' type-id='80f4b756' visibility='default'/>
       </data-member>
     </class-decl>
     <typedef-decl name='sa_share_impl_t' type-id='946a2c6b' id='a48b47d0'/>
     <class-decl name='sa_fstype_t' size-in-bits='384' is-struct='yes' naming-typedef-id='639af739' visibility='default' id='944afa86'>
       <data-member access='public' layout-offset-in-bits='0'>
         <var-decl name='enable_share' type-id='2f78a9c1' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='64'>
         <var-decl name='disable_share' type-id='2f78a9c1' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='128'>
         <var-decl name='is_shared' type-id='81020bc2' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='192'>
         <var-decl name='validate_shareopts' type-id='f194a8fb' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='256'>
         <var-decl name='commit_shares' type-id='797ee7da' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='320'>
         <var-decl name='truncate_shares' type-id='5d51038b' visibility='default'/>
       </data-member>
     </class-decl>
     <typedef-decl name='sa_fstype_t' type-id='944afa86' id='639af739'/>
     <qualified-type-def type-id='639af739' const='yes' id='d19dbca9'/>
     <qualified-type-def type-id='72b09bf8' const='yes' id='484950e3'/>
     <pointer-type-def type-id='484950e3' size-in-bits='64' id='946a2c6b'/>
     <pointer-type-def type-id='276427e1' size-in-bits='64' id='1db260e5'/>
     <qualified-type-def type-id='1db260e5' const='yes' id='797ee7da'/>
     <pointer-type-def type-id='5113b296' size-in-bits='64' id='70487b28'/>
     <qualified-type-def type-id='70487b28' const='yes' id='f194a8fb'/>
     <pointer-type-def type-id='c13578bc' size-in-bits='64' id='fa1f29ce'/>
     <qualified-type-def type-id='fa1f29ce' const='yes' id='2f78a9c1'/>
     <pointer-type-def type-id='723e6cf2' size-in-bits='64' id='1d99e49c'/>
     <pointer-type-def type-id='86373eb1' size-in-bits='64' id='f337456d'/>
     <qualified-type-def type-id='f337456d' const='yes' id='81020bc2'/>
     <qualified-type-def type-id='953b12f8' const='yes' id='5d51038b'/>
     <var-decl name='libshare_nfs_type' type-id='d19dbca9' visibility='default'/>
     <function-decl name='nfs_escape_mountpoint' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <parameter type-id='9b23c9ad'/>
       <parameter type-id='37e3bd22'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='nfs_is_shared_impl' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <parameter type-id='a48b47d0'/>
       <return type-id='c19b74c3'/>
     </function-decl>
     <function-decl name='nfs_toggle_share' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='a48b47d0'/>
       <parameter type-id='1d99e49c'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='nfs_reset_shares' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <parameter type-id='80f4b756'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <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='723e6cf2'>
       <parameter type-id='a48b47d0'/>
       <parameter type-id='822cd80b'/>
       <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='ee076206'>
       <return type-id='48b5725f'/>
     </function-type>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libshare/os/linux/smb.c' language='LANG_C99'>
     <var-decl name='libshare_smb_type' type-id='d19dbca9' visibility='default'/>
     <function-decl name='__fgets_chk' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='266fe297'/>
       <parameter type-id='b59d7dce'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='e75a27e9'/>
       <return type-id='26a90f95'/>
     </function-decl>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libspl/assert.c' language='LANG_C99'>
     <function-decl name='libspl_backtrace' mangled-name='libspl_backtrace' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libspl_backtrace'>
       <parameter type-id='95e97e5e'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='gettid' visibility='default' binding='global' size-in-bits='64'>
       <return type-id='3629bad8'/>
     </function-decl>
     <function-decl name='prctl' 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='libspl_set_assert_ok' mangled-name='libspl_set_assert_ok' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libspl_set_assert_ok'>
       <parameter type-id='c19b74c3' name='val'/>
       <return type-id='48b5725f'/>
     </function-decl>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libspl/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='b96825af' volatile='yes' id='84ff7d66'/>
     <pointer-type-def type-id='84ff7d66' size-in-bits='64' id='aa323ea4'/>
     <qualified-type-def type-id='ee1f298e' volatile='yes' id='6f7e09cb'/>
     <pointer-type-def type-id='6f7e09cb' size-in-bits='64' id='64698d33'/>
     <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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_consumer' mangled-name='membar_consumer' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='membar_consumer'>
       <return type-id='48b5725f'/>
     </function-decl>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libspl/backtrace.c' language='LANG_C99'>
     <array-type-def dimensions='1' type-id='62f1140c' size-in-bits='768' id='b80f3d9b'>
       <subrange length='24' type-id='7359adad' id='fdd3342b'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='62f1140c' size-in-bits='128' id='bc19e735'>
       <subrange length='4' type-id='7359adad' id='16fe7105'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='22c546af' size-in-bits='1024' id='498c040b'>
       <subrange length='8' type-id='7359adad' id='56e0c0b1'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='4ea07cdb' size-in-bits='2048' id='4811c35e'>
       <subrange length='16' type-id='7359adad' id='848d0938'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='de572c22' size-in-bits='1472' id='6d3c2f42'>
       <subrange length='23' type-id='7359adad' id='fdd0f594'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='3a47d82b' size-in-bits='256' id='a133ec23'>
       <subrange length='4' type-id='7359adad' id='16fe7105'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='3a47d82b' size-in-bits='512' id='a13e797f'>
       <subrange length='8' type-id='7359adad' id='56e0c0b1'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='8efea9e5' size-in-bits='48' id='ff2536e2'>
       <subrange length='3' type-id='7359adad' id='56f209d2'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='8efea9e5' size-in-bits='64' id='3f30d495'>
       <subrange length='4' type-id='7359adad' id='16fe7105'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='73d941c6' size-in-bits='8128' id='dc70ec0b'>
       <subrange length='127' type-id='7359adad' id='5ed08de5'/>
     </array-type-def>
     <class-decl name='stack_t' size-in-bits='192' is-struct='yes' naming-typedef-id='ac5e685f' visibility='default' id='380f9954'>
       <data-member access='public' layout-offset-in-bits='0'>
         <var-decl name='ss_sp' type-id='eaa32e2f' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='64'>
         <var-decl name='ss_flags' type-id='95e97e5e' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='128'>
         <var-decl name='ss_size' type-id='b59d7dce' visibility='default'/>
       </data-member>
     </class-decl>
     <typedef-decl name='stack_t' type-id='380f9954' id='ac5e685f'/>
     <class-decl name='unw_cursor' size-in-bits='8128' is-struct='yes' visibility='default' id='384a1f22'>
       <data-member access='public' layout-offset-in-bits='0'>
         <var-decl name='opaque' type-id='dc70ec0b' visibility='default'/>
       </data-member>
     </class-decl>
     <typedef-decl name='unw_cursor_t' type-id='384a1f22' id='1203d35c'/>
     <typedef-decl name='unw_context_t' type-id='190d09ef' id='8f527367'/>
     <typedef-decl name='unw_word_t' type-id='9c313c2d' id='73d941c6'/>
     <typedef-decl name='unw_tdep_context_t' type-id='c4daa689' id='190d09ef'/>
     <typedef-decl name='greg_t' type-id='1eb56b1e' id='de572c22'/>
     <typedef-decl name='gregset_t' type-id='6d3c2f42' id='a66f139c'/>
     <class-decl name='_libc_fpxreg' size-in-bits='128' is-struct='yes' visibility='default' id='22c546af'>
       <data-member access='public' layout-offset-in-bits='0'>
         <var-decl name='significand' type-id='3f30d495' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='64'>
         <var-decl name='exponent' type-id='8efea9e5' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='80'>
         <var-decl name='__glibc_reserved1' type-id='ff2536e2' visibility='default'/>
       </data-member>
     </class-decl>
     <class-decl name='_libc_xmmreg' size-in-bits='128' is-struct='yes' visibility='default' id='4ea07cdb'>
       <data-member access='public' layout-offset-in-bits='0'>
         <var-decl name='element' type-id='bc19e735' visibility='default'/>
       </data-member>
     </class-decl>
     <class-decl name='_libc_fpstate' size-in-bits='4096' is-struct='yes' visibility='default' id='81cbe5ca'>
       <data-member access='public' layout-offset-in-bits='0'>
         <var-decl name='cwd' type-id='253c2d2a' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='16'>
         <var-decl name='swd' type-id='253c2d2a' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='32'>
         <var-decl name='ftw' type-id='253c2d2a' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='48'>
         <var-decl name='fop' type-id='253c2d2a' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='64'>
         <var-decl name='rip' type-id='8910171f' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='128'>
         <var-decl name='rdp' type-id='8910171f' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='192'>
         <var-decl name='mxcsr' type-id='62f1140c' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='224'>
         <var-decl name='mxcr_mask' type-id='62f1140c' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='256'>
         <var-decl name='_st' type-id='498c040b' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='1280'>
         <var-decl name='_xmm' type-id='4811c35e' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='3328'>
         <var-decl name='__glibc_reserved1' type-id='b80f3d9b' visibility='default'/>
       </data-member>
     </class-decl>
     <typedef-decl name='fpregset_t' type-id='5b1ab9a8' id='6e5851bb'/>
     <class-decl name='mcontext_t' size-in-bits='2048' is-struct='yes' naming-typedef-id='bacab071' visibility='default' id='76fab990'>
       <data-member access='public' layout-offset-in-bits='0'>
         <var-decl name='gregs' type-id='a66f139c' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='1472'>
         <var-decl name='fpregs' type-id='6e5851bb' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='1536'>
         <var-decl name='__reserved1' type-id='a13e797f' visibility='default'/>
       </data-member>
     </class-decl>
     <typedef-decl name='mcontext_t' type-id='76fab990' id='bacab071'/>
     <class-decl name='ucontext_t' size-in-bits='7744' is-struct='yes' visibility='default' id='1ba65dc8'>
       <data-member access='public' layout-offset-in-bits='0'>
         <var-decl name='uc_flags' type-id='7359adad' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='64'>
         <var-decl name='uc_link' type-id='4ed508de' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='128'>
         <var-decl name='uc_stack' type-id='ac5e685f' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='320'>
         <var-decl name='uc_mcontext' type-id='bacab071' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='2368'>
         <var-decl name='uc_sigmask' type-id='daf33c64' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='3392'>
         <var-decl name='__fpregs_mem' type-id='81cbe5ca' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='7488'>
         <var-decl name='__ssp' type-id='a133ec23' visibility='default'/>
       </data-member>
     </class-decl>
     <typedef-decl name='ucontext_t' type-id='1ba65dc8' id='c4daa689'/>
     <pointer-type-def type-id='81cbe5ca' size-in-bits='64' id='5b1ab9a8'/>
     <pointer-type-def type-id='1ba65dc8' size-in-bits='64' id='4ed508de'/>
     <pointer-type-def type-id='8f527367' size-in-bits='64' id='2e408b96'/>
     <pointer-type-def type-id='1203d35c' size-in-bits='64' id='3946e4d1'/>
     <pointer-type-def type-id='190d09ef' size-in-bits='64' id='3e0601f0'/>
     <pointer-type-def type-id='73d941c6' size-in-bits='64' id='42f5faab'/>
     <function-decl name='_ULx86_64_init_local' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='3946e4d1'/>
       <parameter type-id='2e408b96'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='_ULx86_64_step' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='3946e4d1'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='_ULx86_64_get_reg' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='3946e4d1'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='42f5faab'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='_ULx86_64_get_proc_name' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='3946e4d1'/>
       <parameter type-id='26a90f95'/>
       <parameter type-id='b59d7dce'/>
       <parameter type-id='42f5faab'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='_Ux86_64_getcontext' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='3e0601f0'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <type-decl name='unsigned short int' size-in-bits='16' id='8efea9e5'/>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libspl/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>
     <function-decl name='getexecname_impl' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='26a90f95'/>
       <return type-id='79a0948f'/>
     </function-decl>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libspl/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='192' is-struct='yes' visibility='default' id='e824dae9'>
       <data-member access='public' layout-offset-in-bits='0'>
         <var-decl name='list_offset' type-id='b59d7dce' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='64'>
         <var-decl name='list_head' type-id='b0b5e45e' visibility='default'/>
       </data-member>
     </class-decl>
     <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_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_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_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_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'/>
       <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 address-size='64' path='lib/libspl/mkdirp.c' language='LANG_C99'>
     <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='__mbstowcs_chk' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='f1358bc3'/>
       <parameter type-id='9d26089a'/>
       <parameter type-id='b59d7dce'/>
       <parameter type-id='b59d7dce'/>
       <return type-id='b59d7dce'/>
     </function-decl>
     <function-decl name='__wcstombs_chk' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='266fe297'/>
       <parameter type-id='598aab80'/>
       <parameter type-id='b59d7dce'/>
       <parameter type-id='b59d7dce'/>
       <return type-id='b59d7dce'/>
     </function-decl>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libspl/os/linux/getmntany.c' language='LANG_C99'>
     <pointer-type-def type-id='56fe4a37' size-in-bits='64' id='b6b61d2f'/>
     <qualified-type-def type-id='b6b61d2f' restrict='yes' id='3cad23cd'/>
     <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>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libspl/timestamp.c' language='LANG_C99'>
     <typedef-decl name='nl_item' type-id='95e97e5e' id='03b79a94'/>
     <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='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='get_timestamp' mangled-name='get_timestamp' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='get_timestamp'>
       <parameter type-id='3502e3ff' name='timestamp_fmt'/>
       <parameter type-id='26a90f95' name='buf'/>
       <parameter type-id='95e97e5e' name='len'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='format_timestamp' mangled-name='format_timestamp' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='format_timestamp'>
       <parameter type-id='c9d12d66' name='t'/>
       <parameter type-id='26a90f95' name='buf'/>
       <parameter type-id='95e97e5e' name='len'/>
       <return type-id='48b5725f'/>
     </function-decl>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libtpool/thread_pool.c' language='LANG_C99'>
     <array-type-def dimensions='1' type-id='49ef3ffd' size-in-bits='1024' id='a14403f5'>
       <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='7359adad' id='8f6d2a81'/>
     </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>
     <union-decl name='__atomic_wide_counter' size-in-bits='64' naming-typedef-id='f3b40860' visibility='default' id='613ce450'>
       <data-member access='public'>
         <var-decl name='__value64' type-id='3a47d82b' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='__value32' type-id='e7f43f72' visibility='default'/>
       </data-member>
     </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='__low' type-id='f0981eeb' visibility='default'/>
       </data-member>
       <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='__atomic_wide_counter' type-id='613ce450' id='f3b40860'/>
     <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'/>
     <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='public'>
         <var-decl name='__size' type-id='36d7f119' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='__align' type-id='1eb56b1e' visibility='default'/>
       </data-member>
     </union-decl>
     <typedef-decl name='pthread_cond_t' type-id='cbb12c12' id='62fab762'/>
     <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='__wseq' type-id='f3b40860' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='64'>
         <var-decl name='__g1_start' type-id='f3b40860' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='128'>
         <var-decl name='__g_refs' type-id='0d532ec1' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='192'>
         <var-decl name='__g_size' type-id='0d532ec1' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='256'>
         <var-decl name='__g1_orig_size' type-id='f0981eeb' visibility='default'/>
       </data-member>
       <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='320'>
         <var-decl name='__g_signals' type-id='0d532ec1' visibility='default'/>
       </data-member>
     </class-decl>
     <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>
     </class-decl>
     <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>
     <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='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='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='0897719a' size-in-bits='64' id='23cbcb08'/>
     <qualified-type-def type-id='23cbcb08' restrict='yes' id='b09b2050'/>
     <pointer-type-def type-id='6fcda10e' size-in-bits='64' id='ad33e5e7'/>
     <pointer-type-def type-id='66a0afc9' size-in-bits='64' id='f32b30e4'/>
     <qualified-type-def type-id='63e171df' restrict='yes' id='9e7a3a7d'/>
     <function-decl name='pthread_self' visibility='default' binding='global' size-in-bits='64'>
       <return type-id='4051f5e7'/>
     </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_destroy' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='7347a39e'/>
       <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_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_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_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_setschedpolicy' 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_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_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='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='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_unregister_cancel' 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='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_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-decl name='__sysconf' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='95e97e5e'/>
       <return type-id='bd54fe1a'/>
     </function-decl>
     <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>
     <pointer-type-def type-id='b1bbf10d' size-in-bits='64' id='9cf59a50'/>
     <typedef-decl name='tpool_t' type-id='88d1b7f9' id='b1bbf10d'/>
     <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>
     <function-type size-in-bits='64' id='c5c76c9c'>
       <parameter type-id='eaa32e2f'/>
       <return type-id='48b5725f'/>
     </function-type>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libzfs/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='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='7359adad' id='c60446f8'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='a84c031d' size-in-bits='2048' id='d1617432'>
       <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='7359adad' id='8f80b239'/>
     </array-type-def>
     <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'/>
     <array-type-def dimensions='1' type-id='80f4b756' size-in-bits='256' id='71dc54ac'>
       <subrange length='4' type-id='7359adad' id='16fe7105'/>
     </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='long long int' size-in-bits='64' id='1eb56b1e'/>
     <type-decl name='short int' size-in-bits='16' id='a2185560'/>
     <array-type-def dimensions='1' type-id='e475ab95' size-in-bits='192' id='0ce65a8b'>
       <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='void' id='48b5725f'/>
     <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='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'/>
     <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_pad' 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='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_INVALID' value='0'/>
       <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'/>
       <enumerator name='ZFS_TYPE_VDEV' value='32'/>
     </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='ZPROP_USERPROP' 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_PROP_SNAPSHOTS_CHANGED' value='95'/>
       <enumerator name='ZFS_PROP_PREFETCH' value='96'/>
       <enumerator name='ZFS_PROP_VOLTHREADING' value='97'/>
       <enumerator name='ZFS_PROP_DIRECT' value='98'/>
       <enumerator name='ZFS_PROP_LONGNAME' value='99'/>
       <enumerator name='ZFS_NUM_PROPS' value='100'/>
     </enum-decl>
     <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='ZPROP_SRC_NONE' value='1'/>
       <enumerator name='ZPROP_SRC_DEFAULT' value='2'/>
       <enumerator name='ZPROP_SRC_TEMPORARY' value='4'/>
       <enumerator name='ZPROP_SRC_LOCAL' value='8'/>
       <enumerator name='ZPROP_SRC_INHERITED' value='16'/>
       <enumerator name='ZPROP_SRC_RECEIVED' value='32'/>
     </enum-decl>
     <typedef-decl name='zprop_source_t' type-id='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='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='nvlist_t' type-id='ac266fd9' id='8e8d4be3'/>
     <enum-decl name='sa_protocol' id='9155d4b5'>
       <underlying-type type-id='9cac1fee'/>
       <enumerator name='SA_PROTOCOL_NFS' value='0'/>
       <enumerator name='SA_PROTOCOL_SMB' value='1'/>
       <enumerator name='SA_PROTOCOL_COUNT' value='2'/>
     </enum-decl>
     <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='uint_t' type-id='f0981eeb' id='3502e3ff'/>
     <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='3502e3ff' id='4da03624'/>
     <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='33976309' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='64'>
         <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='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='448'>
         <var-decl name='can_be_null' type-id='f0981eeb' visibility='default'/>
       </data-member>
       <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='451'>
         <var-decl name='fastmap_accurate' type-id='f0981eeb' visibility='default'/>
       </data-member>
       <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='453'>
         <var-decl name='not_bol' type-id='f0981eeb' visibility='default'/>
       </data-member>
       <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='455'>
         <var-decl name='newline_anchor' type-id='f0981eeb' visibility='default'/>
       </data-member>
     </class-decl>
     <typedef-decl name='regex_t' type-id='19fc9a8c' id='aca3bac8'/>
     <typedef-decl name='uintptr_t' type-id='7359adad' id='e475ab95'/>
     <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='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>
     <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='size_t' type-id='7359adad' id='b59d7dce'/>
     <class-decl name='libzfs_handle' size-in-bits='18240' 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='libzfs_fd' type-id='95e97e5e' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='64'>
         <var-decl name='libzfs_pool_handles' type-id='4c81de99' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='128'>
         <var-decl name='libzfs_ns_avlpool' type-id='de82c773' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='192'>
         <var-decl name='libzfs_ns_avl' type-id='a5c21a38' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='256'>
         <var-decl name='libzfs_ns_gen' type-id='9c313c2d' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='320'>
         <var-decl name='libzfs_desc_active' type-id='95e97e5e' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='352'>
         <var-decl name='libzfs_action' type-id='b54ce520' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='8544'>
         <var-decl name='libzfs_desc' type-id='b54ce520' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='16736'>
         <var-decl name='libzfs_printerr' type-id='95e97e5e' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='16768'>
         <var-decl name='libzfs_mnttab_enable' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='16832'>
         <var-decl name='libzfs_mnttab_cache_lock' type-id='7a6844eb' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='17152'>
         <var-decl name='libzfs_mnttab_cache' type-id='f20fbd51' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='17472'>
         <var-decl name='libzfs_pool_iter' type-id='95e97e5e' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='17504'>
         <var-decl name='libzfs_prop_debug' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='17536'>
         <var-decl name='libzfs_urire' type-id='aca3bac8' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='18048'>
         <var-decl name='libzfs_max_nvlist' type-id='9c313c2d' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='18112'>
         <var-decl name='libfetch' type-id='eaa32e2f' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='18176'>
         <var-decl name='libfetch_load_error' type-id='26a90f95' 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='2816' 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='2208'>
         <var-decl name='zpool_n_propnames' type-id='f0981eeb' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='2240'>
         <var-decl name='zpool_propnames' type-id='71dc54ac' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='2496'>
         <var-decl name='zpool_config_size' type-id='b59d7dce' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='2560'>
         <var-decl name='zpool_config' type-id='5ce45b60' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='2624'>
         <var-decl name='zpool_old_config' type-id='5ce45b60' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='2688'>
         <var-decl name='zpool_props' type-id='5ce45b60' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='2752'>
         <var-decl name='zpool_start_block' type-id='804dc465' visibility='default'/>
       </data-member>
     </class-decl>
     <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='9155d4b5' const='yes' id='9f2c1699'/>
     <pointer-type-def type-id='9f2c1699' size-in-bits='64' id='4567bbc9'/>
     <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='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='b1efc708' size-in-bits='64' id='4c81de99'/>
     <pointer-type-def type-id='a2256d42' size-in-bits='64' id='debc6aa3'/>
     <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='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='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_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='uu_avl_last' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='a5c21a38'/>
       <return type-id='eaa32e2f'/>
     </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>
     <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='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_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='zfs_iter_children_v2' mangled-name='zfs_iter_children_v2' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_children_v2'>
       <parameter type-id='9200a744'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='d8e49ab9'/>
       <parameter type-id='eaa32e2f'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zfs_iter_dependents_v2' mangled-name='zfs_iter_dependents_v2' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_dependents_v2'>
       <parameter type-id='9200a744'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='c19b74c3'/>
       <parameter type-id='d8e49ab9'/>
       <parameter type-id='eaa32e2f'/>
       <return type-id='95e97e5e'/>
     </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'/>
       <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_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_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_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'/>
       <parameter type-id='9b23c9ad'/>
       <parameter type-id='4567bbc9'/>
       <return type-id='c19b74c3'/>
     </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'/>
       <parameter type-id='4567bbc9'/>
       <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'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='4567bbc9'/>
       <return type-id='95e97e5e'/>
     </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='4567bbc9'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <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>
     <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='9155d4b5'/>
       <return type-id='48b5725f'/>
     </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='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='free' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='eaa32e2f'/>
       <return type-id='48b5725f'/>
     </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>
     <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='strlen' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <return type-id='b59d7dce'/>
     </function-decl>
     <function-decl name='zfs_error' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='80f4b756'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zfs_alloc' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='b59d7dce'/>
       <return type-id='eaa32e2f'/>
     </function-decl>
     <function-decl name='remove_mountpoint' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='9200a744'/>
       <return type-id='48b5725f'/>
     </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 address-size='64' path='lib/libzfs/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='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='7359adad' id='c88f397d'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='a84c031d' size-in-bits='infinite' id='e84913bd'>
       <subrange length='infinite' type-id='7359adad' id='031f2035'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='9c313c2d' size-in-bits='128' id='c1c22e6c'>
       <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='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'/>
     <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>
       <data-member access='public' layout-offset-in-bits='128'>
         <var-decl name='nvp_name' type-id='e84913bd' visibility='default'/>
       </data-member>
     </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='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='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='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>
     <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_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'/>
     <qualified-type-def type-id='8e8d4be3' const='yes' id='693c3853'/>
     <pointer-type-def type-id='693c3853' size-in-bits='64' id='22cce67b'/>
     <qualified-type-def type-id='57928edf' const='yes' id='642ee20f'/>
     <pointer-type-def type-id='642ee20f' size-in-bits='64' id='dace003f'/>
     <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='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>
     <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_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='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'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='95e97e5e'/>
       <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_dup' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='22cce67b'/>
       <parameter type-id='857bb57e'/>
       <parameter type-id='95e97e5e'/>
       <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_exists' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='22cce67b'/>
       <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='dace003f'/>
       <return type-id='3fa542f0'/>
     </function-decl>
     <function-decl name='nvpair_name' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='dace003f'/>
       <return type-id='80f4b756'/>
     </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='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='__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='getenv' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <return type-id='26a90f95'/>
     </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='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='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='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='zfs_strdup' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='80f4b756'/>
       <return type-id='26a90f95'/>
     </function-decl>
     <function-decl name='no_memory' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zcmd_alloc_dst_nvlist' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='e4ec4540'/>
       <parameter type-id='b59d7dce'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='zcmd_expand_dst_nvlist' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='e4ec4540'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='zcmd_read_dst_nvlist' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='e4ec4540'/>
       <parameter type-id='857bb57e'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zcmd_free_nvlists' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='e4ec4540'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='make_dataset_handle' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='80f4b756'/>
       <return type-id='9200a744'/>
     </function-decl>
     <function-decl name='zpool_open_silent' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='237193c9'/>
       <return type-id='95e97e5e'/>
     </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 address-size='64' path='lib/libzfs/libzfs_crypto.c' language='LANG_C99'>
     <array-type-def dimensions='1' type-id='38b51b3c' size-in-bits='832' id='02b72c00'>
       <subrange length='13' type-id='7359adad' id='487fded1'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='fb7c6451' size-in-bits='256' id='64177143'>
       <subrange length='32' type-id='7359adad' id='ae5bde82'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='a84c031d' size-in-bits='8' id='89feb1ec'>
       <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='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='__locale_data' is-struct='yes' visibility='default' is-declaration-only='yes' id='23de8b96'/>
     <array-type-def dimensions='1' type-id='80f4b756' size-in-bits='832' id='39e6f84a'>
       <subrange length='13' type-id='7359adad' id='487fded1'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='95e97e5e' size-in-bits='896' id='47394ee0'>
       <subrange length='28' type-id='7359adad' id='3db583d7'/>
     </array-type-def>
     <type-decl name='signed char' size-in-bits='8' id='28577a57'/>
     <array-type-def dimensions='1' type-id='7359adad' size-in-bits='1024' id='d2baa450'>
       <subrange length='16' type-id='7359adad' id='848d0938'/>
     </array-type-def>
     <type-decl name='unsigned short int' size-in-bits='16' id='8efea9e5'/>
     <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_PROP_BCLONEUSED' value='33'/>
       <enumerator name='ZPOOL_PROP_BCLONESAVED' value='34'/>
       <enumerator name='ZPOOL_PROP_BCLONERATIO' value='35'/>
       <enumerator name='ZPOOL_PROP_DEDUP_TABLE_SIZE' value='36'/>
       <enumerator name='ZPOOL_PROP_DEDUP_TABLE_QUOTA' value='37'/>
       <enumerator name='ZPOOL_PROP_DEDUPCACHED' value='38'/>
       <enumerator name='ZPOOL_NUM_PROPS' value='39'/>
     </enum-decl>
     <typedef-decl name='zpool_prop_t' type-id='af1ba157' id='5d0c23fb'/>
     <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='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'/>
     <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='ac5ab595' 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='ac5ab595'>
       <data-member access='public'>
         <var-decl name='sa_handler' type-id='8cdd9566' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='sa_sigaction' type-id='6e756877' visibility='default'/>
       </data-member>
     </union-decl>
     <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='__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='__clock_t' type-id='bd54fe1a' id='4d66c6d7'/>
     <typedef-decl name='__ssize_t' type-id='bd54fe1a' id='41060289'/>
     <typedef-decl name='FILE' type-id='ec1ed955' id='aa12d1ba'/>
     <class-decl name='__locale_struct' size-in-bits='1856' is-struct='yes' visibility='default' id='90cc1ce3'>
       <data-member access='public' layout-offset-in-bits='0'>
         <var-decl name='__locales' type-id='02b72c00' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='832'>
         <var-decl name='__ctype_b' type-id='31347b7a' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='896'>
         <var-decl name='__ctype_tolower' type-id='6d60f45d' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='960'>
         <var-decl name='__ctype_toupper' type-id='6d60f45d' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='1024'>
         <var-decl name='__names' type-id='39e6f84a' visibility='default'/>
       </data-member>
     </class-decl>
     <typedef-decl name='__locale_t' type-id='f01e1813' id='b7ac9b5f'/>
     <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'/>
     <typedef-decl name='locale_t' type-id='b7ac9b5f' id='973a4f8d'/>
     <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='ac5ab596' visibility='default'/>
       </data-member>
     </class-decl>
     <union-decl name='__anonymous_union__1' size-in-bits='896' is-anonymous='yes' visibility='default' id='ac5ab596'>
       <data-member access='public'>
         <var-decl name='_pad' type-id='47394ee0' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='_kill' type-id='e7f43f73' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='_timer' type-id='e7f43f74' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='_rt' type-id='e7f43f75' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='_sigchld' type-id='e7f43f76' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='_sigfault' type-id='e7f43f77' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='_sigpoll' type-id='e7f43f78' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='_sigsys' type-id='e7f43f79' visibility='default'/>
       </data-member>
     </union-decl>
     <class-decl name='__anonymous_struct__1' size-in-bits='64' is-struct='yes' is-anonymous='yes' visibility='default' id='e7f43f73'>
       <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>
     <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='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='eabacd01' visibility='default'/>
       </data-member>
     </class-decl>
     <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='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='eabacd01' visibility='default'/>
       </data-member>
     </class-decl>
     <class-decl name='__anonymous_struct__4' 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_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='4d66c6d7' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='192'>
         <var-decl name='si_stime' type-id='4d66c6d7' 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='e7f43f77'>
       <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='ac5ab597' visibility='default'/>
       </data-member>
     </class-decl>
     <union-decl name='__anonymous_union__2' size-in-bits='128' is-anonymous='yes' visibility='default' id='ac5ab597'>
       <data-member access='public'>
         <var-decl name='_addr_bnd' type-id='e7f43f7a' 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='e7f43f7a'>
       <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='e7f43f78'>
       <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='e7f43f79'>
       <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>
     <typedef-decl name='siginfo_t' type-id='d8149419' id='cb681f62'/>
     <typedef-decl name='sigset_t' type-id='b9c97942' id='daf33c64'/>
     <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='_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>
     <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='23de8b96' size-in-bits='64' id='38b51b3c'/>
     <pointer-type-def type-id='90cc1ce3' size-in-bits='64' id='f01e1813'/>
     <qualified-type-def type-id='9b23c9ad' restrict='yes' id='8c85230f'/>
     <qualified-type-def type-id='80f4b756' restrict='yes' id='9d26089a'/>
     <pointer-type-def type-id='80f4b756' size-in-bits='64' id='7d3cd834'/>
     <qualified-type-def type-id='95e97e5e' const='yes' id='2448a865'/>
     <pointer-type-def type-id='2448a865' size-in-bits='64' id='6d60f45d'/>
     <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'/>
     <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='__locale_data' is-struct='yes' visibility='default' is-declaration-only='yes' id='23de8b96'/>
     <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_v2' mangled-name='zfs_iter_filesystems_v2' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_filesystems_v2'>
       <parameter type-id='9200a744'/>
       <parameter type-id='95e97e5e'/>
       <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_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='22cce67b'/>
       <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='22cce67b'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='7d3cd834'/>
       <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='__ctype_b_loc' visibility='default' binding='global' size-in-bits='64'>
       <return type-id='c59e1ef0'/>
     </function-decl>
     <function-decl name='dlopen' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <parameter type-id='95e97e5e'/>
       <return type-id='eaa32e2f'/>
     </function-decl>
     <function-decl name='dlsym' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='1b7446cd'/>
       <parameter type-id='9d26089a'/>
       <return type-id='eaa32e2f'/>
     </function-decl>
     <function-decl name='dlerror' visibility='default' binding='global' size-in-bits='64'>
       <return type-id='26a90f95'/>
     </function-decl>
     <function-decl name='uselocale' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='973a4f8d'/>
       <return type-id='973a4f8d'/>
     </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='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='kill' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='3629bad8'/>
       <parameter type-id='95e97e5e'/>
       <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='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='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='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='__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='rewind' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='822cd80b'/>
       <return type-id='48b5725f'/>
     </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='strdup' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <return type-id='26a90f95'/>
     </function-decl>
     <function-decl name='strerror_l' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='973a4f8d'/>
       <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='getpid' visibility='default' binding='global' size-in-bits='64'>
       <return type-id='3629bad8'/>
     </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='unlink' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='__open_too_many_args' visibility='default' binding='global' size-in-bits='64'>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='__open_missing_mode' visibility='default' binding='global' size-in-bits='64'>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='__printf_chk' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='80f4b756'/>
       <parameter is-variadic='yes'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='__asprintf_chk' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='8c85230f'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='9d26089a'/>
       <parameter is-variadic='yes'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='__fread_chk' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='1b7446cd'/>
       <parameter type-id='b59d7dce'/>
       <parameter type-id='b59d7dce'/>
       <parameter type-id='b59d7dce'/>
       <parameter type-id='e75a27e9'/>
       <return type-id='b59d7dce'/>
     </function-decl>
     <function-decl name='__read_chk' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='eaa32e2f'/>
       <parameter type-id='b59d7dce'/>
       <parameter type-id='b59d7dce'/>
       <return type-id='79a0948f'/>
     </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='80f4b756' 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='80f4b756' name='alt_keylocation'/>
       <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_error_aux' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='80f4b756'/>
       <parameter is-variadic='yes'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <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 address-size='64' path='lib/libzfs/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='7359adad' id='16fe7105'/>
     </array-type-def>
     <class-decl name='prop_changelist' is-struct='yes' visibility='default' is-declaration-only='yes' id='d86edc51'/>
     <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='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='f0981eeb' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='1'>
         <var-decl name='nounmount' type-id='f0981eeb' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='2'>
         <var-decl name='forceunmount' type-id='f0981eeb' 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_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='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>
     <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='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='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>
     <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='passwd' size-in-bits='384' is-struct='yes' visibility='default' id='a63d15a3'>
       <data-member access='public' layout-offset-in-bits='0'>
         <var-decl name='pw_name' 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'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='128'>
         <var-decl name='pw_uid' type-id='cc5fcceb' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='160'>
         <var-decl name='pw_gid' type-id='d94ec6d9' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='192'>
         <var-decl name='pw_gecos' type-id='26a90f95' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='256'>
         <var-decl name='pw_dir' type-id='26a90f95' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='320'>
         <var-decl name='pw_shell' 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='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='uid_t' type-id='cc5fcceb' id='354978ed'/>
     <typedef-decl name='prop_changelist_t' type-id='d86edc51' id='eae6431d'/>
     <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'/>
     <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'/>
     <qualified-type-def type-id='9c313c2d' const='yes' id='c3b7ba7d'/>
     <pointer-type-def type-id='c3b7ba7d' size-in-bits='64' id='713a56f5'/>
     <pointer-type-def type-id='01a1b934' size-in-bits='64' id='566b3f52'/>
     <qualified-type-def type-id='566b3f52' restrict='yes' id='c878edd6'/>
     <pointer-type-def type-id='566b3f52' size-in-bits='64' id='82d4e9e8'/>
     <qualified-type-def type-id='82d4e9e8' restrict='yes' id='aa19c230'/>
     <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'/>
     <qualified-type-def type-id='a195f4a3' restrict='yes' id='33518961'/>
     <pointer-type-def type-id='a195f4a3' size-in-bits='64' id='e80ff3ab'/>
     <qualified-type-def type-id='e80ff3ab' restrict='yes' id='8f2c7109'/>
     <pointer-type-def type-id='eae6431d' size-in-bits='64' id='0d41d328'/>
     <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'/>
     <class-decl name='prop_changelist' is-struct='yes' visibility='default' is-declaration-only='yes' id='d86edc51'/>
     <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='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_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='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_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_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='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='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='zfs_iter_snapshots_v2' mangled-name='zfs_iter_snapshots_v2' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_snapshots_v2'>
       <parameter type-id='9200a744'/>
       <parameter type-id='95e97e5e'/>
       <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='zfs_iter_bookmarks_v2' mangled-name='zfs_iter_bookmarks_v2' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_bookmarks_v2'>
       <parameter type-id='9200a744'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='d8e49ab9'/>
       <parameter type-id='eaa32e2f'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zfs_destroy_snaps_nvl_os' mangled-name='zfs_destroy_snaps_nvl_os' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_destroy_snaps_nvl_os'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='5ce45b60'/>
       <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'/>
       <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'/>
       <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'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <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='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='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='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='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='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='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='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='lzc_exists' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <return type-id='c19b74c3'/>
     </function-decl>
     <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='lzc_destroy' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <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='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_nicebytes' mangled-name='zfs_nicebytes' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_nicebytes'>
       <parameter type-id='9c313c2d'/>
       <parameter type-id='26a90f95'/>
       <parameter type-id='b59d7dce'/>
       <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'/>
       <parameter type-id='26a90f95'/>
       <parameter type-id='b59d7dce'/>
       <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_add' mangled-name='avl_add' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='avl_add'>
       <parameter type-id='a3681dea'/>
       <parameter type-id='eaa32e2f'/>
       <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'/>
       <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='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_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_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_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='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>
     <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'/>
     </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>
     <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='7d3cd834'/>
       <return type-id='95e97e5e'/>
     </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'/>
       <return type-id='c19b74c3'/>
     </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_size' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='5ce45b60'/>
       <parameter type-id='78c01427'/>
       <parameter type-id='95e97e5e'/>
       <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'/>
       <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'/>
       <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='22cce67b'/>
       <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='713a56f5'/>
       <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_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='nvlist_lookup_int64' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='22cce67b'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='cb785ebf'/>
       <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_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_empty' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='22cce67b'/>
       <return type-id='c19b74c3'/>
     </function-decl>
     <function-decl name='nvpair_type' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='dace003f'/>
       <return type-id='8d0687d2'/>
     </function-decl>
     <function-decl name='nvpair_value_uint64' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='dace003f'/>
       <parameter type-id='5d6479ae'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='nvpair_value_string' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='dace003f'/>
       <parameter type-id='7d3cd834'/>
       <return type-id='95e97e5e'/>
     </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_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_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_lookup_uint64' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='22cce67b'/>
       <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='22cce67b'/>
       <parameter type-id='80f4b756'/>
       <return type-id='80f4b756'/>
     </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>
     <function-decl name='fnvpair_value_int32' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='dace003f'/>
       <return type-id='3ff5601b'/>
     </function-decl>
     <function-decl name='fnvpair_value_uint64' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='dace003f'/>
       <return type-id='9c313c2d'/>
     </function-decl>
     <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='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='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='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='80f4b756'/>
       <parameter type-id='9155d4b5'/>
       <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'/>
       <parameter type-id='9d424d31'/>
       <parameter type-id='9d424d31'/>
       <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'/>
       <parameter type-id='9d424d31'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='getgrnam_r' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='9d26089a'/>
       <parameter type-id='c878edd6'/>
       <parameter type-id='266fe297'/>
       <parameter type-id='b59d7dce'/>
       <parameter type-id='aa19c230'/>
       <return type-id='95e97e5e'/>
     </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='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-decl name='getpwnam_r' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='9d26089a'/>
       <parameter type-id='33518961'/>
       <parameter type-id='266fe297'/>
       <parameter type-id='b59d7dce'/>
       <parameter type-id='8f2c7109'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <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='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='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='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='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='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='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-decl name='__fprintf_chk' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='e75a27e9'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='9d26089a'/>
       <parameter is-variadic='yes'/>
       <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'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <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_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='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_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='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='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='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='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='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='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='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='zfs_prop_set_list_flags' mangled-name='zfs_prop_set_list_flags' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_set_list_flags'>
       <parameter type-id='9200a744' name='zhp'/>
       <parameter type-id='5ce45b60' name='props'/>
       <parameter type-id='95e97e5e' name='flags'/>
       <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'/>
       <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='7d3cd834' 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='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_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_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='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_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_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_get_underlying_type' mangled-name='zfs_get_underlying_type' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_underlying_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'/>
       <return type-id='c19b74c3'/>
     </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'/>
       <return type-id='95e97e5e'/>
     </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'/>
       <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='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='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='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='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_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='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='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='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_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_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='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' 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='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='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='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='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='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='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='zfs_error_fmt' visibility='default' binding='global' size-in-bits='64'>
       <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_standard_error_fmt' visibility='default' binding='global' size-in-bits='64'>
       <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_setprop_error' visibility='default' binding='global' size-in-bits='64'>
       <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='zprop_parse_value' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='3fa542f0'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='2e45de5d'/>
       <parameter type-id='5ce45b60'/>
       <parameter type-id='7d3cd834'/>
       <parameter type-id='5d6479ae'/>
       <parameter type-id='80f4b756'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zprop_expand_list' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='e4378506'/>
       <parameter type-id='2e45de5d'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zcmd_write_src_nvlist' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='e4ec4540'/>
       <parameter type-id='5ce45b60'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='changelist_prefix' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='0d41d328'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='changelist_postfix' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='0d41d328'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='changelist_rename' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='0d41d328'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='80f4b756'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='changelist_remove' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='0d41d328'/>
       <parameter type-id='80f4b756'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='changelist_free' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='0d41d328'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='changelist_gather' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='9200a744'/>
       <parameter type-id='58603c44'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='95e97e5e'/>
       <return type-id='0d41d328'/>
     </function-decl>
     <function-decl name='changelist_haszonedchild' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='0d41d328'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zpool_name_valid' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='c19b74c3'/>
       <parameter type-id='80f4b756'/>
       <return type-id='c19b74c3'/>
     </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 address-size='64' path='lib/libzfs/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='7359adad' id='f8137894'/>
     </array-type-def>
     <typedef-decl name='pthread_t' type-id='7359adad' id='4051f5e7'/>
     <union-decl name='pthread_attr_t' size-in-bits='448' visibility='default' id='b63afacd'>
       <data-member access='public'>
         <var-decl name='__size' type-id='6093ff7c' 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_attr_t' type-id='b63afacd' id='7d8569fd'/>
     <class-decl name='differ_info' size-in-bits='9088' 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='no_mangle' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='8896'>
         <var-decl name='shares' type-id='9c313c2d' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='8960'>
         <var-decl name='zerr' type-id='95e97e5e' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='8992'>
         <var-decl name='cleanupfd' type-id='95e97e5e' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='9024'>
         <var-decl name='outputfd' type-id='95e97e5e' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='9056'>
         <var-decl name='datafd' type-id='95e97e5e' visibility='default'/>
       </data-member>
     </class-decl>
     <typedef-decl name='differ_info_t' type-id='d41965ee' id='e8525f0e'/>
     <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='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='color_start' mangled-name='color_start' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='color_start'>
       <parameter type-id='80f4b756'/>
       <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='pthread_create' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='cc338b26'/>
       <parameter type-id='e1815e87'/>
       <parameter type-id='5ad9edb6'/>
       <parameter type-id='1b7446cd'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <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_cancel' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='4051f5e7'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='fputs' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='9d26089a'/>
       <parameter type-id='e75a27e9'/>
       <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'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <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' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='80f4b756'/>
       <parameter is-variadic='yes'/>
       <return type-id='26a90f95'/>
     </function-decl>
     <function-decl name='zfs_validate_name' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='c19b74c3'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='find_shares_object' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='ee78f675'/>
       <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 address-size='64' path='lib/libzfs/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='7359adad' id='56f209d2'/>
     </array-type-def>
     <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_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='__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='__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>
     <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'/>
     <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' mangled-name='zpool_read_label' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_read_label'>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='857bb57e'/>
       <parameter type-id='7292109c'/>
       <return type-id='95e97e5e'/>
     </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='__pread64_chk' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='eaa32e2f'/>
       <parameter type-id='b59d7dce'/>
       <parameter type-id='724e4de6'/>
       <parameter type-id='b59d7dce'/>
       <return type-id='79a0948f'/>
     </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='zcmd_write_conf_nvlist' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='e4ec4540'/>
       <parameter type-id='5ce45b60'/>
       <return type-id='48b5725f'/>
     </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>
     <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 address-size='64' path='lib/libzfs/libzfs_iter.c' language='LANG_C99'>
     <pointer-type-def type-id='b351119f' size-in-bits='64' id='716943c7'/>
     <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='make_dataset_handle_zc' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='e4ec4540'/>
       <return type-id='9200a744'/>
     </function-decl>
     <function-decl name='make_dataset_simple_handle_zc' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='9200a744'/>
       <parameter type-id='e4ec4540'/>
       <return type-id='9200a744'/>
     </function-decl>
     <function-decl name='make_bookmark_handle' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='9200a744'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='5ce45b60'/>
       <return type-id='9200a744'/>
     </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' name='zhp'/>
       <parameter type-id='d8e49ab9' name='func'/>
       <parameter type-id='eaa32e2f' name='data'/>
       <return type-id='95e97e5e'/>
     </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' name='zhp'/>
       <parameter type-id='c19b74c3' name='simple'/>
       <parameter type-id='d8e49ab9' name='func'/>
       <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_bookmarks' mangled-name='zfs_iter_bookmarks' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_bookmarks'>
       <parameter type-id='9200a744' name='zhp'/>
       <parameter type-id='d8e49ab9' name='func'/>
       <parameter type-id='eaa32e2f' name='data'/>
       <return type-id='95e97e5e'/>
     </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_snapshots_sorted_v2' mangled-name='zfs_iter_snapshots_sorted_v2' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_snapshots_sorted_v2'>
       <parameter type-id='9200a744' name='zhp'/>
       <parameter type-id='95e97e5e' name='flags'/>
       <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='zfs_iter_snapspec_v2' mangled-name='zfs_iter_snapspec_v2' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_snapspec_v2'>
       <parameter type-id='9200a744' name='fs_zhp'/>
       <parameter type-id='95e97e5e' name='flags'/>
       <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='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' name='zhp'/>
       <parameter type-id='d8e49ab9' name='func'/>
       <parameter type-id='eaa32e2f' name='data'/>
       <return type-id='95e97e5e'/>
     </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' name='zhp'/>
       <parameter type-id='c19b74c3' name='allowrecursion'/>
       <parameter type-id='d8e49ab9' name='func'/>
       <parameter type-id='eaa32e2f' name='data'/>
       <return type-id='95e97e5e'/>
     </function-decl>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libzfs/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='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' 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='64' id='e4266c7e'>
       <subrange length='2' type-id='7359adad' id='52efc4ef'/>
     </array-type-def>
     <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='get_all_cb_t' type-id='803dac95' id='9b293607'/>
     <typedef-decl name='tpool_t' type-id='88d1b7f9' id='b1bbf10d'/>
     <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'/>
     <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>
     <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'/>
     <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'/>
     <function-decl name='zpool_disable_datasets_os' mangled-name='zpool_disable_datasets_os' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_disable_datasets_os'>
       <parameter type-id='4c81de99'/>
       <parameter type-id='c19b74c3'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='zpool_disable_volume_os' mangled-name='zpool_disable_volume_os' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_disable_volume_os'>
       <parameter type-id='80f4b756'/>
       <return type-id='48b5725f'/>
     </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='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='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_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='mkdirp' mangled-name='mkdirp' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='mkdirp'>
       <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='80f4b756'/>
     </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='9155d4b5'/>
       <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='9155d4b5'/>
       <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='9155d4b5'/>
       <return type-id='c19b74c3'/>
     </function-decl>
     <function-decl name='sa_truncate_shares' mangled-name='sa_truncate_shares' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_truncate_shares'>
       <parameter type-id='9155d4b5'/>
       <return type-id='48b5725f'/>
     </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='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='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='rmdir' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='__openat_too_many_args' visibility='default' binding='global' size-in-bits='64'>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='__openat_missing_mode' visibility='default' binding='global' size-in-bits='64'>
       <return type-id='48b5725f'/>
     </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='zfs_realloc' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='eaa32e2f'/>
       <parameter type-id='b59d7dce'/>
       <parameter type-id='b59d7dce'/>
       <return type-id='eaa32e2f'/>
     </function-decl>
     <function-decl name='changelist_unshare' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='0d41d328'/>
       <parameter type-id='4567bbc9'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='do_mount' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='9200a744'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='95e97e5e'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='do_unmount' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='9200a744'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='95e97e5e'/>
       <return type-id='95e97e5e'/>
     </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='zfs_truncate_shares' mangled-name='zfs_truncate_shares' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_truncate_shares'>
       <parameter type-id='4567bbc9' name='proto'/>
       <return type-id='48b5725f'/>
     </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'/>
       <parameter type-id='4567bbc9' 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='3502e3ff' name='nthr'/>
       <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'/>
       <parameter type-id='3502e3ff' name='nthr'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <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>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libzfs/libzfs_pool.c' language='LANG_C99'>
     <type-decl name='long long unsigned int' size-in-bits='64' id='3a47d82b'/>
     <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='f0981eeb' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='1'>
         <var-decl name='import' type-id='f0981eeb' 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'/>
     <enum-decl name='vdev_prop_t' naming-typedef-id='5aa5c90c' id='1573bec8'>
       <underlying-type type-id='9cac1fee'/>
       <enumerator name='VDEV_PROP_INVAL' value='-1'/>
       <enumerator name='VDEV_PROP_USERPROP' value='-1'/>
       <enumerator name='VDEV_PROP_NAME' value='0'/>
       <enumerator name='VDEV_PROP_CAPACITY' value='1'/>
       <enumerator name='VDEV_PROP_STATE' value='2'/>
       <enumerator name='VDEV_PROP_GUID' value='3'/>
       <enumerator name='VDEV_PROP_ASIZE' value='4'/>
       <enumerator name='VDEV_PROP_PSIZE' value='5'/>
       <enumerator name='VDEV_PROP_ASHIFT' value='6'/>
       <enumerator name='VDEV_PROP_SIZE' value='7'/>
       <enumerator name='VDEV_PROP_FREE' value='8'/>
       <enumerator name='VDEV_PROP_ALLOCATED' value='9'/>
       <enumerator name='VDEV_PROP_COMMENT' value='10'/>
       <enumerator name='VDEV_PROP_EXPANDSZ' value='11'/>
       <enumerator name='VDEV_PROP_FRAGMENTATION' value='12'/>
       <enumerator name='VDEV_PROP_BOOTSIZE' value='13'/>
       <enumerator name='VDEV_PROP_PARITY' value='14'/>
       <enumerator name='VDEV_PROP_PATH' value='15'/>
       <enumerator name='VDEV_PROP_DEVID' value='16'/>
       <enumerator name='VDEV_PROP_PHYS_PATH' value='17'/>
       <enumerator name='VDEV_PROP_ENC_PATH' value='18'/>
       <enumerator name='VDEV_PROP_FRU' value='19'/>
       <enumerator name='VDEV_PROP_PARENT' value='20'/>
       <enumerator name='VDEV_PROP_CHILDREN' value='21'/>
       <enumerator name='VDEV_PROP_NUMCHILDREN' value='22'/>
       <enumerator name='VDEV_PROP_READ_ERRORS' value='23'/>
       <enumerator name='VDEV_PROP_WRITE_ERRORS' value='24'/>
       <enumerator name='VDEV_PROP_CHECKSUM_ERRORS' value='25'/>
       <enumerator name='VDEV_PROP_INITIALIZE_ERRORS' value='26'/>
       <enumerator name='VDEV_PROP_OPS_NULL' value='27'/>
       <enumerator name='VDEV_PROP_OPS_READ' value='28'/>
       <enumerator name='VDEV_PROP_OPS_WRITE' value='29'/>
       <enumerator name='VDEV_PROP_OPS_FREE' value='30'/>
       <enumerator name='VDEV_PROP_OPS_CLAIM' value='31'/>
       <enumerator name='VDEV_PROP_OPS_TRIM' value='32'/>
       <enumerator name='VDEV_PROP_BYTES_NULL' value='33'/>
       <enumerator name='VDEV_PROP_BYTES_READ' value='34'/>
       <enumerator name='VDEV_PROP_BYTES_WRITE' value='35'/>
       <enumerator name='VDEV_PROP_BYTES_FREE' value='36'/>
       <enumerator name='VDEV_PROP_BYTES_CLAIM' value='37'/>
       <enumerator name='VDEV_PROP_BYTES_TRIM' value='38'/>
       <enumerator name='VDEV_PROP_REMOVING' value='39'/>
       <enumerator name='VDEV_PROP_ALLOCATING' value='40'/>
       <enumerator name='VDEV_PROP_FAILFAST' value='41'/>
       <enumerator name='VDEV_PROP_CHECKSUM_N' value='42'/>
       <enumerator name='VDEV_PROP_CHECKSUM_T' value='43'/>
       <enumerator name='VDEV_PROP_IO_N' value='44'/>
       <enumerator name='VDEV_PROP_IO_T' value='45'/>
       <enumerator name='VDEV_PROP_RAIDZ_EXPANDING' value='46'/>
       <enumerator name='VDEV_PROP_SLOW_IO_N' value='47'/>
       <enumerator name='VDEV_PROP_SLOW_IO_T' value='48'/>
       <enumerator name='VDEV_PROP_TRIM_SUPPORT' value='49'/>
       <enumerator name='VDEV_PROP_TRIM_ERRORS' value='50'/>
       <enumerator name='VDEV_PROP_SLOW_IOS' value='51'/>
       <enumerator name='VDEV_NUM_PROPS' value='52'/>
     </enum-decl>
     <typedef-decl name='vdev_prop_t' type-id='1573bec8' id='5aa5c90c'/>
     <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_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='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_ERRORSCRUB' value='3'/>
       <enumerator name='POOL_SCAN_FUNCS' value='4'/>
     </enum-decl>
     <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_scrub_cmd_t' type-id='a1474cbd' id='b51cf3c2'/>
     <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_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_UNINIT' value='3'/>
       <enumerator name='POOL_INITIALIZE_FUNCS' value='4'/>
     </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='zfs_ioc' id='12033f13'>
       <underlying-type type-id='9cac1fee'/>
       <enumerator name='ZFS_IOC_FIRST' value='23040'/>
       <enumerator name='ZFS_IOC' value='23040'/>
       <enumerator name='ZFS_IOC_POOL_CREATE' value='23040'/>
       <enumerator name='ZFS_IOC_POOL_DESTROY' value='23041'/>
       <enumerator name='ZFS_IOC_POOL_IMPORT' value='23042'/>
       <enumerator name='ZFS_IOC_POOL_EXPORT' value='23043'/>
       <enumerator name='ZFS_IOC_POOL_CONFIGS' value='23044'/>
       <enumerator name='ZFS_IOC_POOL_STATS' value='23045'/>
       <enumerator name='ZFS_IOC_POOL_TRYIMPORT' value='23046'/>
       <enumerator name='ZFS_IOC_POOL_SCAN' value='23047'/>
       <enumerator name='ZFS_IOC_POOL_FREEZE' value='23048'/>
       <enumerator name='ZFS_IOC_POOL_UPGRADE' value='23049'/>
       <enumerator name='ZFS_IOC_POOL_GET_HISTORY' value='23050'/>
       <enumerator name='ZFS_IOC_VDEV_ADD' value='23051'/>
       <enumerator name='ZFS_IOC_VDEV_REMOVE' value='23052'/>
       <enumerator name='ZFS_IOC_VDEV_SET_STATE' value='23053'/>
       <enumerator name='ZFS_IOC_VDEV_ATTACH' value='23054'/>
       <enumerator name='ZFS_IOC_VDEV_DETACH' value='23055'/>
       <enumerator name='ZFS_IOC_VDEV_SETPATH' value='23056'/>
       <enumerator name='ZFS_IOC_VDEV_SETFRU' value='23057'/>
       <enumerator name='ZFS_IOC_OBJSET_STATS' value='23058'/>
       <enumerator name='ZFS_IOC_OBJSET_ZPLPROPS' value='23059'/>
       <enumerator name='ZFS_IOC_DATASET_LIST_NEXT' value='23060'/>
       <enumerator name='ZFS_IOC_SNAPSHOT_LIST_NEXT' value='23061'/>
       <enumerator name='ZFS_IOC_SET_PROP' value='23062'/>
       <enumerator name='ZFS_IOC_CREATE' value='23063'/>
       <enumerator name='ZFS_IOC_DESTROY' value='23064'/>
       <enumerator name='ZFS_IOC_ROLLBACK' value='23065'/>
       <enumerator name='ZFS_IOC_RENAME' value='23066'/>
       <enumerator name='ZFS_IOC_RECV' value='23067'/>
       <enumerator name='ZFS_IOC_SEND' value='23068'/>
       <enumerator name='ZFS_IOC_INJECT_FAULT' value='23069'/>
       <enumerator name='ZFS_IOC_CLEAR_FAULT' value='23070'/>
       <enumerator name='ZFS_IOC_INJECT_LIST_NEXT' value='23071'/>
       <enumerator name='ZFS_IOC_ERROR_LOG' value='23072'/>
       <enumerator name='ZFS_IOC_CLEAR' value='23073'/>
       <enumerator name='ZFS_IOC_PROMOTE' value='23074'/>
       <enumerator name='ZFS_IOC_SNAPSHOT' value='23075'/>
       <enumerator name='ZFS_IOC_DSOBJ_TO_DSNAME' value='23076'/>
       <enumerator name='ZFS_IOC_OBJ_TO_PATH' value='23077'/>
       <enumerator name='ZFS_IOC_POOL_SET_PROPS' value='23078'/>
       <enumerator name='ZFS_IOC_POOL_GET_PROPS' value='23079'/>
       <enumerator name='ZFS_IOC_SET_FSACL' value='23080'/>
       <enumerator name='ZFS_IOC_GET_FSACL' value='23081'/>
       <enumerator name='ZFS_IOC_SHARE' value='23082'/>
       <enumerator name='ZFS_IOC_INHERIT_PROP' value='23083'/>
       <enumerator name='ZFS_IOC_SMB_ACL' value='23084'/>
       <enumerator name='ZFS_IOC_USERSPACE_ONE' value='23085'/>
       <enumerator name='ZFS_IOC_USERSPACE_MANY' value='23086'/>
       <enumerator name='ZFS_IOC_USERSPACE_UPGRADE' value='23087'/>
       <enumerator name='ZFS_IOC_HOLD' value='23088'/>
       <enumerator name='ZFS_IOC_RELEASE' value='23089'/>
       <enumerator name='ZFS_IOC_GET_HOLDS' value='23090'/>
       <enumerator name='ZFS_IOC_OBJSET_RECVD_PROPS' value='23091'/>
       <enumerator name='ZFS_IOC_VDEV_SPLIT' value='23092'/>
       <enumerator name='ZFS_IOC_NEXT_OBJ' value='23093'/>
       <enumerator name='ZFS_IOC_DIFF' value='23094'/>
       <enumerator name='ZFS_IOC_TMP_SNAPSHOT' value='23095'/>
       <enumerator name='ZFS_IOC_OBJ_TO_STATS' value='23096'/>
       <enumerator name='ZFS_IOC_SPACE_WRITTEN' value='23097'/>
       <enumerator name='ZFS_IOC_SPACE_SNAPS' value='23098'/>
       <enumerator name='ZFS_IOC_DESTROY_SNAPS' value='23099'/>
       <enumerator name='ZFS_IOC_POOL_REGUID' value='23100'/>
       <enumerator name='ZFS_IOC_POOL_REOPEN' value='23101'/>
       <enumerator name='ZFS_IOC_SEND_PROGRESS' value='23102'/>
       <enumerator name='ZFS_IOC_LOG_HISTORY' value='23103'/>
       <enumerator name='ZFS_IOC_SEND_NEW' value='23104'/>
       <enumerator name='ZFS_IOC_SEND_SPACE' value='23105'/>
       <enumerator name='ZFS_IOC_CLONE' value='23106'/>
       <enumerator name='ZFS_IOC_BOOKMARK' value='23107'/>
       <enumerator name='ZFS_IOC_GET_BOOKMARKS' value='23108'/>
       <enumerator name='ZFS_IOC_DESTROY_BOOKMARKS' value='23109'/>
       <enumerator name='ZFS_IOC_RECV_NEW' value='23110'/>
       <enumerator name='ZFS_IOC_POOL_SYNC' value='23111'/>
       <enumerator name='ZFS_IOC_CHANNEL_PROGRAM' value='23112'/>
       <enumerator name='ZFS_IOC_LOAD_KEY' value='23113'/>
       <enumerator name='ZFS_IOC_UNLOAD_KEY' value='23114'/>
       <enumerator name='ZFS_IOC_CHANGE_KEY' value='23115'/>
       <enumerator name='ZFS_IOC_REMAP' value='23116'/>
       <enumerator name='ZFS_IOC_POOL_CHECKPOINT' value='23117'/>
       <enumerator name='ZFS_IOC_POOL_DISCARD_CHECKPOINT' value='23118'/>
       <enumerator name='ZFS_IOC_POOL_INITIALIZE' value='23119'/>
       <enumerator name='ZFS_IOC_POOL_TRIM' value='23120'/>
       <enumerator name='ZFS_IOC_REDACT' value='23121'/>
       <enumerator name='ZFS_IOC_GET_BOOKMARK_PROPS' value='23122'/>
       <enumerator name='ZFS_IOC_WAIT' value='23123'/>
       <enumerator name='ZFS_IOC_WAIT_FS' value='23124'/>
       <enumerator name='ZFS_IOC_VDEV_GET_PROPS' value='23125'/>
       <enumerator name='ZFS_IOC_VDEV_SET_PROPS' value='23126'/>
       <enumerator name='ZFS_IOC_POOL_SCRUB' value='23127'/>
       <enumerator name='ZFS_IOC_POOL_PREFETCH' value='23128'/>
       <enumerator name='ZFS_IOC_DDT_PRUNE' value='23129'/>
       <enumerator name='ZFS_IOC_PLATFORM' value='23168'/>
       <enumerator name='ZFS_IOC_EVENTS_NEXT' value='23169'/>
       <enumerator name='ZFS_IOC_EVENTS_CLEAR' value='23170'/>
       <enumerator name='ZFS_IOC_EVENTS_SEEK' value='23171'/>
       <enumerator name='ZFS_IOC_NEXTBOOT' value='23172'/>
       <enumerator name='ZFS_IOC_JAIL' value='23173'/>
       <enumerator name='ZFS_IOC_USERNS_ATTACH' value='23173'/>
       <enumerator name='ZFS_IOC_UNJAIL' value='23174'/>
       <enumerator name='ZFS_IOC_USERNS_DETACH' value='23174'/>
       <enumerator name='ZFS_IOC_SET_BOOTENV' value='23175'/>
       <enumerator name='ZFS_IOC_GET_BOOTENV' value='23176'/>
       <enumerator name='ZFS_IOC_LAST' value='23177'/>
     </enum-decl>
     <typedef-decl name='zfs_ioc_t' type-id='12033f13' id='5b35941c'/>
     <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_RAIDZ_EXPAND' value='8'/>
       <enumerator name='ZPOOL_WAIT_NUM_ACTIVITIES' value='9'/>
     </enum-decl>
     <typedef-decl name='zpool_wait_activity_t' type-id='849338e3' id='73446457'/>
     <enum-decl name='zpool_prefetch_type_t' naming-typedef-id='e55ff6bc' id='0299ab50'>
       <underlying-type type-id='9cac1fee'/>
       <enumerator name='ZPOOL_PREFETCH_NONE' value='0'/>
       <enumerator name='ZPOOL_PREFETCH_DDT' value='1'/>
     </enum-decl>
     <typedef-decl name='zpool_prefetch_type_t' type-id='0299ab50' id='e55ff6bc'/>
     <enum-decl name='zpool_ddt_prune_unit_t' naming-typedef-id='02e25ab0' id='509ae11c'>
       <underlying-type type-id='9cac1fee'/>
       <enumerator name='ZPOOL_DDT_PRUNE_NONE' value='0'/>
       <enumerator name='ZPOOL_DDT_PRUNE_AGE' value='1'/>
       <enumerator name='ZPOOL_DDT_PRUNE_PERCENTAGE' value='2'/>
     </enum-decl>
     <typedef-decl name='zpool_ddt_prune_unit_t' type-id='509ae11c' id='02e25ab0'/>
     <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_FEATURE_ZILSAXATTR' value='34'/>
       <enumerator name='SPA_FEATURE_HEAD_ERRLOG' value='35'/>
       <enumerator name='SPA_FEATURE_BLAKE3' value='36'/>
       <enumerator name='SPA_FEATURE_BLOCK_CLONING' value='37'/>
       <enumerator name='SPA_FEATURE_AVZ_V2' value='38'/>
       <enumerator name='SPA_FEATURE_REDACTION_LIST_SPILL' value='39'/>
       <enumerator name='SPA_FEATURE_RAIDZ_EXPANSION' value='40'/>
       <enumerator name='SPA_FEATURE_FAST_DEDUP' value='41'/>
       <enumerator name='SPA_FEATURE_LONGNAME' value='42'/>
       <enumerator name='SPA_FEATURE_LARGE_MICROZAP' value='43'/>
       <enumerator name='SPA_FEATURES' value='44'/>
     </enum-decl>
     <typedef-decl name='spa_feature_t' type-id='33ecb627' id='d6618c78'/>
     <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='22cce67b' const='yes' id='d2816df0'/>
     <pointer-type-def type-id='d2816df0' size-in-bits='64' id='3bbfee2e'/>
     <qualified-type-def type-id='b96825af' const='yes' id='2b61797f'/>
     <pointer-type-def type-id='2b61797f' size-in-bits='64' id='9f7200cf'/>
     <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_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_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='vdev_prop_to_name' mangled-name='vdev_prop_to_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='vdev_prop_to_name'>
       <parameter type-id='5aa5c90c'/>
       <return type-id='80f4b756'/>
     </function-decl>
     <function-decl name='vdev_prop_user' mangled-name='vdev_prop_user' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='vdev_prop_user'>
       <parameter type-id='80f4b756'/>
       <return type-id='c19b74c3'/>
     </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='7d3cd834'/>
       <parameter type-id='cec6f2e4'/>
       <return type-id='d3dd6294'/>
     </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>
     <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='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='80f4b756'/>
       <return type-id='c19b74c3'/>
     </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'/>
       <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'/>
       <return type-id='95e97e5e'/>
     </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'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <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='lzc_pool_checkpoint' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <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'/>
       <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'/>
       <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'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='lzc_pool_prefetch' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <parameter type-id='e55ff6bc'/>
       <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'/>
       <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'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='lzc_get_vdev_prop' 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='lzc_set_vdev_prop' 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='lzc_scrub' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='5b35941c'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='5ce45b60'/>
       <parameter type-id='857bb57e'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='lzc_ddt_prune' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <parameter type-id='02e25ab0'/>
       <parameter type-id='9c313c2d'/>
       <return type-id='95e97e5e'/>
     </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'/>
       <parameter type-id='26a90f95'/>
       <parameter type-id='b59d7dce'/>
       <return type-id='95e97e5e'/>
     </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='80f4b756'/>
       <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='80f4b756'/>
       <return type-id='80f4b756'/>
     </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'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='95e97e5e'/>
       <return type-id='95e97e5e'/>
     </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'/>
       <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='zfs_basename' mangled-name='zfs_basename' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_basename'>
       <parameter type-id='80f4b756'/>
       <return type-id='80f4b756'/>
     </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'>
       <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'/>
     </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='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='vdev_name_to_prop' mangled-name='vdev_name_to_prop' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='vdev_name_to_prop'>
       <parameter type-id='80f4b756'/>
       <return type-id='5aa5c90c'/>
     </function-decl>
     <function-decl name='vdev_prop_default_string' mangled-name='vdev_prop_default_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='vdev_prop_default_string'>
       <parameter type-id='5aa5c90c'/>
       <return type-id='80f4b756'/>
     </function-decl>
     <function-decl name='vdev_prop_default_numeric' mangled-name='vdev_prop_default_numeric' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='vdev_prop_default_numeric'>
       <parameter type-id='5aa5c90c'/>
       <return type-id='9c313c2d'/>
     </function-decl>
     <function-decl name='vdev_prop_readonly' mangled-name='vdev_prop_readonly' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='vdev_prop_readonly'>
       <parameter type-id='5aa5c90c'/>
       <return type-id='c19b74c3'/>
     </function-decl>
     <function-decl name='vdev_prop_index_to_string' mangled-name='vdev_prop_index_to_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='vdev_prop_index_to_string'>
       <parameter type-id='5aa5c90c'/>
       <parameter type-id='9c313c2d'/>
       <parameter type-id='7d3cd834'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zpool_prop_vdev' mangled-name='zpool_prop_vdev' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_vdev'>
       <parameter type-id='80f4b756'/>
       <return type-id='c19b74c3'/>
     </function-decl>
     <function-decl name='nvlist_add_nvpair' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='5ce45b60'/>
       <parameter type-id='3fa542f0'/>
       <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='9f7200cf'/>
       <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='3bbfee2e'/>
       <parameter type-id='3502e3ff'/>
       <return type-id='95e97e5e'/>
     </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='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_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='fnvlist_add_string_array' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='5ce45b60'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='13956559'/>
       <parameter type-id='3502e3ff'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='fnvlist_add_nvlist_array' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='5ce45b60'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='3bbfee2e'/>
       <parameter type-id='3502e3ff'/>
       <return type-id='48b5725f'/>
     </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='fnvpair_value_int64' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='dace003f'/>
       <return type-id='9da381c4'/>
     </function-decl>
     <function-decl name='fnvpair_value_string' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='dace003f'/>
       <return type-id='80f4b756'/>
     </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='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='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_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='vdev_prop_get_type' mangled-name='vdev_prop_get_type' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='vdev_prop_get_type'>
       <parameter type-id='5aa5c90c'/>
       <return type-id='31429eff'/>
     </function-decl>
     <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='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='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='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='ctime_r' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='d6e2847c'/>
       <parameter type-id='266fe297'/>
       <return type-id='26a90f95'/>
     </function-decl>
     <function-decl name='__realpath_chk' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='9d26089a'/>
       <parameter type-id='266fe297'/>
       <parameter type-id='b59d7dce'/>
       <return type-id='26a90f95'/>
     </function-decl>
     <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='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='zpool_standard_error' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='80f4b756'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zpool_standard_error_fmt' visibility='default' binding='global' size-in-bits='64'>
       <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_relabel_disk' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='80f4b756'/>
       <return type-id='95e97e5e'/>
     </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'/>
       <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>
     <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_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'/>
       <return type-id='80f4b756'/>
     </function-decl>
     <function-decl name='zpool_get_userprop' mangled-name='zpool_get_userprop' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_userprop'>
       <parameter type-id='4c81de99' name='zhp'/>
       <parameter type-id='80f4b756' name='propname'/>
       <parameter type-id='26a90f95' name='buf'/>
       <parameter type-id='b59d7dce' name='len'/>
       <parameter type-id='debc6aa3' name='srctype'/>
       <return type-id='95e97e5e'/>
     </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_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='2e45de5d' name='type'/>
       <parameter type-id='c19b74c3' name='literal'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='vdev_expand_proplist' mangled-name='vdev_expand_proplist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='vdev_expand_proplist'>
       <parameter type-id='4c81de99' name='zhp'/>
       <parameter type-id='80f4b756' name='vdevname'/>
       <parameter type-id='e4378506' name='plp'/>
       <return type-id='95e97e5e'/>
     </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>
     <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='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_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'/>
       <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'/>
       <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'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zpool_prefetch' mangled-name='zpool_prefetch' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prefetch'>
       <parameter type-id='4c81de99' name='zhp'/>
       <parameter type-id='e55ff6bc' name='type'/>
       <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'/>
       <parameter type-id='c19b74c3' name='check_ashift'/>
       <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'/>
       <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'/>
       <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'/>
       <parameter type-id='26a90f95' name='buf'/>
       <parameter type-id='b59d7dce' name='size'/>
       <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_collect_unsup_feat' mangled-name='zpool_collect_unsup_feat' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_collect_unsup_feat'>
       <parameter type-id='5ce45b60' name='config'/>
       <parameter type-id='26a90f95' name='buf'/>
       <parameter type-id='b59d7dce' name='size'/>
       <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_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_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'/>
       <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'/>
       <return type-id='95e97e5e'/>
     </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'/>
       <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>
     <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='zpool_find_parent_vdev' mangled-name='zpool_find_parent_vdev' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_find_parent_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='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='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_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_vdev_remove_wanted' mangled-name='zpool_vdev_remove_wanted' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_remove_wanted'>
       <parameter type-id='4c81de99' name='zhp'/>
       <parameter type-id='80f4b756' name='path'/>
       <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'/>
       <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>
     <function-decl name='zpool_vdev_set_removed_state' mangled-name='zpool_vdev_set_removed_state' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_set_removed_state'>
       <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_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='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='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='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='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='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='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='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='zpool_set_guid' mangled-name='zpool_set_guid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_set_guid'>
       <parameter type-id='4c81de99' name='zhp'/>
       <parameter type-id='713a56f5' name='guid'/>
       <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>
     <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_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_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='zpool_add_propname' mangled-name='zpool_add_propname' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_add_propname'>
       <parameter type-id='4c81de99' name='zhp'/>
       <parameter type-id='80f4b756' name='propname'/>
       <return type-id='48b5725f'/>
     </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'/>
       <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'>
       <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='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='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='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='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='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='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'>
       <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_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='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='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='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='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_get_vdev_prop_value' mangled-name='zpool_get_vdev_prop_value' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_vdev_prop_value'>
       <parameter type-id='5ce45b60' name='nvprop'/>
       <parameter type-id='5aa5c90c' name='prop'/>
       <parameter type-id='26a90f95' name='prop_name'/>
       <parameter type-id='26a90f95' name='buf'/>
       <parameter type-id='b59d7dce' name='len'/>
       <parameter type-id='debc6aa3' name='srctype'/>
       <parameter type-id='c19b74c3' name='literal'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zpool_get_vdev_prop' mangled-name='zpool_get_vdev_prop' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_vdev_prop'>
       <parameter type-id='4c81de99' name='zhp'/>
       <parameter type-id='80f4b756' name='vdevname'/>
       <parameter type-id='5aa5c90c' name='prop'/>
       <parameter type-id='26a90f95' name='prop_name'/>
       <parameter type-id='26a90f95' name='buf'/>
       <parameter type-id='b59d7dce' name='len'/>
       <parameter type-id='debc6aa3' name='srctype'/>
       <parameter type-id='c19b74c3' name='literal'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zpool_get_all_vdev_props' mangled-name='zpool_get_all_vdev_props' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_all_vdev_props'>
       <parameter type-id='4c81de99' name='zhp'/>
       <parameter type-id='80f4b756' name='vdevname'/>
       <parameter type-id='857bb57e' name='outnvl'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zpool_set_vdev_prop' mangled-name='zpool_set_vdev_prop' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_set_vdev_prop'>
       <parameter type-id='4c81de99' name='zhp'/>
       <parameter type-id='80f4b756' name='vdevname'/>
       <parameter type-id='80f4b756' name='propname'/>
       <parameter type-id='80f4b756' name='propval'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zpool_ddt_prune' mangled-name='zpool_ddt_prune' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_ddt_prune'>
       <parameter type-id='4c81de99' name='zhp'/>
       <parameter type-id='02e25ab0' name='unit'/>
       <parameter type-id='9c313c2d' name='amount'/>
       <return type-id='95e97e5e'/>
     </function-decl>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libzfs/libzfs_sendrecv.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='95e97e5e' size-in-bits='384' id='73b82f0f'>
       <subrange length='12' type-id='7359adad' id='84827bdc'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='bd54fe1a' size-in-bits='512' id='5d4efd44'>
       <subrange length='8' type-id='7359adad' id='56e0c0b1'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='9c313c2d' size-in-bits='2176' id='8c2bcad1'>
       <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='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='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='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='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='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='7359adad' id='56e0c0b1'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='eaa32e2f' size-in-bits='256' id='209ef23f'>
       <subrange length='4' type-id='7359adad' id='16fe7105'/>
     </array-type-def>
     <class-decl name='sendflags' size-in-bits='576' 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='progressastitle' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='352'>
         <var-decl name='largeblock' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='384'>
         <var-decl name='embed_data' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='416'>
         <var-decl name='compress' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='448'>
         <var-decl name='raw' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='480'>
         <var-decl name='backup' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='512'>
         <var-decl name='holds' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='544'>
         <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'/>
     <class-decl name='recvflags' size-in-bits='448' 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>
       <data-member access='public' layout-offset-in-bits='416'>
         <var-decl name='heal' 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_t' size-in-bits='320' is-struct='yes' naming-typedef-id='67f6d2cf' visibility='default' id='5fae1718'>
       <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='5fae1718' 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='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='ac5ab598' visibility='default'/>
       </data-member>
     </class-decl>
     <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='ac5ab598'>
       <data-member access='public'>
         <var-decl name='drr_begin' type-id='09fcdc01' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='drr_end' type-id='6ee25631' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='drr_object' type-id='f9ad530b' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='drr_freeobjects' type-id='a27d958e' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='drr_write' type-id='4cc69e4b' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='drr_free' type-id='c836cfd2' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='drr_write_byref' type-id='e511cdce' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='drr_spill' type-id='1e69a80a' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='drr_write_embedded' type-id='98b1345e' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='drr_object_range' type-id='aba1f9e1' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='drr_redact' type-id='50389039' visibility='default'/>
       </data-member>
       <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>
     <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>
     <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>
     <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>
     <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>
     <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='__cancel_jmp_buf' type-id='f5da478b' visibility='default'/>
       </data-member>
       <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_unwind_buf_t' type-id='a0abc656' id='4423cf7f'/>
     <typedef-decl name='__jmp_buf' type-id='5d4efd44' id='379a1ab7'/>
     <typedef-decl name='__clockid_t' type-id='95e97e5e' id='08f9a87a'/>
     <typedef-decl name='__timer_t' type-id='eaa32e2f' id='df209b60'/>
     <typedef-decl name='clockid_t' type-id='08f9a87a' id='a1c3b834'/>
     <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='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='ac5ab599' visibility='default'/>
       </data-member>
     </class-decl>
     <union-decl name='__anonymous_union__1' size-in-bits='384' is-anonymous='yes' visibility='default' id='ac5ab599'>
       <data-member access='public'>
         <var-decl name='_pad' type-id='73b82f0f' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='_tid' type-id='3629bad8' visibility='default'/>
       </data-member>
       <data-member access='public'>
         <var-decl name='_sigev_thread' type-id='e7f43f7b' visibility='default'/>
       </data-member>
     </union-decl>
     <class-decl name='__anonymous_struct__' 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='_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>
     <class-decl name='itimerspec' size-in-bits='256' is-struct='yes' visibility='default' id='acbdbcc6'>
       <data-member access='public' layout-offset-in-bits='0'>
         <var-decl name='it_interval' type-id='a9c79a1f' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='128'>
         <var-decl name='it_value' type-id='a9c79a1f' visibility='default'/>
       </data-member>
     </class-decl>
     <typedef-decl name='timer_t' type-id='df209b60' id='b07ae406'/>
     <typedef-decl name='Byte' type-id='002ac4a6' id='efb9ba06'/>
     <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'/>
     <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='c1606520' const='yes' id='a6124a50'/>
     <pointer-type-def type-id='a6124a50' size-in-bits='64' id='e8cb3e0e'/>
     <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='781a52d7' const='yes' id='413ab2b8'/>
     <pointer-type-def type-id='413ab2b8' size-in-bits='64' id='41671bd6'/>
     <qualified-type-def type-id='acbdbcc6' const='yes' id='4ba62af7'/>
     <pointer-type-def type-id='4ba62af7' size-in-bits='64' id='f39579e7'/>
     <qualified-type-def type-id='f39579e7' restrict='yes' id='9b23e165'/>
     <pointer-type-def type-id='c70fa2e8' size-in-bits='64' id='2e711a2a'/>
     <pointer-type-def type-id='3ff5601b' size-in-bits='64' id='4aafb922'/>
     <pointer-type-def type-id='acbdbcc6' size-in-bits='64' id='116842ac'/>
     <qualified-type-def type-id='116842ac' restrict='yes' id='3d3c4cf4'/>
     <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='519bc206' size-in-bits='64' id='ef2f159c'/>
     <qualified-type-def type-id='ef2f159c' restrict='yes' id='de0eb5a4'/>
     <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='b07ae406' size-in-bits='64' id='36e89359'/>
     <qualified-type-def type-id='36e89359' restrict='yes' id='de98c2bb'/>
     <pointer-type-def type-id='a9c79a1f' size-in-bits='64' id='3d83ba87'/>
     <pointer-type-def type-id='4d39af59' size-in-bits='64' id='60db3356'/>
     <pointer-type-def type-id='f1abb096' size-in-bits='64' id='5f147c28'/>
     <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_wrapper' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='2e711a2a'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='eaa32e2f'/>
       <return type-id='95e97e5e'/>
     </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_receive_with_heal' 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='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='zfs_setproctitle' mangled-name='zfs_setproctitle' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_setproctitle'>
       <parameter type-id='80f4b756'/>
       <parameter is-variadic='yes'/>
       <return type-id='48b5725f'/>
     </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='nvlist_add_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='nvlist_lookup_boolean' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='22cce67b'/>
       <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='dace003f'/>
       <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_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='22cce67b'/>
       <parameter type-id='80f4b756'/>
       <return type-id='c19b74c3'/>
     </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='pthread_exit' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='eaa32e2f'/>
       <return type-id='48b5725f'/>
     </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_unwind_next' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='ba7c727c'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='sigaddset' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='9e80f729'/>
       <parameter type-id='95e97e5e'/>
       <return type-id='95e97e5e'/>
     </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-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='time' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b2eb2c3f'/>
       <return type-id='c9d12d66'/>
     </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='timer_create' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='a1c3b834'/>
       <parameter type-id='de0eb5a4'/>
       <parameter type-id='de98c2bb'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='timer_delete' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b07ae406'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='timer_settime' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b07ae406'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='9b23e165'/>
       <parameter type-id='3d3c4cf4'/>
       <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='pause' visibility='default' binding='global' size-in-bits='64'>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='pthread_sigmask' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='5a8729d0'/>
       <parameter type-id='65e6ec45'/>
       <return type-id='95e97e5e'/>
     </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='create_parents' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <parameter type-id='26a90f95'/>
       <parameter type-id='95e97e5e'/>
       <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-type size-in-bits='64' id='c70fa2e8'>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='eaa32e2f'/>
       <return type-id='95e97e5e'/>
     </function-type>
     <function-type size-in-bits='64' id='d2a5e211'>
       <parameter type-id='9200a744'/>
       <parameter type-id='eaa32e2f'/>
       <return type-id='c19b74c3'/>
     </function-type>
     <function-type size-in-bits='64' id='f1abb096'>
       <parameter type-id='eabacd01'/>
       <return type-id='48b5725f'/>
     </function-type>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libzfs/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='7d3cd834' name='msgid'/>
       <parameter type-id='cec6f2e4' name='errata'/>
       <return type-id='d3dd6294'/>
     </function-decl>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libzfs/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='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='7359adad' id='53010e10'/>
     </array-type-def>
     <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='vdev_cbdata' size-in-bits='192' is-struct='yes' visibility='default' id='b8006be8'>
       <data-member access='public' layout-offset-in-bits='0'>
         <var-decl name='cb_name_flags' type-id='95e97e5e' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='64'>
         <var-decl name='cb_names' type-id='9b23c9ad' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='128'>
         <var-decl name='cb_names_count' type-id='f0981eeb' visibility='default'/>
       </data-member>
     </class-decl>
     <typedef-decl name='vdev_cbdata_t' type-id='b8006be8' id='a9679c94'/>
     <class-decl name='zprop_get_cbdata' size-in-bits='960' 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='480'>
         <var-decl name='cb_json' 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>
       <data-member access='public' layout-offset-in-bits='640'>
         <var-decl name='cb_vdevs' type-id='a9679c94' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='832'>
         <var-decl name='cb_jsobj' type-id='5ce45b60' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='896'>
         <var-decl name='cb_json_as_int' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='928'>
         <var-decl name='cb_json_pool_key_guid' type-id='c19b74c3' visibility='default'/>
       </data-member>
     </class-decl>
     <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='PROP_DEFAULT' value='0'/>
       <enumerator name='PROP_READONLY' value='1'/>
       <enumerator name='PROP_INHERIT' value='2'/>
       <enumerator name='PROP_ONETIME' value='3'/>
       <enumerator name='PROP_ONETIME_DEFAULT' value='4'/>
     </enum-decl>
     <typedef-decl name='zprop_attr_t' type-id='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='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>
     <typedef-decl name='zprop_index_t' type-id='87957af9' id='64636ce3'/>
     <class-decl name='zprop_desc_t' size-in-bits='640' 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='449'>
         <var-decl name='pd_visible' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='450'>
         <var-decl name='pd_zfs_mod_supported' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='451'>
         <var-decl name='pd_always_flex' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='512'>
         <var-decl name='pd_table' type-id='c8bc397b' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='576'>
         <var-decl name='pd_table_size' type-id='b59d7dce' visibility='default'/>
       </data-member>
     </class-decl>
     <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='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>
     <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='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='nvlist_print_json' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='822cd80b'/>
       <parameter type-id='5ce45b60'/>
       <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'/>
       <parameter type-id='4c81de99'/>
       <parameter type-id='80f4b756'/>
       <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'>
       <return type-id='26a90f95'/>
     </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='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'/>
       <return type-id='26a90f95'/>
     </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='vdev_prop_init' mangled-name='vdev_prop_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='vdev_prop_init'>
       <return type-id='48b5725f'/>
     </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' mangled-name='getextmntent' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='getextmntent'>
       <parameter type-id='80f4b756'/>
       <parameter type-id='394fc496'/>
       <parameter type-id='62f7a03d'/>
       <return type-id='95e97e5e'/>
     </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='dlclose' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='eaa32e2f'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <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='regfree' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='d33f11cb'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='putc' 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='puts' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <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='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='exit' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='95e97e5e'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='strspn' 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='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='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='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='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='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='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='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='fork' visibility='default' binding='global' size-in-bits='64'>
       <return type-id='3629bad8'/>
     </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='__vfprintf_chk' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='e75a27e9'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='9d26089a'/>
       <parameter type-id='b7f2d5e6'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='__vasprintf_chk' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='8c85230f'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='9d26089a'/>
       <parameter type-id='b7f2d5e6'/>
       <return type-id='95e97e5e'/>
     </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='namespace_clear' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='b0382bb3'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='libzfs_load_module' visibility='default' binding='global' size-in-bits='64'>
       <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_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='zcmd_print_json' mangled-name='zcmd_print_json' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_print_json'>
       <parameter type-id='5ce45b60' name='nvl'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='zprop_nvlist_one_property' mangled-name='zprop_nvlist_one_property' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_nvlist_one_property'>
       <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'/>
       <parameter type-id='5ce45b60' name='nvl'/>
       <parameter type-id='c19b74c3' name='as_int'/>
       <return type-id='95e97e5e'/>
     </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='zprop_collect_property' mangled-name='zprop_collect_property' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_collect_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'/>
       <parameter type-id='5ce45b60' name='nvl'/>
       <return type-id='95e97e5e'/>
     </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'>
       <return type-id='80f4b756'/>
     </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='zfs_version_nvlist' mangled-name='zfs_version_nvlist' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_version_nvlist'>
       <return type-id='5ce45b60'/>
     </function-decl>
     <function-decl name='use_color' mangled-name='use_color' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='use_color'>
       <return type-id='95e97e5e'/>
     </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='80f4b756' name='color'/>
       <parameter type-id='80f4b756' name='format'/>
       <parameter is-variadic='yes'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zpool_vdev_script_alloc_env' mangled-name='zpool_vdev_script_alloc_env' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_script_alloc_env'>
       <parameter type-id='80f4b756' name='pool_name'/>
       <parameter type-id='80f4b756' name='vdev_path'/>
       <parameter type-id='80f4b756' name='vdev_upath'/>
       <parameter type-id='80f4b756' name='vdev_enc_sysfs_path'/>
       <parameter type-id='80f4b756' name='opt_key'/>
       <parameter type-id='80f4b756' name='opt_val'/>
       <return type-id='9b23c9ad'/>
     </function-decl>
     <function-decl name='zpool_vdev_script_free_env' mangled-name='zpool_vdev_script_free_env' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_script_free_env'>
       <parameter type-id='9b23c9ad' name='env'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='zpool_prepare_disk' mangled-name='zpool_prepare_disk' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prepare_disk'>
       <parameter type-id='4c81de99' name='zhp'/>
       <parameter type-id='5ce45b60' name='vdev_nv'/>
       <parameter type-id='80f4b756' name='prepare_str'/>
       <parameter type-id='c0563f85' name='lines'/>
       <parameter type-id='7292109c' name='lines_cnt'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zpool_prepare_and_label_disk' mangled-name='zpool_prepare_and_label_disk' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prepare_and_label_disk'>
       <parameter type-id='b0382bb3' name='hdl'/>
       <parameter type-id='4c81de99' name='zhp'/>
       <parameter type-id='80f4b756' name='name'/>
       <parameter type-id='5ce45b60' name='vdev_nv'/>
       <parameter type-id='80f4b756' name='prepare_str'/>
       <parameter type-id='c0563f85' name='lines'/>
       <parameter type-id='7292109c' name='lines_cnt'/>
       <return type-id='95e97e5e'/>
     </function-decl>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libzfs/os/linux/libzfs_mount_os.c' language='LANG_C99'>
     <pointer-type-def type-id='7359adad' size-in-bits='64' id='1d2c2b85'/>
     <function-decl name='geteuid' visibility='default' binding='global' size-in-bits='64'>
       <return type-id='cc5fcceb'/>
     </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='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='80f4b756' 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>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libzfs/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='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='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='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='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='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_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'/>
       <parameter type-id='95e97e5e'/>
       <return type-id='95e97e5e'/>
     </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='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_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'/>
       <parameter type-id='c43b27a6'/>
       <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'>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='0d8119a8'/>
       <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'/>
       <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='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'/>
       <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='fsync' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='95e97e5e'/>
       <return type-id='95e97e5e'/>
     </function-decl>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libzfs/os/linux/libzfs_util_os.c' language='LANG_C99'>
     <typedef-decl name='nfds_t' type-id='7359adad' id='555eef66'/>
     <class-decl name='pollfd' size-in-bits='64' is-struct='yes' visibility='default' id='b440e872'>
       <data-member access='public' layout-offset-in-bits='0'>
         <var-decl name='fd' type-id='95e97e5e' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='32'>
         <var-decl name='events' type-id='a2185560' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='48'>
         <var-decl name='revents' type-id='a2185560' visibility='default'/>
       </data-member>
     </class-decl>
     <pointer-type-def type-id='b440e872' size-in-bits='64' id='3ac36db0'/>
     <function-decl name='__poll_chk' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='3ac36db0'/>
       <parameter type-id='555eef66'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='7359adad'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='inotify_init1' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='95e97e5e'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='inotify_add_watch' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='8f92235e'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='timerfd_create' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='08f9a87a'/>
       <parameter type-id='95e97e5e'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='timerfd_settime' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='f39579e7'/>
       <parameter type-id='116842ac'/>
       <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>
     <function-decl name='zfs_userns' mangled-name='zfs_userns' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_userns'>
       <parameter type-id='9200a744' name='zhp'/>
       <parameter type-id='80f4b756' name='nspath'/>
       <parameter type-id='95e97e5e' name='attach'/>
       <return type-id='95e97e5e'/>
     </function-decl>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libzutil/os/linux/zutil_device_path_os.c' language='LANG_C99'>
     <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'/>
     <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='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='__readlink_chk' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='9d26089a'/>
       <parameter type-id='266fe297'/>
       <parameter type-id='b59d7dce'/>
       <parameter type-id='b59d7dce'/>
       <return type-id='79a0948f'/>
     </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='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>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libzutil/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='pool_vdev_iter_f' type-id='6c16a6c8' id='dff793e0'/>
     <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='__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'/>
     <pointer-type-def type-id='2ec2411e' size-in-bits='64' id='6c16a6c8'/>
     <pointer-type-def type-id='e7dbdca3' size-in-bits='64' id='deabd0d3'/>
     <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='for_each_vdev_in_nvlist' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='5ce45b60'/>
       <parameter type-id='dff793e0'/>
       <parameter type-id='eaa32e2f'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='label_paths' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='5507783b'/>
       <parameter type-id='5ce45b60'/>
       <parameter type-id='7d3cd834'/>
       <parameter type-id='7d3cd834'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zutil_alloc' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='5507783b'/>
       <parameter type-id='b59d7dce'/>
       <return type-id='eaa32e2f'/>
     </function-decl>
     <function-decl name='zutil_strdup' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='5507783b'/>
       <parameter type-id='80f4b756'/>
       <return type-id='26a90f95'/>
     </function-decl>
     <function-decl name='slice_cache_compare' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='eaa32e2f'/>
       <parameter type-id='eaa32e2f'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <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_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='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_iterate_end' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='f4760fa7'/>
       <return type-id='48b5725f'/>
     </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>
     <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_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='usleep' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='4e80d4b1'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <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_disk_wait' mangled-name='zpool_disk_wait' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_disk_wait'>
       <parameter type-id='80f4b756' name='path'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='update_vdev_config_dev_sysfs_path' mangled-name='update_vdev_config_dev_sysfs_path' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='update_vdev_config_dev_sysfs_path'>
       <parameter type-id='5ce45b60' name='nv'/>
       <parameter type-id='80f4b756' name='path'/>
       <parameter type-id='80f4b756' name='key'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <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>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libzutil/os/linux/zutil_setproctitle.c' language='LANG_C99'>
     <function-decl name='warnx' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <parameter is-variadic='yes'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='setenv' 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='clearenv' visibility='default' binding='global' size-in-bits='64'>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zfs_setproctitle_init' mangled-name='zfs_setproctitle_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_setproctitle_init'>
       <parameter type-id='95e97e5e' name='argc'/>
       <parameter type-id='9b23c9ad' name='argv'/>
       <parameter type-id='9b23c9ad' name='envp'/>
       <return type-id='48b5725f'/>
     </function-decl>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libzutil/zutil_device_path.c' language='LANG_C99'>
     <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_dirnamelen' mangled-name='zfs_dirnamelen' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_dirnamelen'>
       <parameter type-id='80f4b756' name='path'/>
       <return type-id='79a0948f'/>
     </function-decl>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libzutil/zutil_import.c' language='LANG_C99'>
     <array-type-def dimensions='1' type-id='a84c031d' size-in-bits='256' id='16dc656a'>
       <subrange length='32' type-id='7359adad' id='ae5bde82'/>
     </array-type-def>
     <class-decl name='importargs' size-in-bits='512' 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>
       <data-member access='public' layout-offset-in-bits='448'>
         <var-decl name='do_destroyed' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='480'>
         <var-decl name='do_all' type-id='c19b74c3' visibility='default'/>
       </data-member>
     </class-decl>
     <typedef-decl name='importargs_t' type-id='7ac83801' id='7a842a6b'/>
     <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_error' type-id='95e97e5e' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='32'>
         <var-decl name='lpc_printerr' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='64'>
         <var-decl name='lpc_open_access_error' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='96'>
         <var-decl name='lpc_desc_active' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='128'>
         <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='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>
     <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='a3681dea' size-in-bits='64' id='fce6d540'/>
     <qualified-type-def type-id='e4957c49' const='yes' id='fced9da2'/>
     <pointer-type-def type-id='fced9da2' size-in-bits='64' id='b20efd18'/>
     <pointer-type-def type-id='7a842a6b' size-in-bits='64' id='07ee4a58'/>
     <pointer-type-def type-id='8a70a786' size-in-bits='64' id='5507783b'/>
     <pointer-type-def type-id='b1e62775' size-in-bits='64' id='f095e320'/>
     <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='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='update_vdevs_config_dev_sysfs_path' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='5ce45b60'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='fnvlist_dup' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='22cce67b'/>
       <return type-id='5ce45b60'/>
     </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>
     <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='sysconf' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='95e97e5e'/>
       <return type-id='bd54fe1a'/>
     </function-decl>
     <function-decl name='libpc_error_description' mangled-name='libpc_error_description' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libpc_error_description'>
       <parameter type-id='5507783b' name='hdl'/>
       <return type-id='80f4b756'/>
     </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='5507783b' name='hdl'/>
       <parameter type-id='07ee4a58' name='import'/>
       <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='5507783b' name='hdl'/>
       <parameter type-id='80f4b756' name='target'/>
       <parameter type-id='857bb57e' name='configp'/>
       <parameter type-id='07ee4a58' name='args'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zpool_find_import_blkid' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='5507783b'/>
       <parameter type-id='18c91f9e'/>
       <parameter type-id='fce6d540'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='zpool_open_func' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='eaa32e2f'/>
       <return type-id='48b5725f'/>
     </function-decl>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libzutil/zutil_nicenum.c' language='LANG_C99'>
     <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>
     <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='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_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>
   </abi-instr>
   <abi-instr address-size='64' path='lib/libzutil/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='7359adad' id='b10be967'/>
     </array-type-def>
     <type-decl name='float' size-in-bits='32' id='a6c45d85'/>
     <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_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'/>
     <qualified-type-def type-id='a9c79a1f' const='yes' id='cd087e36'/>
     <pointer-type-def type-id='cd087e36' size-in-bits='64' id='e05e8614'/>
     <function-decl name='nanosleep' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='e05e8614'/>
       <parameter type-id='3d83ba87'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <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='fsleep' mangled-name='fsleep' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fsleep'>
       <parameter type-id='a6c45d85' name='sec'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <function-decl name='zpool_getenv_int' mangled-name='zpool_getenv_int' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_getenv_int'>
       <parameter type-id='80f4b756' name='env'/>
       <parameter type-id='95e97e5e' name='default_val'/>
       <return type-id='95e97e5e'/>
     </function-decl>
   </abi-instr>
   <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_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>
   </abi-instr>
   <abi-instr address-size='64' path='module/zcommon/cityhash.c' language='LANG_C99'>
     <function-decl name='cityhash1' mangled-name='cityhash1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='cityhash1'>
       <parameter type-id='9c313c2d' name='w'/>
       <return type-id='9c313c2d'/>
     </function-decl>
     <function-decl name='cityhash2' mangled-name='cityhash2' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='cityhash2'>
       <parameter type-id='9c313c2d' name='w1'/>
       <parameter type-id='9c313c2d' name='w2'/>
       <return type-id='9c313c2d'/>
     </function-decl>
     <function-decl name='cityhash3' mangled-name='cityhash3' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='cityhash3'>
       <parameter type-id='9c313c2d' name='w1'/>
       <parameter type-id='9c313c2d' name='w2'/>
       <parameter type-id='9c313c2d' name='w3'/>
       <return type-id='9c313c2d'/>
     </function-decl>
     <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 address-size='64' path='module/zcommon/zfeature_common.c' language='LANG_C99'>
     <array-type-def dimensions='1' type-id='83f29ca2' size-in-bits='19712' id='fd4573e5'>
       <subrange length='44' type-id='7359adad' id='cf8ba455'/>
     </array-type-def>
     <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_info_t' type-id='1178d146' id='83f29ca2'/>
     <typedef-decl name='__free_fn_t' type-id='b7f9d8e6' id='3ff5e51e'/>
     <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>
     <class-decl name='zfs_mod_supported_features' size-in-bits='128' is-struct='yes' visibility='default' id='3eee3342'>
       <data-member access='public' layout-offset-in-bits='0'>
         <var-decl name='tree' type-id='eaa32e2f' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='64'>
         <var-decl name='all_features' type-id='c19b74c3' visibility='default'/>
       </data-member>
     </class-decl>
     <qualified-type-def type-id='d6618c78' const='yes' id='81a65028'/>
     <pointer-type-def type-id='81a65028' size-in-bits='64' id='1acff326'/>
     <qualified-type-def type-id='3eee3342' const='yes' id='0c1d5bbb'/>
     <pointer-type-def type-id='0c1d5bbb' size-in-bits='64' id='a3372543'/>
     <pointer-type-def type-id='611586a1' size-in-bits='64' id='2e243169'/>
     <qualified-type-def type-id='eaa32e2f' const='yes' id='83be723c'/>
     <pointer-type-def type-id='83be723c' size-in-bits='64' id='7acd98a2'/>
     <var-decl name='spa_feature_table' type-id='fd4573e5' 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='opendir' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <return type-id='f09217ba'/>
     </function-decl>
     <function-decl name='tsearch' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='eaa32e2f'/>
       <parameter type-id='63e171df'/>
       <parameter type-id='aba7edd8'/>
       <return type-id='eaa32e2f'/>
     </function-decl>
     <function-decl name='tfind' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='eaa32e2f'/>
       <parameter type-id='7acd98a2'/>
       <parameter type-id='aba7edd8'/>
       <return type-id='eaa32e2f'/>
     </function-decl>
     <function-decl name='tdestroy' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='eaa32e2f'/>
       <parameter type-id='3ff5e51e'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <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'/>
       <parameter type-id='a3372543' name='sfeatures'/>
       <return type-id='c19b74c3'/>
     </function-decl>
   </abi-instr>
   <abi-instr address-size='64' path='module/zcommon/zfs_comutil.c' language='LANG_C99'>
     <array-type-def dimensions='1' type-id='b99c00c9' size-in-bits='2624' id='5ce15418'>
       <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='dace003f'/>
       <parameter type-id='90421557'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <var-decl name='zfs_history_event_names' type-id='5ce15418' mangled-name='zfs_history_event_names' visibility='default' elf-symbol-id='zfs_history_event_names'/>
     <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='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='80f4b756' 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>
   </abi-instr>
   <abi-instr address-size='64' path='module/zcommon/zfs_deleg.c' language='LANG_C99'>
     <array-type-def dimensions='1' type-id='fa1870fd' size-in-bits='4096' id='59e94aca'>
       <subrange length='32' type-id='7359adad' id='ae5bde82'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='fa1870fd' size-in-bits='infinite' id='7c00e69d'>
       <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_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='80f4b756' 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'/>
     <qualified-type-def type-id='f3f851ad' const='yes' id='fa1870fd'/>
     <var-decl name='zfs_deleg_perm_tab' type-id='7c00e69d' 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>
   </abi-instr>
   <abi-instr address-size='64' path='module/zcommon/zfs_fletcher.c' language='LANG_C99'>
     <array-type-def dimensions='1' type-id='9c313c2d' size-in-bits='512' id='c5d13f42'>
       <subrange length='8' type-id='7359adad' id='56e0c0b1'/>
     </array-type-def>
     <array-type-def dimensions='1' type-id='90dbb6d6' size-in-bits='2048' id='16582e69'>
       <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='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='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='7359adad' id='16fe7105'/>
     </array-type-def>
     <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_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='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_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_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_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_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='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' mangled-name='atomic_swap_32' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='atomic_swap_32'>
       <parameter type-id='3a147f31'/>
       <parameter type-id='8f92235e'/>
       <return type-id='8f92235e'/>
     </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='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>
     <function-type size-in-bits='64' id='f4a1892e'>
       <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>
   </abi-instr>
   <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='1024' 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='uses_fpu' type-id='c19b74c3' visibility='default'/>
       </data-member>
       <data-member access='public' layout-offset-in-bits='512'>
         <var-decl name='name' type-id='80f4b756' visibility='default'/>
       </data-member>
     </class-decl>
     <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 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 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 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 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 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>
   </abi-instr>
   <abi-instr address-size='64' path='module/zcommon/zfs_prop.c' language='LANG_C99'>
     <array-type-def dimensions='1' type-id='b99c00c9' size-in-bits='768' id='bcc77e38'>
       <subrange length='12' type-id='7359adad' id='84827bdc'/>
     </array-type-def>
     <pointer-type-def type-id='3eee3342' size-in-bits='64' id='73f8e240'/>
     <var-decl name='zfs_userquota_prop_prefixes' type-id='bcc77e38' mangled-name='zfs_userquota_prop_prefixes' visibility='default' elf-symbol-id='zfs_userquota_prop_prefixes'/>
     <function-decl name='zfs_mod_list_supported' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='80f4b756'/>
       <return type-id='73f8e240'/>
     </function-decl>
     <function-decl name='zfs_mod_list_supported_free' visibility='default' binding='global' size-in-bits='64'>
       <parameter type-id='73f8e240'/>
       <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'>
       <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='c19b74c3'/>
       <parameter type-id='c8bc397b'/>
       <parameter type-id='a3372543'/>
       <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'/>
       <parameter type-id='a3372543'/>
       <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'/>
       <parameter type-id='c19b74c3'/>
       <parameter type-id='a3372543'/>
       <return type-id='48b5725f'/>
     </function-decl>
     <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='9c313c2d'/>
       <parameter type-id='999701cc'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='c8bc397b'/>
       <parameter type-id='a3372543'/>
       <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'>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='31429eff'/>
       <parameter type-id='999701cc'/>
       <parameter type-id='95e97e5e'/>
       <parameter type-id='80f4b756'/>
       <parameter type-id='c19b74c3'/>
       <parameter type-id='a3372543'/>
       <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>
     <function-decl name='zprop_valid_char' mangled-name='zprop_valid_char' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_valid_char'>
       <parameter type-id='a84c031d'/>
       <return type-id='95e97e5e'/>
     </function-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 address-size='64' path='module/zcommon/zfs_valstr.c' language='LANG_C99'>
     <function-decl name='zfs_valstr_zio_flag' mangled-name='zfs_valstr_zio_flag' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_valstr_zio_flag'>
       <parameter type-id='9c313c2d' name='bits'/>
       <parameter type-id='26a90f95' name='out'/>
       <parameter type-id='b59d7dce' name='outlen'/>
       <return type-id='b59d7dce'/>
     </function-decl>
     <function-decl name='zfs_valstr_zio_flag_bits' mangled-name='zfs_valstr_zio_flag_bits' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_valstr_zio_flag_bits'>
       <parameter type-id='9c313c2d' name='bits'/>
       <parameter type-id='26a90f95' name='out'/>
       <parameter type-id='b59d7dce' name='outlen'/>
       <return type-id='b59d7dce'/>
     </function-decl>
     <function-decl name='zfs_valstr_zio_flag_pairs' mangled-name='zfs_valstr_zio_flag_pairs' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_valstr_zio_flag_pairs'>
       <parameter type-id='9c313c2d' name='bits'/>
       <parameter type-id='26a90f95' name='out'/>
       <parameter type-id='b59d7dce' name='outlen'/>
       <return type-id='b59d7dce'/>
     </function-decl>
     <function-decl name='zfs_valstr_zio_stage' mangled-name='zfs_valstr_zio_stage' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_valstr_zio_stage'>
       <parameter type-id='9c313c2d' name='bits'/>
       <parameter type-id='26a90f95' name='out'/>
       <parameter type-id='b59d7dce' name='outlen'/>
       <return type-id='b59d7dce'/>
     </function-decl>
     <function-decl name='zfs_valstr_zio_stage_bits' mangled-name='zfs_valstr_zio_stage_bits' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_valstr_zio_stage_bits'>
       <parameter type-id='9c313c2d' name='bits'/>
       <parameter type-id='26a90f95' name='out'/>
       <parameter type-id='b59d7dce' name='outlen'/>
       <return type-id='b59d7dce'/>
     </function-decl>
     <function-decl name='zfs_valstr_zio_stage_pairs' mangled-name='zfs_valstr_zio_stage_pairs' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_valstr_zio_stage_pairs'>
       <parameter type-id='9c313c2d' name='bits'/>
       <parameter type-id='26a90f95' name='out'/>
       <parameter type-id='b59d7dce' name='outlen'/>
       <return type-id='b59d7dce'/>
     </function-decl>
     <function-decl name='zfs_valstr_zio_priority' mangled-name='zfs_valstr_zio_priority' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_valstr_zio_priority'>
       <parameter type-id='95e97e5e' name='v'/>
       <parameter type-id='26a90f95' name='out'/>
       <parameter type-id='b59d7dce' name='outlen'/>
       <return type-id='b59d7dce'/>
     </function-decl>
   </abi-instr>
   <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>
     <function-decl name='vdev_prop_get_table' mangled-name='vdev_prop_get_table' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='vdev_prop_get_table'>
       <return type-id='76c8174b'/>
     </function-decl>
     <function-decl name='vdev_prop_string_to_index' mangled-name='vdev_prop_string_to_index' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='vdev_prop_string_to_index'>
       <parameter type-id='5aa5c90c' name='prop'/>
       <parameter type-id='80f4b756' name='string'/>
       <parameter type-id='5d6479ae' name='index'/>
       <return type-id='95e97e5e'/>
     </function-decl>
     <function-decl name='vdev_prop_random_value' mangled-name='vdev_prop_random_value' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='vdev_prop_random_value'>
       <parameter type-id='5aa5c90c' name='prop'/>
       <parameter type-id='9c313c2d' name='seed'/>
       <return type-id='9c313c2d'/>
     </function-decl>
     <function-decl name='vdev_prop_values' mangled-name='vdev_prop_values' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='vdev_prop_values'>
       <parameter type-id='5aa5c90c' name='prop'/>
       <return type-id='80f4b756'/>
     </function-decl>
     <function-decl name='vdev_prop_column_name' mangled-name='vdev_prop_column_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='vdev_prop_column_name'>
       <parameter type-id='5aa5c90c' name='prop'/>
       <return type-id='80f4b756'/>
     </function-decl>
     <function-decl name='vdev_prop_align_right' mangled-name='vdev_prop_align_right' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='vdev_prop_align_right'>
       <parameter type-id='5aa5c90c' name='prop'/>
       <return type-id='c19b74c3'/>
     </function-decl>
   </abi-instr>
   <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>
   </abi-instr>
 </abi-corpus>
diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_pool.c b/sys/contrib/openzfs/lib/libzfs/libzfs_pool.c
index 14410b153130..44f2c6f19dff 100644
--- a/sys/contrib/openzfs/lib/libzfs/libzfs_pool.c
+++ b/sys/contrib/openzfs/lib/libzfs/libzfs_pool.c
@@ -1,5679 +1,5679 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 
 /*
  * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2011, 2024 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>
  * Copyright (c) 2021, 2023, Klara Inc.
  */
 
 #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 {
 	unsigned int create:1;	/* Validate property on creation */
 	unsigned int import:1;	/* Validate property on import */
 	unsigned int vdevprop:1; /* Validate property as a VDEV property */
 } 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 (zhp->zpool_n_propnames > 0) {
 		nvlist_t *innvl = fnvlist_alloc();
 		fnvlist_add_string_array(innvl, ZPOOL_GET_PROPS_NAMES,
 		    zhp->zpool_propnames, zhp->zpool_n_propnames);
 		zcmd_write_src_nvlist(hdl, &zc, innvl);
 	}
 
 	zcmd_alloc_dst_nvlist(hdl, &zc, 0);
 
 	while (zfs_ioctl(hdl, ZFS_IOC_POOL_GET_PROPS, &zc) != 0) {
 		if (errno == ENOMEM)
 			zcmd_expand_dst_nvlist(hdl, &zc);
 		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;
 	const char *value;
 	zprop_source_t source;
 
 	nvl = zhp->zpool_props;
 	if (nvlist_lookup_nvlist(nvl, zpool_prop_to_name(prop), &nv) == 0) {
 		source = fnvlist_lookup_uint64(nv, ZPROP_SOURCE);
 		value = fnvlist_lookup_string(nv, ZPROP_VALUE);
 	} else {
 		source = ZPROP_SRC_DEFAULT;
 		if ((value = 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) {
 		source = fnvlist_lookup_uint64(nv, ZPROP_SOURCE);
 		value = fnvlist_lookup_uint64(nv, ZPROP_VALUE);
 	} 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;
 	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_CONTINUE ||
 	    status == ZPOOL_STATUS_IO_FAILURE_MMP) {
 		str = gettext("SUSPENDED");
 	} else {
 		nvlist_t *nvroot = fnvlist_lookup_nvlist(
 		    zpool_get_config(zhp, NULL), ZPOOL_CONFIG_VDEV_TREE);
 		uint_t vsc;
 		vdev_stat_t *vs = (vdev_stat_t *)fnvlist_lookup_uint64_array(
 		    nvroot, ZPOOL_CONFIG_VDEV_STATS, &vsc);
 		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;
 			}
 			zfs_fallthrough;
 		default:
 			(void) strlcpy(buf, "-", len);
 			break;
 		}
 
 		if (srctype != NULL)
 			*srctype = src;
 		return (0);
 	}
 
 	/*
 	 * ZPOOL_PROP_DEDUPCACHED can be fetched by name only using
 	 * the ZPOOL_GET_PROPS_NAMES mechanism
 	 */
 	if (prop == ZPOOL_PROP_DEDUPCACHED) {
 		zpool_add_propname(zhp, ZPOOL_DEDUPCACHED_PROP_NAME);
 		(void) zpool_get_all_props(zhp);
 	}
 
 	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_DEDUP_TABLE_QUOTA:
 			/*
 			 * If dedup quota is 0, we translate this into 'none'
 			 * (unless literal is set). And if it is UINT64_MAX
 			 * we translate that as 'automatic' (limit to size of
 			 * the dedicated dedup VDEV.  Otherwise, fall throught
 			 * into the regular number formating.
 			 */
 			if (intval == 0) {
 				(void) strlcpy(buf, literal ? "0" : "none",
 				    len);
 				break;
 			} else if (intval == UINT64_MAX) {
 				(void) strlcpy(buf, "auto", len);
 				break;
 			}
 			zfs_fallthrough;
 
 		case ZPOOL_PROP_SIZE:
 		case ZPOOL_PROP_ALLOCATED:
 		case ZPOOL_PROP_FREE:
 		case ZPOOL_PROP_FREEING:
 		case ZPOOL_PROP_LEAKED:
 		case ZPOOL_PROP_ASHIFT:
 		case ZPOOL_PROP_MAXBLOCKSIZE:
 		case ZPOOL_PROP_MAXDNODESIZE:
 		case ZPOOL_PROP_BCLONESAVED:
 		case ZPOOL_PROP_BCLONEUSED:
 		case ZPOOL_PROP_DEDUP_TABLE_SIZE:
 		case ZPOOL_PROP_DEDUPCACHED:
 			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_BCLONERATIO:
 		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;
 			}
 			zfs_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);
 }
 
 /*
  * Get a zpool property value for 'propname' and return the value in
  * a pre-allocated buffer.
  */
 int
 zpool_get_userprop(zpool_handle_t *zhp, const char *propname, char *buf,
     size_t len, zprop_source_t *srctype)
 {
 	nvlist_t *nv, *nvl;
 	uint64_t ival;
 	const char *value;
 	zprop_source_t source = ZPROP_SRC_LOCAL;
 
 	nvl = zhp->zpool_props;
 	if (nvlist_lookup_nvlist(nvl, propname, &nv) == 0) {
 		if (nvlist_lookup_uint64(nv, ZPROP_SOURCE, &ival) == 0)
 			source = ival;
 		verify(nvlist_lookup_string(nv, ZPROP_VALUE, &value) == 0);
 	} else {
 		source = ZPROP_SRC_DEFAULT;
 		value = "-";
 	}
 
 	if (srctype)
 		*srctype = source;
 
 	(void) strlcpy(buf, value, len);
 
 	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;
 	const char *strval;
 	uint64_t intval;
 	const char *check;
 	struct stat64 statbuf;
 	zpool_handle_t *zhp;
 	char *parent, *slash;
 	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);
 
 		if (flags.vdevprop && zpool_prop_vdev(propname)) {
 			vdev_prop_t vprop = vdev_name_to_prop(propname);
 
 			if (vdev_prop_readonly(vprop)) {
 				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, vprop, ZFS_TYPE_VDEV,
 			    retprops, &strval, &intval, errbuf) != 0)
 				goto error;
 
 			continue;
 		} else if (flags.vdevprop && vdev_prop_user(propname)) {
 			if (nvlist_add_nvpair(retprops, elem) != 0) {
 				(void) no_memory(hdl);
 				goto error;
 			}
 			continue;
 		} else if (flags.vdevprop) {
 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 			    "invalid property: '%s'"), propname);
 			(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
 			goto error;
 		}
 
 		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;
 		} else if (prop == ZPOOL_PROP_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 (strlen(strval) >= ZFS_MAXPROPLEN) {
 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 				    "property value '%s' is too long"),
 				    strval);
 				(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
 				goto error;
 			}
 
 			if (nvlist_add_string(retprops, propname,
 			    strval) != 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;
 			}
 
 			parent = strdup(strval);
 			if (parent == NULL) {
 				(void) zfs_error(hdl, EZFS_NOMEM, errbuf);
 				goto error;
 			}
 			slash = strrchr(parent, '/');
 
 			if (slash[1] == '\0' || strcmp(slash, "/.") == 0 ||
 			    strcmp(slash, "/..") == 0) {
 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 				    "'%s' is not a valid file"), parent);
 				(void) zfs_error(hdl, EZFS_BADPATH, errbuf);
 				free(parent);
 				goto error;
 			}
 
 			*slash = '\0';
 
 			if (parent[0] != '\0' &&
 			    (stat64(parent, &statbuf) != 0 ||
 			    !S_ISDIR(statbuf.st_mode))) {
 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 				    "'%s' is not a valid directory"),
 				    parent);
 				(void) zfs_error(hdl, EZFS_BADPATH, errbuf);
 				free(parent);
 				goto error;
 			}
 			free(parent);
 
 			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[ERRBUFLEN];
 	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));
 
 	zcmd_write_src_nvlist(zhp->zpool_hdl, &zc, nvl);
 
 	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,
     zfs_type_t type, 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, type) != 0)
 		return (-1);
 
 	if (type == ZFS_TYPE_VDEV)
 		return (0);
 
 	last = plp;
 	while (*last != NULL)
 		last = &(*last)->pl_next;
 
 	if ((*plp)->pl_all)
 		features = zpool_get_features(zhp);
 
 	if ((*plp)->pl_all && firstexpand) {
 		/* Handle userprops in the all properties case */
 		if (zhp->zpool_props == NULL && zpool_props_refresh(zhp))
 			return (-1);
 
 		nvp = NULL;
 		while ((nvp = nvlist_next_nvpair(zhp->zpool_props, nvp)) !=
 		    NULL) {
 			const char *propname = nvpair_name(nvp);
 
 			if (!zfs_prop_user(propname))
 				continue;
 
 			entry = zfs_alloc(hdl, sizeof (zprop_list_t));
 			entry->pl_prop = ZPROP_USERPROP;
 			entry->pl_user_prop = zfs_strdup(hdl, propname);
 			entry->pl_width = strlen(entry->pl_user_prop);
 			entry->pl_all = B_TRUE;
 
 			*last = entry;
 			last = &entry->pl_next;
 		}
 
 		for (i = 0; i < SPA_FEATURES; i++) {
 			entry = zfs_alloc(hdl, sizeof (zprop_list_t));
 			entry->pl_prop = ZPROP_USERPROP;
 			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;
 
 		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_USERPROP;
 		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_USERPROP &&
 		    zpool_get_prop(zhp, entry->pl_prop, buf, sizeof (buf),
 		    NULL, literal) == 0) {
 			if (strlen(buf) > entry->pl_width)
 				entry->pl_width = strlen(buf);
 		} else if (entry->pl_prop == ZPROP_INVAL &&
 		    zfs_prop_user(entry->pl_user_prop) &&
 		    zpool_get_userprop(zhp, entry->pl_user_prop, buf,
 		    sizeof (buf), NULL) == 0) {
 			if (strlen(buf) > entry->pl_width)
 				entry->pl_width = strlen(buf);
 		}
 	}
 
 	return (0);
 }
 
 int
 vdev_expand_proplist(zpool_handle_t *zhp, const char *vdevname,
     zprop_list_t **plp)
 {
 	zprop_list_t *entry;
 	char buf[ZFS_MAXPROPLEN];
 	const char *strval = NULL;
 	int err = 0;
 	nvpair_t *elem = NULL;
 	nvlist_t *vprops = NULL;
 	nvlist_t *propval = NULL;
 	const char *propname;
 	vdev_prop_t prop;
 	zprop_list_t **last;
 
 	for (entry = *plp; entry != NULL; entry = entry->pl_next) {
 		if (entry->pl_fixed)
 			continue;
 
 		if (zpool_get_vdev_prop(zhp, vdevname, entry->pl_prop,
 		    entry->pl_user_prop, buf, sizeof (buf), NULL,
 		    B_FALSE) == 0) {
 			if (strlen(buf) > entry->pl_width)
 				entry->pl_width = strlen(buf);
 		}
 		if (entry->pl_prop == VDEV_PROP_NAME &&
 		    strlen(vdevname) > entry->pl_width)
 			entry->pl_width = strlen(vdevname);
 	}
 
 	/* Handle the all properties case */
 	last = plp;
 	if (*last != NULL && (*last)->pl_all == B_TRUE) {
 		while (*last != NULL)
 			last = &(*last)->pl_next;
 
 		err = zpool_get_all_vdev_props(zhp, vdevname, &vprops);
 		if (err != 0)
 			return (err);
 
 		while ((elem = nvlist_next_nvpair(vprops, elem)) != NULL) {
 			propname = nvpair_name(elem);
 
 			/* Skip properties that are not user defined */
 			if ((prop = vdev_name_to_prop(propname)) !=
 			    VDEV_PROP_USERPROP)
 				continue;
 
 			if (nvpair_value_nvlist(elem, &propval) != 0)
 				continue;
 
 			strval = fnvlist_lookup_string(propval, ZPROP_VALUE);
 
 			entry = zfs_alloc(zhp->zpool_hdl,
 			    sizeof (zprop_list_t));
 			entry->pl_prop = prop;
 			entry->pl_user_prop = zfs_strdup(zhp->zpool_hdl,
 			    propname);
 			entry->pl_width = strlen(strval);
 			entry->pl_all = B_TRUE;
 			*last = entry;
 			last = &entry->pl_next;
 		}
 	}
 
 	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);
 	}
 
 	zhp = zfs_alloc(hdl, sizeof (zpool_handle_t));
 
 	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;
 
 	zhp = zfs_alloc(hdl, sizeof (zpool_handle_t));
 
 	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++) {
 			const 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++) {
 			const 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 errbuf[ERRBUFLEN];
 	int ret = -1;
 
 	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
 	    "cannot create '%s'"), pool);
 
 	if (!zpool_name_valid(hdl, B_FALSE, pool))
 		return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
 
 	zcmd_write_conf_nvlist(hdl, &zc, nvroot);
 
 	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, errbuf)) == NULL) {
 			goto create_failed;
 		}
 	}
 
 	if (fsprops) {
 		uint64_t zoned;
 		const 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, errbuf)) == 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, errbuf);
 			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, errbuf);
 			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);
 
 	(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, errbuf));
 
 		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, errbuf));
 
 		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, errbuf));
 
 		case ENOSPC:
 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 			    "one or more devices is out of space"));
 			return (zfs_error(hdl, EZFS_BADDEV, errbuf));
 
 		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, errbuf));
 			} else {
 				return (zpool_standard_error(hdl, errno,
 				    errbuf));
 			}
 
 		default:
 			return (zpool_standard_error(hdl, errno, errbuf));
 		}
 	}
 
 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 errbuf[ERRBUFLEN];
 
 	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(errbuf, sizeof (errbuf), 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, errbuf);
 		} else {
 			(void) zpool_standard_error(hdl, errno, errbuf);
 		}
 
 		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 errbuf[ERRBUFLEN];
 	int error;
 
 	error = lzc_pool_checkpoint(zhp->zpool_name);
 	if (error != 0) {
 		(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
 		    "cannot checkpoint '%s'"), zhp->zpool_name);
 		(void) zpool_standard_error(hdl, error, errbuf);
 		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 errbuf[ERRBUFLEN];
 	int error;
 
 	error = lzc_pool_checkpoint_discard(zhp->zpool_name);
 	if (error != 0) {
 		(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
 		    "cannot discard checkpoint in '%s'"), zhp->zpool_name);
 		(void) zpool_standard_error(hdl, error, errbuf);
 		return (-1);
 	}
 
 	return (0);
 }
 
 /*
  * Load data type for the given pool.
  */
 int
 zpool_prefetch(zpool_handle_t *zhp, zpool_prefetch_type_t type)
 {
 	libzfs_handle_t *hdl = zhp->zpool_hdl;
 	char msg[1024];
 	int error;
 
 	error = lzc_pool_prefetch(zhp->zpool_name, type);
 	if (error != 0) {
 		(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
 		    "cannot prefetch %s in '%s'"),
 		    type == ZPOOL_PREFETCH_DDT ? "ddt" : "", 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, boolean_t check_ashift)
 {
 	zfs_cmd_t zc = {"\0"};
 	int ret;
 	libzfs_handle_t *hdl = zhp->zpool_hdl;
 	char errbuf[ERRBUFLEN];
 	nvlist_t **spares, **l2cache;
 	uint_t nspares, nl2cache;
 
 	(void) snprintf(errbuf, sizeof (errbuf), 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, errbuf));
 	}
 
 	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, errbuf));
 	}
 
 	zcmd_write_conf_nvlist(hdl, &zc, nvroot);
 	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
 	zc.zc_flags = check_ashift;
 
 	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, errbuf);
 			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, errbuf);
 			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, errbuf);
 			break;
 
 		case ENOTSUP:
 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 			    "pool must be upgraded to add these vdevs"));
 			(void) zfs_error(hdl, EZFS_BADVERSION, errbuf);
 			break;
 
 		default:
 			(void) zpool_standard_error(hdl, errno, errbuf);
 		}
 
 		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 &&
 	    ctime_r((time_t *)&rewindto, timestr) != NULL) {
 		timestr[24] = 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, char *buf, size_t size)
 {
 	nvlist_t *nv = NULL;
 	int64_t loss = -1;
 	uint64_t edata = UINT64_MAX;
 	uint64_t rewindto;
 	struct tm t;
 	char timestr[128], temp[1024];
 
 	if (!hdl->libzfs_printerr)
 		return;
 
 	/* 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) snprintf(buf, size, dgettext(TEXT_DOMAIN,
 	    "Recovery is possible, but will result in some data loss.\n"));
 
 	if (localtime_r((time_t *)&rewindto, &t) != NULL &&
 	    ctime_r((time_t *)&rewindto, timestr) != NULL) {
 		timestr[24] = 0;
 		(void) snprintf(temp, 1024, dgettext(TEXT_DOMAIN,
 		    "\tReturning the pool to its state as of %s\n"
 		    "\tshould correct the problem.  "), timestr);
 		(void) strlcat(buf, temp, size);
 	} else {
 		(void) strlcat(buf, dgettext(TEXT_DOMAIN,
 		    "\tReverting the pool to an earlier state "
 		    "should correct the problem.\n\t"), size);
 	}
 
 	if (loss > 120) {
 		(void) snprintf(temp, 1024, dgettext(TEXT_DOMAIN,
 		    "Approximately %lld minutes of data\n"
 		    "\tmust be discarded, irreversibly.  "),
 		    ((longlong_t)loss + 30) / 60);
 		(void) strlcat(buf, temp, size);
 	} else if (loss > 0) {
 		(void) snprintf(temp, 1024, dgettext(TEXT_DOMAIN,
 		    "Approximately %lld seconds of data\n"
 		    "\tmust be discarded, irreversibly.  "),
 		    (longlong_t)loss);
 		(void) strlcat(buf, temp, size);
 	}
 	if (edata != 0 && edata != UINT64_MAX) {
 		if (edata == 1) {
 			(void) strlcat(buf, dgettext(TEXT_DOMAIN,
 			    "After rewind, at least\n"
 			    "\tone persistent user-data error will remain.  "),
 			    size);
 		} else {
 			(void) strlcat(buf, dgettext(TEXT_DOMAIN,
 			    "After rewind, several\n"
 			    "\tpersistent user-data errors will remain.  "),
 			    size);
 		}
 	}
 	(void) snprintf(temp, 1024, dgettext(TEXT_DOMAIN,
 	    "Recovery can be attempted\n\tby executing 'zpool %s -F %s'.  "),
 	    reason >= 0 ? "clear" : "import", name);
 	(void) strlcat(buf, temp, size);
 
 	(void) strlcat(buf, dgettext(TEXT_DOMAIN,
 	    "A scrub of the pool\n"
 	    "\tis strongly recommended after recovery.\n"), size);
 	return;
 
 no_info:
 	(void) strlcat(buf, dgettext(TEXT_DOMAIN,
 	    "Destroy and re-create the pool from\n\ta backup source.\n"), size);
 }
 
 /*
  * 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_collect_unsup_feat(nvlist_t *config, char *buf, size_t size)
 {
 	nvlist_t *nvinfo, *unsup_feat;
 	char temp[512];
 
 	nvinfo = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO);
 	unsup_feat = fnvlist_lookup_nvlist(nvinfo, ZPOOL_CONFIG_UNSUP_FEAT);
 
 	for (nvpair_t *nvp = nvlist_next_nvpair(unsup_feat, NULL);
 	    nvp != NULL; nvp = nvlist_next_nvpair(unsup_feat, nvp)) {
 		const char *desc = fnvpair_value_string(nvp);
 		if (strlen(desc) > 0) {
 			(void) snprintf(temp, 512, "\t%s (%s)\n",
 			    nvpair_name(nvp), desc);
 			(void) strlcat(buf, temp, size);
 		} else {
 			(void) snprintf(temp, 512, "\t%s\n", nvpair_name(nvp));
 			(void) strlcat(buf, temp, size);
 		}
 	}
 }
 
 /*
  * 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;
 	const char *thename;
 	const char *origname;
 	int ret;
 	int error = 0;
 	char buf[2048];
 	char errbuf[ERRBUFLEN];
 
 	origname = fnvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME);
 
 	(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 = newname;
 	} else {
 		thename = origname;
 	}
 
 	if (props != NULL) {
 		uint64_t version;
 		prop_flags_t flags = { .create = B_FALSE, .import = B_TRUE };
 
 		version = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION);
 
 		if ((props = zpool_valid_proplist(hdl, origname,
 		    props, version, flags, errbuf)) == NULL)
 			return (-1);
 		zcmd_write_src_nvlist(hdl, &zc, props);
 		nvlist_free(props);
 	}
 
 	(void) strlcpy(zc.zc_name, thename, sizeof (zc.zc_name));
 
 	zc.zc_guid = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID);
 
 	zcmd_write_conf_nvlist(hdl, &zc, config);
 	zcmd_alloc_dst_nvlist(hdl, &zc, zc.zc_nvlist_conf_size * 2);
 
 	zc.zc_cookie = flags;
 	while ((ret = zfs_ioctl(hdl, ZFS_IOC_POOL_IMPORT, &zc)) != 0 &&
 	    errno == ENOMEM)
 		zcmd_expand_dst_nvlist(hdl, &zc);
 	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"));
 				memset(buf, 0, 2048);
 				zpool_collect_unsup_feat(nv, buf, 2048);
 				(void) printf("%s", buf);
 				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) {
 				const 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);
 			memset(buf, 0, 2048);
 			zpool_explain_recover(hdl,
 			    newname ? origname : thename, -error, nv,
 			    buf, 2048);
 			(void) printf("\t%s", buf);
 			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 (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;
 
 		const 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, cancel, or uninit (clear) 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 && nvlist_lookup_nvlist(errlist,
 		    ZPOOL_INITIALIZE_VDEVS, &vd_errlist) == 0) {
 			goto list_errors;
 		}
 
 		if (err == EINVAL && cmd_type == POOL_INITIALIZE_UNINIT) {
 			zfs_error_aux(zhp->zpool_hdl, dgettext(TEXT_DOMAIN,
 			    "uninitialize is not supported by kernel"));
 		}
 
 		(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));
 		const 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));
 		const 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 errbuf[ERRBUFLEN];
 
 			(void) snprintf(errbuf, sizeof (errbuf),
 			    dgettext(TEXT_DOMAIN, "operation failed"));
 			zpool_standard_error(zhp->zpool_hdl, err, errbuf);
 			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)
 {
 	char errbuf[ERRBUFLEN];
 	int err;
 	libzfs_handle_t *hdl = zhp->zpool_hdl;
 
 	nvlist_t *args = fnvlist_alloc();
 	fnvlist_add_uint64(args, "scan_type", (uint64_t)func);
 	fnvlist_add_uint64(args, "scan_command", (uint64_t)cmd);
 
 	err = lzc_scrub(ZFS_IOC_POOL_SCRUB, zhp->zpool_name, args, NULL);
 	fnvlist_free(args);
 
 	if (err == 0) {
 		return (0);
 	} else if (err == ZFS_ERR_IOC_CMD_UNAVAIL) {
 		zfs_cmd_t zc = {"\0"};
 		(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);
 	}
 
 	/*
 	 * An ECANCELED on a scrub means one of the following:
 	 * 1. we resumed a paused scrub.
 	 * 2. we resumed a paused error scrub.
 	 * 3. Error scrub is not run because of no error log.
 	 */
 	if (err == ECANCELED && (func == POOL_SCAN_SCRUB ||
 	    func == POOL_SCAN_ERRORSCRUB) && cmd == POOL_SCRUB_NORMAL)
 		return (0);
 	/*
 	 * The following cases have been handled here:
 	 * 1. Paused a scrub/error scrub if there is none in progress.
 	 */
 	if (err == ENOENT && func != POOL_SCAN_NONE && cmd ==
 	    POOL_SCRUB_PAUSE) {
 		return (0);
 	}
 
 	ASSERT3U(func, >=, POOL_SCAN_NONE);
 	ASSERT3U(func, <, POOL_SCAN_FUNCS);
 
 	if (func == POOL_SCAN_SCRUB || func == POOL_SCAN_ERRORSCRUB) {
 		if (cmd == POOL_SCRUB_PAUSE) {
 			(void) snprintf(errbuf, sizeof (errbuf),
 			    dgettext(TEXT_DOMAIN, "cannot pause scrubbing %s"),
 			    zhp->zpool_name);
 		} else {
 			assert(cmd == POOL_SCRUB_NORMAL);
 			(void) snprintf(errbuf, sizeof (errbuf),
 			    dgettext(TEXT_DOMAIN, "cannot scrub %s"),
 			    zhp->zpool_name);
 		}
 	} else if (func == POOL_SCAN_RESILVER) {
 		assert(cmd == POOL_SCRUB_NORMAL);
 		(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
 		    "cannot restart resilver on %s"), zhp->zpool_name);
 	} else if (func == POOL_SCAN_NONE) {
 		(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
 		    "cannot cancel scrubbing %s"), zhp->zpool_name);
 	} else {
 		assert(!"unexpected result");
 	}
 
 	/*
-	 * With EBUSY, five cases are possible:
+	 * With EBUSY, six cases are possible:
 	 *
 	 * Current state		Requested
 	 * 1. Normal Scrub Running	Normal Scrub or Error Scrub
 	 * 2. Normal Scrub Paused	Error Scrub
 	 * 3. Normal Scrub Paused 	Pause Normal Scrub
 	 * 4. Error Scrub Running	Normal Scrub or Error Scrub
 	 * 5. Error Scrub Paused	Pause Error Scrub
 	 * 6. Resilvering		Anything else
 	 */
 	if (err == EBUSY) {
 		nvlist_t *nvroot;
 		pool_scan_stat_t *ps = NULL;
 		uint_t psc;
 
 		nvroot = fnvlist_lookup_nvlist(zhp->zpool_config,
 		    ZPOOL_CONFIG_VDEV_TREE);
 		(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 (ps->pss_pass_scrub_pause == 0) {
 				/* handles case 1 */
 				assert(cmd == POOL_SCRUB_NORMAL);
 				return (zfs_error(hdl, EZFS_SCRUBBING,
 				    errbuf));
 			} else {
 				if (func == POOL_SCAN_ERRORSCRUB) {
 					/* handles case 2 */
 					ASSERT3U(cmd, ==, POOL_SCRUB_NORMAL);
 					return (zfs_error(hdl,
 					    EZFS_SCRUB_PAUSED_TO_CANCEL,
 					    errbuf));
 				} else {
 					/* handles case 3 */
 					ASSERT3U(func, ==, POOL_SCAN_SCRUB);
 					ASSERT3U(cmd, ==, POOL_SCRUB_PAUSE);
 					return (zfs_error(hdl,
 					    EZFS_SCRUB_PAUSED, errbuf));
 				}
 			}
 		} else if (ps &&
 		    ps->pss_error_scrub_func == POOL_SCAN_ERRORSCRUB &&
 		    ps->pss_error_scrub_state == DSS_ERRORSCRUBBING) {
 			if (ps->pss_pass_error_scrub_pause == 0) {
 				/* handles case 4 */
 				ASSERT3U(cmd, ==, POOL_SCRUB_NORMAL);
 				return (zfs_error(hdl, EZFS_ERRORSCRUBBING,
 				    errbuf));
 			} else {
 				/* handles case 5 */
 				ASSERT3U(func, ==, POOL_SCAN_ERRORSCRUB);
 				ASSERT3U(cmd, ==, POOL_SCRUB_PAUSE);
 				return (zfs_error(hdl, EZFS_ERRORSCRUB_PAUSED,
 				    errbuf));
 			}
 		} else {
 			/* handles case 6 */
 			return (zfs_error(hdl, EZFS_RESILVERING, errbuf));
 		}
 	} else if (err == ENOENT) {
 		return (zfs_error(hdl, EZFS_NO_SCRUB, errbuf));
 	} else if (err == ENOTSUP && func == POOL_SCAN_RESILVER) {
 		return (zfs_error(hdl, EZFS_NO_RESILVER_DEFER, errbuf));
 	} else {
 		return (zpool_standard_error(hdl, err, errbuf));
 	}
 }
 
 /*
  * 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.
  *
  * If 'return_parent' is set, then return the *parent* of the vdev you're
  * searching for rather than the vdev itself.
  */
 static nvlist_t *
 vdev_to_nvlist_iter(nvlist_t *nv, nvlist_t *search, boolean_t *avail_spare,
     boolean_t *l2cache, boolean_t *log, boolean_t return_parent)
 {
 	uint_t c, children;
 	nvlist_t **child;
 	nvlist_t *ret;
 	uint64_t is_log;
 	const char *srchkey;
 	nvpair_t *pair = nvlist_next_nvpair(search, NULL);
 	const char *tmp = NULL;
 	boolean_t is_root;
 
 	/* Nothing to look for */
 	if (search == NULL || pair == NULL)
 		return (NULL);
 
 	/* Obtain the key we will use to search */
 	srchkey = nvpair_name(pair);
 
 	nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &tmp);
 	if (strcmp(tmp, "root") == 0)
 		is_root = B_TRUE;
 	else
 		is_root = B_FALSE;
 
 	switch (nvpair_type(pair)) {
 	case DATA_TYPE_UINT64:
 		if (strcmp(srchkey, ZPOOL_CONFIG_GUID) == 0) {
 			uint64_t srchval = fnvpair_value_uint64(pair);
 			uint64_t theguid = fnvlist_lookup_uint64(nv,
 			    ZPOOL_CONFIG_GUID);
 			if (theguid == srchval)
 				return (nv);
 		}
 		break;
 
 	case DATA_TYPE_STRING: {
 		const char *srchval, *val;
 
 		srchval = fnvpair_value_string(pair);
 		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) {
 			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));
 
 			id = fnvlist_lookup_uint64(nv, ZPOOL_CONFIG_ID);
 			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);
 				}
 				vdev_parity = fnvlist_lookup_uint64(nv,
 				    ZPOOL_CONFIG_NPARITY);
 				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, return_parent)) != 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 && return_parent && !is_root ? nv : 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, return_parent))
 			    != NULL) {
 				*avail_spare = B_TRUE;
 				return (ret && return_parent &&
 				    !is_root ? nv : 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, return_parent))
 			    != NULL) {
 				*l2cache = B_TRUE;
 				return (ret && return_parent &&
 				    !is_root ? nv : 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;
 
 	search = fnvlist_alloc();
 
 	guid = strtoull(ppath, &end, 0);
 	if (guid != 0 && *end == '\0') {
 		fnvlist_add_uint64(search, ZPOOL_CONFIG_GUID, guid);
 	} else {
 		fnvlist_add_string(search, ZPOOL_CONFIG_PHYS_PATH, ppath);
 	}
 
 	nvroot = fnvlist_lookup_nvlist(zhp->zpool_config,
 	    ZPOOL_CONFIG_VDEV_TREE);
 
 	*avail_spare = B_FALSE;
 	*l2cache = B_FALSE;
 	if (log != NULL)
 		*log = B_FALSE;
 	ret = vdev_to_nvlist_iter(nvroot, search, avail_spare, l2cache, log,
 	    B_FALSE);
 	fnvlist_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_ROOT, strlen(VDEV_TYPE_ROOT)) == 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);
 }
 
 /*
  * Lookup the nvlist for a given vdev or vdev's parent (depending on
  * if 'return_parent' is set).
  */
 static nvlist_t *
 __zpool_find_vdev(zpool_handle_t *zhp, const char *path, boolean_t *avail_spare,
     boolean_t *l2cache, boolean_t *log, boolean_t return_parent)
 {
 	char *end;
 	nvlist_t *nvroot, *search, *ret;
 	uint64_t guid;
 	boolean_t __avail_spare, __l2cache, __log;
 
 	search = fnvlist_alloc();
 
 	guid = strtoull(path, &end, 0);
 	if (guid != 0 && *end == '\0') {
 		fnvlist_add_uint64(search, ZPOOL_CONFIG_GUID, guid);
 	} else if (zpool_vdev_is_interior(path)) {
 		fnvlist_add_string(search, ZPOOL_CONFIG_TYPE, path);
 	} else {
 		fnvlist_add_string(search, ZPOOL_CONFIG_PATH, path);
 	}
 
 	nvroot = fnvlist_lookup_nvlist(zhp->zpool_config,
 	    ZPOOL_CONFIG_VDEV_TREE);
 
 	/*
 	 * User can pass NULL for avail_spare, l2cache, and log, but
 	 * we still need to provide variables to vdev_to_nvlist_iter(), so
 	 * just point them to junk variables here.
 	 */
 	if (!avail_spare)
 		avail_spare = &__avail_spare;
 	if (!l2cache)
 		l2cache = &__l2cache;
 	if (!log)
 		log = &__log;
 
 	*avail_spare = B_FALSE;
 	*l2cache = B_FALSE;
 	if (log != NULL)
 		*log = B_FALSE;
 	ret = vdev_to_nvlist_iter(nvroot, search, avail_spare, l2cache, log,
 	    return_parent);
 	fnvlist_free(search);
 
 	return (ret);
 }
 
 nvlist_t *
 zpool_find_vdev(zpool_handle_t *zhp, const char *path, boolean_t *avail_spare,
     boolean_t *l2cache, boolean_t *log)
 {
 	return (__zpool_find_vdev(zhp, path, avail_spare, l2cache, log,
 	    B_FALSE));
 }
 
 /* Given a vdev path, return its parent's nvlist */
 nvlist_t *
 zpool_find_parent_vdev(zpool_handle_t *zhp, const char *path,
     boolean_t *avail_spare, boolean_t *l2cache, boolean_t *log)
 {
 	return (__zpool_find_vdev(zhp, path, avail_spare, l2cache, log,
 	    B_TRUE));
 }
 
 /*
  * 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)
 {
 	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);
 
 	if (is_spare != NULL)
 		*is_spare = spare;
 	if (is_l2cache != NULL)
 		*is_l2cache = l2cache;
 	if (is_log != NULL)
 		*is_log = log;
 
 	return (fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_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 errbuf[ERRBUFLEN];
 	nvlist_t *tgt;
 	boolean_t avail_spare, l2cache, islog;
 	libzfs_handle_t *hdl = zhp->zpool_hdl;
 
 	if (flags & ZFS_ONLINE_EXPAND) {
 		(void) snprintf(errbuf, sizeof (errbuf),
 		    dgettext(TEXT_DOMAIN, "cannot expand %s"), path);
 	} else {
 		(void) snprintf(errbuf, sizeof (errbuf),
 		    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, errbuf));
 
 	zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID);
 
 	if (!(flags & ZFS_ONLINE_SPARE) && avail_spare)
 		return (zfs_error(hdl, EZFS_ISSPARE, errbuf));
 
 #ifndef __FreeBSD__
 	const char *pathname;
 	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, errbuf));
 		}
 
 		if (wholedisk) {
 			const char *fullpath = path;
 			char buf[MAXPATHLEN];
 			int error;
 
 			if (path[0] != '/') {
 				error = zfs_resolve_shortname(path, buf,
 				    sizeof (buf));
 				if (error != 0)
 					return (zfs_error(hdl, EZFS_NODEVICE,
 					    errbuf));
 
 				fullpath = buf;
 			}
 
 			error = zpool_relabel_disk(hdl, fullpath, errbuf);
 			if (error != 0)
 				return (error);
 		}
 	}
 #endif
 
 	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, errbuf));
 		}
 		return (zpool_standard_error(hdl, errno, errbuf));
 	}
 
 	*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 errbuf[ERRBUFLEN];
 	nvlist_t *tgt;
 	boolean_t avail_spare, l2cache;
 	libzfs_handle_t *hdl = zhp->zpool_hdl;
 
 	(void) snprintf(errbuf, sizeof (errbuf),
 	    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, errbuf));
 
 	zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID);
 
 	if (avail_spare)
 		return (zfs_error(hdl, EZFS_ISSPARE, errbuf));
 
 	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, errbuf));
 
 	case EEXIST:
 		/*
 		 * The log device has unplayed logs
 		 */
 		return (zfs_error(hdl, EZFS_UNPLAYED_LOGS, errbuf));
 
 	default:
 		return (zpool_standard_error(hdl, errno, errbuf));
 	}
 }
 
 /*
  * Remove the specified vdev asynchronously from the configuration, so
  * that it may come ONLINE if reinserted. This is called from zed on
  * Udev remove event.
  * Note: We also have a similar function zpool_vdev_remove() that
  * removes the vdev from the pool.
  */
 int
 zpool_vdev_remove_wanted(zpool_handle_t *zhp, const char *path)
 {
 	zfs_cmd_t zc = {"\0"};
 	char errbuf[ERRBUFLEN];
 	nvlist_t *tgt;
 	boolean_t avail_spare, l2cache;
 	libzfs_handle_t *hdl = zhp->zpool_hdl;
 
 	(void) snprintf(errbuf, sizeof (errbuf),
 	    dgettext(TEXT_DOMAIN, "cannot remove %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, errbuf));
 
 	zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID);
 
 	zc.zc_cookie = VDEV_STATE_REMOVED;
 
 	if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SET_STATE, &zc) == 0)
 		return (0);
 
 	return (zpool_standard_error(hdl, errno, errbuf));
 }
 
 /*
  * 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 errbuf[ERRBUFLEN];
 	libzfs_handle_t *hdl = zhp->zpool_hdl;
 
 	(void) snprintf(errbuf, sizeof (errbuf),
 	    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, errbuf));
 
 	default:
 		return (zpool_standard_error(hdl, errno, errbuf));
 	}
 
 }
 
 /*
  * Generic set vdev state function
  */
 static int
 zpool_vdev_set_state(zpool_handle_t *zhp, uint64_t guid, vdev_aux_t aux,
     vdev_state_t state)
 {
 	zfs_cmd_t zc = {"\0"};
 	char errbuf[ERRBUFLEN];
 	libzfs_handle_t *hdl = zhp->zpool_hdl;
 
 	(void) snprintf(errbuf, sizeof (errbuf),
 	    dgettext(TEXT_DOMAIN, "cannot set %s %llu"),
 	    zpool_state_to_name(state, aux), (u_longlong_t)guid);
 
 	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
 	zc.zc_guid = guid;
 	zc.zc_cookie = state;
 	zc.zc_obj = aux;
 
 	if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SET_STATE, &zc) == 0)
 		return (0);
 
 	return (zpool_standard_error(hdl, errno, errbuf));
 }
 
 /*
  * Mark the given vdev degraded.
  */
 int
 zpool_vdev_degrade(zpool_handle_t *zhp, uint64_t guid, vdev_aux_t aux)
 {
 	return (zpool_vdev_set_state(zhp, guid, aux, VDEV_STATE_DEGRADED));
 }
 
 /*
  * Mark the given vdev as in a removed state (as if the device does not exist).
  *
  * This is different than zpool_vdev_remove() which does a removal of a device
  * from the pool (but the device does exist).
  */
 int
 zpool_vdev_set_removed_state(zpool_handle_t *zhp, uint64_t guid, vdev_aux_t aux)
 {
 	return (zpool_vdev_set_state(zhp, guid, aux, VDEV_STATE_REMOVED));
 }
 
 /*
  * 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;
 
 	if (nvlist_lookup_nvlist_array(search, ZPOOL_CONFIG_CHILDREN, &child,
 	    &children) == 0) {
 		const char *type = fnvlist_lookup_string(search,
 		    ZPOOL_CONFIG_TYPE);
 		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 errbuf[ERRBUFLEN];
 	int ret;
 	nvlist_t *tgt;
 	boolean_t avail_spare, l2cache, islog;
 	uint64_t val;
 	char *newname;
 	const char *type;
 	nvlist_t **child;
 	uint_t children;
 	nvlist_t *config_root;
 	libzfs_handle_t *hdl = zhp->zpool_hdl;
 
 	if (replacing)
 		(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
 		    "cannot replace %s with %s"), old_disk, new_disk);
 	else
 		(void) snprintf(errbuf, sizeof (errbuf), 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, errbuf));
 
 	if (avail_spare)
 		return (zfs_error(hdl, EZFS_ISSPARE, errbuf));
 
 	if (l2cache)
 		return (zfs_error(hdl, EZFS_ISL2CACHE, errbuf));
 
 	zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID);
 	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, errbuf));
 	}
 
 	type = fnvlist_lookup_string(tgt, ZPOOL_CONFIG_TYPE);
 	if (strcmp(type, VDEV_TYPE_RAIDZ) == 0 &&
 	    zfeature_lookup_guid("org.openzfs:raidz_expansion", NULL) != 0) {
 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 		    "the loaded zfs module doesn't support raidz expansion"));
 		return (zfs_error(hdl, EZFS_POOL_NOTSUP, errbuf));
 	}
 
 	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, errbuf));
 	}
 
 	config_root = fnvlist_lookup_nvlist(zpool_get_config(zhp, NULL),
 	    ZPOOL_CONFIG_VDEV_TREE);
 
 	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, errbuf));
 	}
 
 	free(newname);
 
 	zcmd_write_conf_nvlist(hdl, &zc, nvroot);
 
 	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 if (strcmp(type, VDEV_TYPE_RAIDZ) == 0) {
 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 			    "raidz_expansion feature must be enabled "
 			    "in order to attach a device to raidz"));
 		} else {
 			char status[64] = {0};
 			zpool_prop_get_feature(zhp,
 			    "feature@device_rebuild", status, 63);
 			if (rebuild &&
 			    strncmp(status, ZFS_FEATURE_DISABLED, 64) == 0) {
 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 				    "device_rebuild feature must be enabled "
 				    "in order to use sequential "
 				    "reconstruction"));
 			} else {
 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 				    "can only attach to mirrors and top-level "
 				    "disks"));
 			}
 		}
 		(void) zfs_error(hdl, EZFS_BADTARGET, errbuf);
 		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, errbuf);
 		break;
 
 	case EBUSY:
 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "%s is busy"),
 		    new_disk);
 		(void) zfs_error(hdl, EZFS_BADDEV, errbuf);
 		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, errbuf);
 		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, errbuf);
 		break;
 
 	case ENAMETOOLONG:
 		/*
 		 * The resulting top-level vdev spec won't fit in the label.
 		 */
 		(void) zfs_error(hdl, EZFS_DEVOVERFLOW, errbuf);
 		break;
 
 	case ENXIO:
 		/*
 		 * The existing raidz vdev has offline children
 		 */
 		if (strcmp(type, VDEV_TYPE_RAIDZ) == 0) {
 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 			    "raidz vdev has devices that are are offline or "
 			    "being replaced"));
 			(void) zfs_error(hdl, EZFS_BADDEV, errbuf);
 			break;
 		} else {
 			(void) zpool_standard_error(hdl, errno, errbuf);
 		}
 		break;
 
 	case EADDRINUSE:
 		/*
 		 * The boot reserved area is already being used (FreeBSD)
 		 */
 		if (strcmp(type, VDEV_TYPE_RAIDZ) == 0) {
 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 			    "the reserved boot area needed for the expansion "
 			    "is already being used by a boot loader"));
 			(void) zfs_error(hdl, EZFS_BADDEV, errbuf);
 		} else {
 			(void) zpool_standard_error(hdl, errno, errbuf);
 		}
 		break;
 
 	case ZFS_ERR_ASHIFT_MISMATCH:
 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 		    "The new device cannot have a higher alignment requirement "
 		    "than the top-level vdev."));
 		(void) zfs_error(hdl, EZFS_BADTARGET, errbuf);
 		break;
 	default:
 		(void) zpool_standard_error(hdl, errno, errbuf);
 	}
 
 	return (-1);
 }
 
 /*
  * Detach the specified device.
  */
 int
 zpool_vdev_detach(zpool_handle_t *zhp, const char *path)
 {
 	zfs_cmd_t zc = {"\0"};
 	char errbuf[ERRBUFLEN];
 	nvlist_t *tgt;
 	boolean_t avail_spare, l2cache;
 	libzfs_handle_t *hdl = zhp->zpool_hdl;
 
 	(void) snprintf(errbuf, sizeof (errbuf),
 	    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, errbuf));
 
 	if (avail_spare)
 		return (zfs_error(hdl, EZFS_ISSPARE, errbuf));
 
 	if (l2cache)
 		return (zfs_error(hdl, EZFS_ISL2CACHE, errbuf));
 
 	zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID);
 
 	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, errbuf);
 		break;
 
 	case EBUSY:
 		/*
 		 * There are no other replicas of this device.
 		 */
 		(void) zfs_error(hdl, EZFS_NOREPLICAS, errbuf);
 		break;
 
 	default:
 		(void) zpool_standard_error(hdl, errno, errbuf);
 	}
 
 	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 errbuf[ERRBUFLEN];
 	const char *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(errbuf, sizeof (errbuf),
 	    dgettext(TEXT_DOMAIN, "Unable to split %s"), zhp->zpool_name);
 
 	if (!zpool_name_valid(hdl, B_FALSE, newname))
 		return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
 
 	if ((config = zpool_get_config(zhp, NULL)) == NULL) {
 		(void) fprintf(stderr, gettext("Internal error: unable to "
 		    "retrieve pool configuration\n"));
 		return (-1);
 	}
 
 	tree = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE);
 	vers = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION);
 
 	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, errbuf)) == 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;
 		const 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;
 		type = fnvlist_lookup_string(child[c], ZPOOL_CONFIG_TYPE);
 
 		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, errbuf);
 			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, errbuf);
 		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,
 	    (const nvlist_t **)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));
 	zcmd_write_conf_nvlist(hdl, &zc, newconfig);
 	if (zc_props != NULL)
 		zcmd_write_src_nvlist(hdl, &zc, zc_props);
 
 	if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SPLIT, &zc) != 0) {
 		retval = zpool_standard_error(hdl, errno, errbuf);
 		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 errbuf[ERRBUFLEN];
 	nvlist_t *tgt;
 	boolean_t avail_spare, l2cache, islog;
 	libzfs_handle_t *hdl = zhp->zpool_hdl;
 	uint64_t version;
 
 	(void) snprintf(errbuf, sizeof (errbuf),
 	    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, errbuf));
 	}
 
 	(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, errbuf));
 
 	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, errbuf));
 	}
 
 	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 EALREADY:
 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 		    "removal for this vdev is already in progress."));
 		(void) zfs_error(hdl, EZFS_BUSY, errbuf);
 		break;
 
 	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, errbuf);
 		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, errbuf);
 		break;
 
 	case EACCES:
 		if (islog) {
 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 			    "Mount encrypted datasets to replay logs."));
 			(void) zfs_error(hdl, EZFS_BUSY, errbuf);
 		} else {
 			(void) zpool_standard_error(hdl, errno, errbuf);
 		}
 		break;
 
 	default:
 		(void) zpool_standard_error(hdl, errno, errbuf);
 	}
 	return (-1);
 }
 
 int
 zpool_vdev_remove_cancel(zpool_handle_t *zhp)
 {
 	zfs_cmd_t zc = {{0}};
 	char errbuf[ERRBUFLEN];
 	libzfs_handle_t *hdl = zhp->zpool_hdl;
 
 	(void) snprintf(errbuf, sizeof (errbuf),
 	    dgettext(TEXT_DOMAIN, "cannot cancel removal"));
 
 	(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, errbuf));
 }
 
 int
 zpool_vdev_indirect_size(zpool_handle_t *zhp, const char *path,
     uint64_t *sizep)
 {
 	char errbuf[ERRBUFLEN];
 	nvlist_t *tgt;
 	boolean_t avail_spare, l2cache, islog;
 	libzfs_handle_t *hdl = zhp->zpool_hdl;
 
 	(void) snprintf(errbuf, sizeof (errbuf),
 	    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, errbuf));
 
 	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, errbuf));
 	}
 	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 errbuf[ERRBUFLEN];
 	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(errbuf, sizeof (errbuf),
 		    dgettext(TEXT_DOMAIN, "cannot clear errors for %s"),
 		    path);
 	else
 		(void) snprintf(errbuf, sizeof (errbuf),
 		    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, errbuf));
 
 		/*
 		 * Don't allow error clearing for hot spares.  Do allow
 		 * error clearing for l2cache devices.
 		 */
 		if (avail_spare)
 			return (zfs_error(hdl, EZFS_ISSPARE, errbuf));
 
 		zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID);
 	}
 
 	zpool_get_load_policy(rewindnvl, &policy);
 	zc.zc_cookie = policy.zlp_rewind;
 
 	zcmd_alloc_dst_nvlist(hdl, &zc, zhp->zpool_config_size * 2);
 	zcmd_write_src_nvlist(hdl, &zc, rewindnvl);
 
 	while ((error = zfs_ioctl(hdl, ZFS_IOC_CLEAR, &zc)) != 0 &&
 	    errno == ENOMEM)
 		zcmd_expand_dst_nvlist(hdl, &zc);
 
 	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, errbuf));
 }
 
 /*
  * 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 errbuf[ERRBUFLEN];
 	libzfs_handle_t *hdl = zhp->zpool_hdl;
 
 	(void) snprintf(errbuf, sizeof (errbuf),
 	    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, errbuf));
 }
 
 /*
  * Change the GUID for a pool.
  *
  * Similar to zpool_reguid(), but may take a GUID.
  *
  * If the guid argument is NULL, then no GUID is passed in the nvlist to the
  * ioctl().
  */
 int
 zpool_set_guid(zpool_handle_t *zhp, const uint64_t *guid)
 {
 	char errbuf[ERRBUFLEN];
 	libzfs_handle_t *hdl = zhp->zpool_hdl;
 	nvlist_t *nvl = NULL;
 	zfs_cmd_t zc = {"\0"};
 	int error = -1;
 
 	if (guid != NULL) {
 		if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
 			return (no_memory(hdl));
 
 		if (nvlist_add_uint64(nvl, ZPOOL_REGUID_GUID, *guid) != 0) {
 			nvlist_free(nvl);
 			return (no_memory(hdl));
 		}
 
 		zcmd_write_src_nvlist(hdl, &zc, nvl);
 	}
 
 	(void) snprintf(errbuf, sizeof (errbuf),
 	    dgettext(TEXT_DOMAIN, "cannot reguid '%s'"), zhp->zpool_name);
 
 	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
 	error = zfs_ioctl(hdl, ZFS_IOC_POOL_REGUID, &zc);
 	if (error) {
 		return (zpool_standard_error(hdl, errno, errbuf));
 	}
 	if (guid != NULL) {
 		zcmd_free_nvlists(&zc);
 		nvlist_free(nvl);
 	}
 	return (0);
 }
 
 /*
  * Change the GUID for a pool.
  */
 int
 zpool_reguid(zpool_handle_t *zhp)
 {
 	return (zpool_set_guid(zhp, NULL));
 }
 
 /*
  * 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)
 {
 	const char *type, *tpath;
 	const char *path;
 	uint64_t value;
 	char buf[PATH_BUF_LEN];
 	char tmpbuf[PATH_BUF_LEN * 2];
 
 	/*
 	 * vdev_name will be "root"/"root-0" for the root vdev, but it is the
 	 * zpool name that will be displayed to the user.
 	 */
 	type = fnvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE);
 	if (zhp != NULL && strcmp(type, "root") == 0)
 		return (zfs_strdup(hdl, zpool_get_name(zhp)));
 
 	if (libzfs_envvar_is_set("ZPOOL_VDEV_NAME_PATH"))
 		name_flags |= VDEV_NAME_PATH;
 	if (libzfs_envvar_is_set("ZPOOL_VDEV_NAME_GUID"))
 		name_flags |= VDEV_NAME_GUID;
 	if (libzfs_envvar_is_set("ZPOOL_VDEV_NAME_FOLLOW_LINKS"))
 		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, &tpath) == 0) {
 		path = tpath;
 
 		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) {
 			value = fnvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY);
 			(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);
 			nparity = fnvlist_lookup_uint64(nv,
 			    ZPOOL_CONFIG_NPARITY);
 			ndata = fnvlist_lookup_uint64(nv,
 			    ZPOOL_CONFIG_DRAID_NDATA);
 			nspares = fnvlist_lookup_uint64(nv,
 			    ZPOOL_CONFIG_DRAID_NSPARES);
 
 			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 = fnvlist_lookup_uint64(nv,
 			    ZPOOL_CONFIG_ID);
 			(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)));
 }
 
 void
 zpool_add_propname(zpool_handle_t *zhp, const char *propname)
 {
 	assert(zhp->zpool_n_propnames < ZHP_MAX_PROPNAMES);
 	zhp->zpool_propnames[zhp->zpool_n_propnames] = propname;
 	zhp->zpool_n_propnames++;
 }
 
 /*
  * 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;
 	zbookmark_phys_t *buf;
 	uint64_t buflen = 10000; /* approx. 1MB of RAM */
 
 	if (fnvlist_lookup_uint64(zhp->zpool_config,
 	    ZPOOL_CONFIG_ERRCOUNT) == 0)
 		return (0);
 
 	/*
 	 * Retrieve the raw error list from the kernel.  If it doesn't fit,
 	 * allocate a larger buffer and retry.
 	 */
 	(void) strcpy(zc.zc_name, zhp->zpool_name);
 	for (;;) {
 		buf = zfs_alloc(zhp->zpool_hdl,
 		    buflen * sizeof (zbookmark_phys_t));
 		zc.zc_nvlist_dst = (uintptr_t)buf;
 		zc.zc_nvlist_dst_size = buflen;
 		if (zfs_ioctl(zhp->zpool_hdl, ZFS_IOC_ERROR_LOG,
 		    &zc) != 0) {
 			free(buf);
 			if (errno == ENOMEM) {
 				buflen *= 2;
 			} 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.
 	 */
 	zbookmark_phys_t *zb = buf + zc.zc_nvlist_dst_size;
 	uint64_t zblen = buflen - zc.zc_nvlist_dst_size;
 
 	qsort(zb, zblen, 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 (uint64_t i = 0; i < zblen; 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(buf);
 	return (0);
 
 nomem:
 	free(buf);
 	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, zfs_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;
 
 	args = fnvlist_alloc();
 	fnvlist_add_string(args, "message", message);
 	zcmd_write_src_nvlist(hdl, &zc, args);
 	int 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)
 {
 	libzfs_handle_t *hdl = zhp->zpool_hdl;
 	char *buf;
 	int buflen = 128 * 1024;
 	nvlist_t **records = NULL;
 	uint_t numrecords = 0;
 	int err = 0, i;
 	uint64_t start = *off;
 
 	buf = zfs_alloc(hdl, buflen);
 
 	/* process about 1MiB 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) {
 			zpool_standard_error_fmt(hdl, err,
 			    dgettext(TEXT_DOMAIN,
 			    "cannot get history for '%s'"), zhp->zpool_name);
 			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 = zfs_alloc(hdl, buflen);
 		}
 	}
 
 	free(buf);
 
 	if (!err) {
 		*nvhisp = fnvlist_alloc();
 		fnvlist_add_nvlist_array(*nvhisp, ZPOOL_HIST_RECORD,
 		    (const nvlist_t **)records, numrecords);
 	}
 	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;
 
 	zcmd_alloc_dst_nvlist(hdl, &zc, ZEVENT_SIZE);
 
 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:
 			zcmd_expand_dst_nvlist(hdl, &zc);
 			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[ZFS_MAXPROPLEN] = "";
 	char err_badtoken[ZFS_MAXPROPLEN] = "";
 
 	/*
 	 * 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);
 }
 
 static int
 zpool_vdev_guid(zpool_handle_t *zhp, const char *vdevname, uint64_t *vdev_guid)
 {
 	nvlist_t *tgt;
 	boolean_t avail_spare, l2cache;
 
 	verify(zhp != NULL);
 	if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) {
 		char errbuf[ERRBUFLEN];
 		(void) snprintf(errbuf, sizeof (errbuf),
 		    dgettext(TEXT_DOMAIN, "pool is in an unavailable state"));
 		return (zfs_error(zhp->zpool_hdl, EZFS_POOLUNAVAIL, errbuf));
 	}
 
 	if ((tgt = zpool_find_vdev(zhp, vdevname, &avail_spare, &l2cache,
 	    NULL)) == NULL) {
 		char errbuf[ERRBUFLEN];
 		(void) snprintf(errbuf, sizeof (errbuf),
 		    dgettext(TEXT_DOMAIN, "can not find %s in %s"),
 		    vdevname, zhp->zpool_name);
 		return (zfs_error(zhp->zpool_hdl, EZFS_NODEVICE, errbuf));
 	}
 
 	*vdev_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID);
 	return (0);
 }
 
 /*
  * Get a vdev property value for 'prop' and return the value in
  * a pre-allocated buffer.
  */
 int
 zpool_get_vdev_prop_value(nvlist_t *nvprop, vdev_prop_t prop, char *prop_name,
     char *buf, size_t len, zprop_source_t *srctype, boolean_t literal)
 {
 	nvlist_t *nv;
 	const char *strval;
 	uint64_t intval;
 	zprop_source_t src = ZPROP_SRC_NONE;
 
 	if (prop == VDEV_PROP_USERPROP) {
 		/* user property, prop_name must contain the property name */
 		assert(prop_name != NULL);
 		if (nvlist_lookup_nvlist(nvprop, prop_name, &nv) == 0) {
 			src = fnvlist_lookup_uint64(nv, ZPROP_SOURCE);
 			strval = fnvlist_lookup_string(nv, ZPROP_VALUE);
 		} else {
 			/* user prop not found */
 			return (-1);
 		}
 		(void) strlcpy(buf, strval, len);
 		if (srctype)
 			*srctype = src;
 		return (0);
 	}
 
 	if (prop_name == NULL)
 		prop_name = (char *)vdev_prop_to_name(prop);
 
 	switch (vdev_prop_get_type(prop)) {
 	case PROP_TYPE_STRING:
 		if (nvlist_lookup_nvlist(nvprop, prop_name, &nv) == 0) {
 			src = fnvlist_lookup_uint64(nv, ZPROP_SOURCE);
 			strval = fnvlist_lookup_string(nv, ZPROP_VALUE);
 		} else {
 			src = ZPROP_SRC_DEFAULT;
 			if ((strval = vdev_prop_default_string(prop)) == NULL)
 				strval = "-";
 		}
 		(void) strlcpy(buf, strval, len);
 		break;
 
 	case PROP_TYPE_NUMBER:
 		if (nvlist_lookup_nvlist(nvprop, prop_name, &nv) == 0) {
 			src = fnvlist_lookup_uint64(nv, ZPROP_SOURCE);
 			intval = fnvlist_lookup_uint64(nv, ZPROP_VALUE);
 		} else {
 			src = ZPROP_SRC_DEFAULT;
 			intval = vdev_prop_default_numeric(prop);
 		}
 
 		switch (prop) {
 		case VDEV_PROP_ASIZE:
 		case VDEV_PROP_PSIZE:
 		case VDEV_PROP_SIZE:
 		case VDEV_PROP_BOOTSIZE:
 		case VDEV_PROP_ALLOCATED:
 		case VDEV_PROP_FREE:
 		case VDEV_PROP_READ_ERRORS:
 		case VDEV_PROP_WRITE_ERRORS:
 		case VDEV_PROP_CHECKSUM_ERRORS:
 		case VDEV_PROP_INITIALIZE_ERRORS:
 		case VDEV_PROP_TRIM_ERRORS:
 		case VDEV_PROP_SLOW_IOS:
 		case VDEV_PROP_OPS_NULL:
 		case VDEV_PROP_OPS_READ:
 		case VDEV_PROP_OPS_WRITE:
 		case VDEV_PROP_OPS_FREE:
 		case VDEV_PROP_OPS_CLAIM:
 		case VDEV_PROP_OPS_TRIM:
 		case VDEV_PROP_BYTES_NULL:
 		case VDEV_PROP_BYTES_READ:
 		case VDEV_PROP_BYTES_WRITE:
 		case VDEV_PROP_BYTES_FREE:
 		case VDEV_PROP_BYTES_CLAIM:
 		case VDEV_PROP_BYTES_TRIM:
 			if (literal) {
 				(void) snprintf(buf, len, "%llu",
 				    (u_longlong_t)intval);
 			} else {
 				(void) zfs_nicenum(intval, buf, len);
 			}
 			break;
 		case VDEV_PROP_EXPANDSZ:
 			if (intval == 0) {
 				(void) strlcpy(buf, "-", len);
 			} else if (literal) {
 				(void) snprintf(buf, len, "%llu",
 				    (u_longlong_t)intval);
 			} else {
 				(void) zfs_nicenum(intval, buf, len);
 			}
 			break;
 		case VDEV_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 VDEV_PROP_CHECKSUM_N:
 		case VDEV_PROP_CHECKSUM_T:
 		case VDEV_PROP_IO_N:
 		case VDEV_PROP_IO_T:
 		case VDEV_PROP_SLOW_IO_N:
 		case VDEV_PROP_SLOW_IO_T:
 			if (intval == UINT64_MAX) {
 				(void) strlcpy(buf, "-", len);
 			} else {
 				(void) snprintf(buf, len, "%llu",
 				    (u_longlong_t)intval);
 			}
 			break;
 		case VDEV_PROP_FRAGMENTATION:
 			if (intval == UINT64_MAX) {
 				(void) strlcpy(buf, "-", len);
 			} else {
 				(void) snprintf(buf, len, "%llu%%",
 				    (u_longlong_t)intval);
 			}
 			break;
 		case VDEV_PROP_STATE:
 			if (literal) {
 				(void) snprintf(buf, len, "%llu",
 				    (u_longlong_t)intval);
 			} else {
 				(void) strlcpy(buf, zpool_state_to_name(intval,
 				    VDEV_AUX_NONE), len);
 			}
 			break;
 		default:
 			(void) snprintf(buf, len, "%llu",
 			    (u_longlong_t)intval);
 		}
 		break;
 
 	case PROP_TYPE_INDEX:
 		if (nvlist_lookup_nvlist(nvprop, prop_name, &nv) == 0) {
 			src = fnvlist_lookup_uint64(nv, ZPROP_SOURCE);
 			intval = fnvlist_lookup_uint64(nv, ZPROP_VALUE);
 		} else {
 			/* 'trim_support' only valid for leaf vdevs */
 			if (prop == VDEV_PROP_TRIM_SUPPORT) {
 				(void) strlcpy(buf, "-", len);
 				break;
 			}
 			src = ZPROP_SRC_DEFAULT;
 			intval = vdev_prop_default_numeric(prop);
 			/* Only use if provided by the RAIDZ VDEV above */
 			if (prop == VDEV_PROP_RAIDZ_EXPANDING)
 				return (ENOENT);
 		}
 		if (vdev_prop_index_to_string(prop, intval,
 		    (const char **)&strval) != 0)
 			return (-1);
 		(void) strlcpy(buf, strval, len);
 		break;
 
 	default:
 		abort();
 	}
 
 	if (srctype)
 		*srctype = src;
 
 	return (0);
 }
 
 /*
  * Get a vdev property value for 'prop_name' and return the value in
  * a pre-allocated buffer.
  */
 int
 zpool_get_vdev_prop(zpool_handle_t *zhp, const char *vdevname, vdev_prop_t prop,
     char *prop_name, char *buf, size_t len, zprop_source_t *srctype,
     boolean_t literal)
 {
 	nvlist_t *reqnvl, *reqprops;
 	nvlist_t *retprops = NULL;
 	uint64_t vdev_guid = 0;
 	int ret;
 
 	if ((ret = zpool_vdev_guid(zhp, vdevname, &vdev_guid)) != 0)
 		return (ret);
 
 	if (nvlist_alloc(&reqnvl, NV_UNIQUE_NAME, 0) != 0)
 		return (no_memory(zhp->zpool_hdl));
 	if (nvlist_alloc(&reqprops, NV_UNIQUE_NAME, 0) != 0)
 		return (no_memory(zhp->zpool_hdl));
 
 	fnvlist_add_uint64(reqnvl, ZPOOL_VDEV_PROPS_GET_VDEV, vdev_guid);
 
 	if (prop != VDEV_PROP_USERPROP) {
 		/* prop_name overrides prop value */
 		if (prop_name != NULL)
 			prop = vdev_name_to_prop(prop_name);
 		else
 			prop_name = (char *)vdev_prop_to_name(prop);
 		assert(prop < VDEV_NUM_PROPS);
 	}
 
 	assert(prop_name != NULL);
 	if (nvlist_add_uint64(reqprops, prop_name, prop) != 0) {
 		nvlist_free(reqnvl);
 		nvlist_free(reqprops);
 		return (no_memory(zhp->zpool_hdl));
 	}
 
 	fnvlist_add_nvlist(reqnvl, ZPOOL_VDEV_PROPS_GET_PROPS, reqprops);
 
 	ret = lzc_get_vdev_prop(zhp->zpool_name, reqnvl, &retprops);
 
 	if (ret == 0) {
 		ret = zpool_get_vdev_prop_value(retprops, prop, prop_name, buf,
 		    len, srctype, literal);
 	} else {
 		char errbuf[ERRBUFLEN];
 		(void) snprintf(errbuf, sizeof (errbuf),
 		    dgettext(TEXT_DOMAIN, "cannot get vdev property %s from"
 		    " %s in %s"), prop_name, vdevname, zhp->zpool_name);
 		(void) zpool_standard_error(zhp->zpool_hdl, ret, errbuf);
 	}
 
 	nvlist_free(reqnvl);
 	nvlist_free(reqprops);
 	nvlist_free(retprops);
 
 	return (ret);
 }
 
 /*
  * Get all vdev properties
  */
 int
 zpool_get_all_vdev_props(zpool_handle_t *zhp, const char *vdevname,
     nvlist_t **outnvl)
 {
 	nvlist_t *nvl = NULL;
 	uint64_t vdev_guid = 0;
 	int ret;
 
 	if ((ret = zpool_vdev_guid(zhp, vdevname, &vdev_guid)) != 0)
 		return (ret);
 
 	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
 		return (no_memory(zhp->zpool_hdl));
 
 	fnvlist_add_uint64(nvl, ZPOOL_VDEV_PROPS_GET_VDEV, vdev_guid);
 
 	ret = lzc_get_vdev_prop(zhp->zpool_name, nvl, outnvl);
 
 	nvlist_free(nvl);
 
 	if (ret) {
 		char errbuf[ERRBUFLEN];
 		(void) snprintf(errbuf, sizeof (errbuf),
 		    dgettext(TEXT_DOMAIN, "cannot get vdev properties for"
 		    " %s in %s"), vdevname, zhp->zpool_name);
 		(void) zpool_standard_error(zhp->zpool_hdl, errno, errbuf);
 	}
 
 	return (ret);
 }
 
 /*
  * Set vdev property
  */
 int
 zpool_set_vdev_prop(zpool_handle_t *zhp, const char *vdevname,
     const char *propname, const char *propval)
 {
 	int ret;
 	nvlist_t *nvl = NULL;
 	nvlist_t *outnvl = NULL;
 	nvlist_t *props;
 	nvlist_t *realprops;
 	prop_flags_t flags = { 0 };
 	uint64_t version;
 	uint64_t vdev_guid;
 
 	if ((ret = zpool_vdev_guid(zhp, vdevname, &vdev_guid)) != 0)
 		return (ret);
 
 	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
 		return (no_memory(zhp->zpool_hdl));
 	if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
 		return (no_memory(zhp->zpool_hdl));
 
 	fnvlist_add_uint64(nvl, ZPOOL_VDEV_PROPS_SET_VDEV, vdev_guid);
 
 	if (nvlist_add_string(props, propname, propval) != 0) {
 		nvlist_free(props);
 		return (no_memory(zhp->zpool_hdl));
 	}
 
 	char errbuf[ERRBUFLEN];
 	(void) snprintf(errbuf, sizeof (errbuf),
 	    dgettext(TEXT_DOMAIN, "cannot set property %s for %s on %s"),
 	    propname, vdevname, zhp->zpool_name);
 
 	flags.vdevprop = 1;
 	version = zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL);
 	if ((realprops = zpool_valid_proplist(zhp->zpool_hdl,
 	    zhp->zpool_name, props, version, flags, errbuf)) == NULL) {
 		nvlist_free(props);
 		nvlist_free(nvl);
 		return (-1);
 	}
 
 	nvlist_free(props);
 	props = realprops;
 
 	fnvlist_add_nvlist(nvl, ZPOOL_VDEV_PROPS_SET_PROPS, props);
 
 	ret = lzc_set_vdev_prop(zhp->zpool_name, nvl, &outnvl);
 
 	nvlist_free(props);
 	nvlist_free(nvl);
 	nvlist_free(outnvl);
 
 	if (ret)
 		(void) zpool_standard_error(zhp->zpool_hdl, errno, errbuf);
 
 	return (ret);
 }
 
 /*
  * Prune older entries from the DDT to reclaim space under the quota
  */
 int
 zpool_ddt_prune(zpool_handle_t *zhp, zpool_ddt_prune_unit_t unit,
     uint64_t amount)
 {
 	int error = lzc_ddt_prune(zhp->zpool_name, unit, amount);
 	if (error != 0) {
 		libzfs_handle_t *hdl = zhp->zpool_hdl;
 		char errbuf[ERRBUFLEN];
 
 		(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
 		    "cannot prune dedup table on '%s'"), zhp->zpool_name);
 
 		if (error == EALREADY) {
 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 			    "a prune operation is already in progress"));
 			(void) zfs_error(hdl, EZFS_BUSY, errbuf);
 		} else {
 			(void) zpool_standard_error(hdl, errno, errbuf);
 		}
 		return (-1);
 	}
 
 	return (0);
 }
diff --git a/sys/contrib/openzfs/lib/libzpool/Makefile.am b/sys/contrib/openzfs/lib/libzpool/Makefile.am
index 397959c679e9..404b737c204d 100644
--- a/sys/contrib/openzfs/lib/libzpool/Makefile.am
+++ b/sys/contrib/openzfs/lib/libzpool/Makefile.am
@@ -1,220 +1,220 @@
 include $(srcdir)/%D%/include/Makefile.am
 
 libzpool_la_CFLAGS  = $(AM_CFLAGS) $(KERNEL_CFLAGS) $(LIBRARY_CFLAGS)
 libzpool_la_CFLAGS += $(ZLIB_CFLAGS)
 
 libzpool_la_CPPFLAGS  = $(AM_CPPFLAGS) $(LIBZPOOL_CPPFLAGS)
 libzpool_la_CPPFLAGS += -I$(srcdir)/include/os/@ac_system_l@/zfs
 libzpool_la_CPPFLAGS += -DLIB_ZPOOL_BUILD
 
 lib_LTLIBRARIES += libzpool.la
 CPPCHECKTARGETS += libzpool.la
 
 dist_libzpool_la_SOURCES = \
 	%D%/abd_os.c \
 	%D%/arc_os.c \
 	%D%/kernel.c \
 	%D%/taskq.c \
 	%D%/util.c \
 	%D%/vdev_label_os.c \
 	%D%/zfs_racct.c \
 	%D%/zfs_debug.c
 
 nodist_libzpool_la_SOURCES = \
 	module/lua/lapi.c \
 	module/lua/lauxlib.c \
 	module/lua/lbaselib.c \
 	module/lua/lcode.c \
 	module/lua/lcompat.c \
 	module/lua/lcorolib.c \
 	module/lua/lctype.c \
 	module/lua/ldebug.c \
 	module/lua/ldo.c \
 	module/lua/lfunc.c \
 	module/lua/lgc.c \
 	module/lua/llex.c \
 	module/lua/lmem.c \
 	module/lua/lobject.c \
 	module/lua/lopcodes.c \
 	module/lua/lparser.c \
 	module/lua/lstate.c \
 	module/lua/lstring.c \
 	module/lua/lstrlib.c \
 	module/lua/ltable.c \
 	module/lua/ltablib.c \
 	module/lua/ltm.c \
 	module/lua/lvm.c \
 	module/lua/lzio.c \
 	\
 	module/os/linux/zfs/vdev_file.c \
 	module/os/linux/zfs/zio_crypt.c \
 	\
 	module/zcommon/cityhash.c \
 	module/zcommon/simd_stat.c \
 	module/zcommon/zfeature_common.c \
 	module/zcommon/zfs_comutil.c \
 	module/zcommon/zfs_deleg.c \
 	module/zcommon/zfs_fletcher.c \
 	module/zcommon/zfs_fletcher_aarch64_neon.c \
 	module/zcommon/zfs_fletcher_avx512.c \
 	module/zcommon/zfs_fletcher_intel.c \
 	module/zcommon/zfs_fletcher_sse.c \
 	module/zcommon/zfs_fletcher_superscalar.c \
 	module/zcommon/zfs_fletcher_superscalar4.c \
 	module/zcommon/zfs_namecheck.c \
 	module/zcommon/zfs_prop.c \
 	module/zcommon/zfs_valstr.c \
 	module/zcommon/zpool_prop.c \
 	module/zcommon/zprop_common.c \
 	\
 	module/zfs/abd.c \
 	module/zfs/aggsum.c \
 	module/zfs/arc.c \
 	module/zfs/blake3_zfs.c \
 	module/zfs/blkptr.c \
 	module/zfs/bplist.c \
 	module/zfs/bpobj.c \
 	module/zfs/bptree.c \
 	module/zfs/bqueue.c \
 	module/zfs/btree.c \
 	module/zfs/brt.c \
 	module/zfs/dbuf.c \
 	module/zfs/dbuf_stats.c \
 	module/zfs/ddt.c \
 	module/zfs/ddt_log.c \
 	module/zfs/ddt_stats.c \
 	module/zfs/ddt_zap.c \
 	module/zfs/dmu.c \
 	module/zfs/dmu_diff.c \
 	module/zfs/dmu_direct.c \
 	module/zfs/dmu_object.c \
 	module/zfs/dmu_objset.c \
 	module/zfs/dmu_recv.c \
 	module/zfs/dmu_redact.c \
 	module/zfs/dmu_send.c \
 	module/zfs/dmu_traverse.c \
 	module/zfs/dmu_tx.c \
 	module/zfs/dmu_zfetch.c \
 	module/zfs/dnode.c \
 	module/zfs/dnode_sync.c \
 	module/zfs/dsl_bookmark.c \
 	module/zfs/dsl_crypt.c \
 	module/zfs/dsl_dataset.c \
 	module/zfs/dsl_deadlist.c \
 	module/zfs/dsl_deleg.c \
 	module/zfs/dsl_destroy.c \
 	module/zfs/dsl_dir.c \
 	module/zfs/dsl_pool.c \
 	module/zfs/dsl_prop.c \
 	module/zfs/dsl_scan.c \
 	module/zfs/dsl_synctask.c \
 	module/zfs/dsl_userhold.c \
 	module/zfs/edonr_zfs.c \
 	module/zfs/fm.c \
 	module/zfs/gzip.c \
 	module/zfs/hkdf.c \
 	module/zfs/lz4.c \
 	module/zfs/lz4_zfs.c \
 	module/zfs/lzjb.c \
 	module/zfs/metaslab.c \
 	module/zfs/mmp.c \
 	module/zfs/multilist.c \
 	module/zfs/objlist.c \
 	module/zfs/pathname.c \
 	module/zfs/range_tree.c \
 	module/zfs/refcount.c \
 	module/zfs/rrwlock.c \
 	module/zfs/sa.c \
 	module/zfs/sha2_zfs.c \
 	module/zfs/skein_zfs.c \
 	module/zfs/spa.c \
 	module/zfs/spa_checkpoint.c \
 	module/zfs/spa_config.c \
 	module/zfs/spa_errlog.c \
 	module/zfs/spa_history.c \
 	module/zfs/spa_log_spacemap.c \
 	module/zfs/spa_misc.c \
 	module/zfs/spa_stats.c \
 	module/zfs/space_map.c \
 	module/zfs/space_reftree.c \
 	module/zfs/txg.c \
 	module/zfs/uberblock.c \
 	module/zfs/unique.c \
 	module/zfs/vdev.c \
 	module/zfs/vdev_draid.c \
 	module/zfs/vdev_draid_rand.c \
 	module/zfs/vdev_indirect.c \
 	module/zfs/vdev_indirect_births.c \
 	module/zfs/vdev_indirect_mapping.c \
 	module/zfs/vdev_initialize.c \
 	module/zfs/vdev_label.c \
 	module/zfs/vdev_mirror.c \
 	module/zfs/vdev_missing.c \
 	module/zfs/vdev_queue.c \
 	module/zfs/vdev_raidz.c \
 	module/zfs/vdev_raidz_math.c \
 	module/zfs/vdev_raidz_math_aarch64_neon.c \
 	module/zfs/vdev_raidz_math_aarch64_neonx2.c \
 	module/zfs/vdev_raidz_math_avx2.c \
 	module/zfs/vdev_raidz_math_avx512bw.c \
 	module/zfs/vdev_raidz_math_avx512f.c \
 	module/zfs/vdev_raidz_math_powerpc_altivec.c \
 	module/zfs/vdev_raidz_math_scalar.c \
 	module/zfs/vdev_raidz_math_sse2.c \
 	module/zfs/vdev_raidz_math_ssse3.c \
 	module/zfs/vdev_rebuild.c \
 	module/zfs/vdev_removal.c \
 	module/zfs/vdev_root.c \
 	module/zfs/vdev_trim.c \
 	module/zfs/zap.c \
 	module/zfs/zap_leaf.c \
 	module/zfs/zap_micro.c \
 	module/zfs/zcp.c \
 	module/zfs/zcp_get.c \
 	module/zfs/zcp_global.c \
 	module/zfs/zcp_iter.c \
 	module/zfs/zcp_set.c \
 	module/zfs/zcp_synctask.c \
 	module/zfs/zfeature.c \
 	module/zfs/zfs_byteswap.c \
 	module/zfs/zfs_chksum.c \
 	module/zfs/zfs_fm.c \
 	module/zfs/zfs_fuid.c \
 	module/zfs/zfs_ratelimit.c \
 	module/zfs/zfs_rlock.c \
 	module/zfs/zfs_sa.c \
 	module/zfs/zfs_znode.c \
 	module/zfs/zil.c \
 	module/zfs/zio.c \
 	module/zfs/zio_checksum.c \
 	module/zfs/zio_compress.c \
 	module/zfs/zio_inject.c \
 	module/zfs/zle.c \
 	module/zfs/zrlock.c \
 	module/zfs/zthr.c
 
 libzpool_la_LIBADD = \
 	libicp.la \
 	libunicode.la \
 	libnvpair.la \
 	libzstd.la \
 	libzutil.la
 
 libzpool_la_LIBADD += $(LIBCLOCK_GETTIME) $(ZLIB_LIBS) -ldl -lm
 
 libzpool_la_LDFLAGS = -pthread
 
 if !ASAN_ENABLED
 libzpool_la_LDFLAGS += -Wl,-z,defs
 endif
 
 if BUILD_FREEBSD
 libzpool_la_LIBADD += -lgeom
 endif
 
-libzpool_la_LDFLAGS += -version-info 5:0:0
+libzpool_la_LDFLAGS += -version-info 6:0:0
 
 if TARGET_CPU_POWERPC
 module/zfs/libzpool_la-vdev_raidz_math_powerpc_altivec.$(OBJEXT) : CFLAGS += -maltivec
 module/zfs/libzpool_la-vdev_raidz_math_powerpc_altivec.l$(OBJEXT): CFLAGS += -maltivec
 endif
diff --git a/sys/contrib/openzfs/lib/libzpool/zfs_debug.c b/sys/contrib/openzfs/lib/libzpool/zfs_debug.c
index df49a9a33fe8..82c7229932f0 100644
--- a/sys/contrib/openzfs/lib/libzpool/zfs_debug.c
+++ b/sys/contrib/openzfs/lib/libzpool/zfs_debug.c
@@ -1,106 +1,124 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 /*
  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2012, 2014 by Delphix. All rights reserved.
  * Copyright (c) 2024, Rob Norris <robn@despairlabs.com>
  */
 
 #include <sys/zfs_context.h>
 
 typedef struct zfs_dbgmsg {
 	list_node_t		zdm_node;
 	uint64_t		zdm_timestamp;
 	uint_t			zdm_size;
 	char			zdm_msg[]; /* variable length allocation */
 } zfs_dbgmsg_t;
 
 static list_t zfs_dbgmsgs;
 static kmutex_t zfs_dbgmsgs_lock;
+static uint_t zfs_dbgmsg_size = 0;
+static uint_t zfs_dbgmsg_maxsize = 4<<20; /* 4MB */
 
 int zfs_dbgmsg_enable = B_TRUE;
 
+static void
+zfs_dbgmsg_purge(uint_t max_size)
+{
+	while (zfs_dbgmsg_size > max_size) {
+		zfs_dbgmsg_t *zdm = list_remove_head(&zfs_dbgmsgs);
+		if (zdm == NULL)
+			return;
+
+		uint_t size = zdm->zdm_size;
+		kmem_free(zdm, size);
+		zfs_dbgmsg_size -= size;
+	}
+}
+
 void
 zfs_dbgmsg_init(void)
 {
 	list_create(&zfs_dbgmsgs, sizeof (zfs_dbgmsg_t),
 	    offsetof(zfs_dbgmsg_t, zdm_node));
 	mutex_init(&zfs_dbgmsgs_lock, NULL, MUTEX_DEFAULT, NULL);
 }
 
 void
 zfs_dbgmsg_fini(void)
 {
 	zfs_dbgmsg_t *zdm;
 	while ((zdm = list_remove_head(&zfs_dbgmsgs)))
 		umem_free(zdm, zdm->zdm_size);
 	mutex_destroy(&zfs_dbgmsgs_lock);
 }
 
 void
 __set_error(const char *file, const char *func, int line, int err)
 {
 	if (zfs_flags & ZFS_DEBUG_SET_ERROR)
 		__dprintf(B_FALSE, file, func, line, "error %lu",
 		    (ulong_t)err);
 }
 
 void
 __zfs_dbgmsg(char *buf)
 {
 	uint_t size = sizeof (zfs_dbgmsg_t) + strlen(buf) + 1;
 	zfs_dbgmsg_t *zdm = umem_zalloc(size, KM_SLEEP);
 	zdm->zdm_size = size;
 	zdm->zdm_timestamp = gethrestime_sec();
 	strcpy(zdm->zdm_msg, buf);
 
 	mutex_enter(&zfs_dbgmsgs_lock);
 	list_insert_tail(&zfs_dbgmsgs, zdm);
+	zfs_dbgmsg_size += size;
+	zfs_dbgmsg_purge(zfs_dbgmsg_maxsize);
 	mutex_exit(&zfs_dbgmsgs_lock);
 }
 
 void
 zfs_dbgmsg_print(int fd, const char *tag)
 {
 	ssize_t ret __attribute__((unused));
 
 	mutex_enter(&zfs_dbgmsgs_lock);
 
 	/*
 	 * We use write() in this function instead of printf()
 	 * so it is safe to call from a signal handler.
 	 */
 	ret = write(fd, "ZFS_DBGMSG(", 11);
 	ret = write(fd, tag, strlen(tag));
 	ret = write(fd, ") START:\n", 9);
 
 	for (zfs_dbgmsg_t *zdm = list_head(&zfs_dbgmsgs); zdm != NULL;
 	    zdm = list_next(&zfs_dbgmsgs, zdm)) {
 		ret = write(fd, zdm->zdm_msg, strlen(zdm->zdm_msg));
 		ret = write(fd, "\n", 1);
 	}
 
 	ret = write(fd, "ZFS_DBGMSG(", 11);
 	ret = write(fd, tag, strlen(tag));
 	ret = write(fd, ") END\n", 6);
 
 	mutex_exit(&zfs_dbgmsgs_lock);
 }
diff --git a/sys/contrib/openzfs/man/man4/zfs.4 b/sys/contrib/openzfs/man/man4/zfs.4
index e19573d5ee14..c9f6ed0dece3 100644
--- a/sys/contrib/openzfs/man/man4/zfs.4
+++ b/sys/contrib/openzfs/man/man4/zfs.4
@@ -1,2871 +1,2871 @@
 .\"
 .\" 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.
 .\" Copyright (c) 2023, 2024 Klara, 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 https://opensource.org/licenses/CDDL-1.0.
 .\"
 .\" See the License for the specific language governing permissions and
 .\" limitations under the License. When distributing Covered Code, include this
 .\" CDDL HEADER in each file and include the License file at
 .\" usr/src/OPENSOLARIS.LICENSE.  If applicable, add the following below this
 .\" CDDL HEADER, with the fields enclosed by brackets "[]" replaced with your
 .\" own identifying information:
 .\" Portions Copyright [yyyy] [name of copyright owner]
 .\"
 .\" Copyright (c) 2024, Klara, Inc.
 .\"
 .Dd October 2, 2024
 .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 UINT64_MAX Ns B Pq u64
 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 UINT64_MAX Ns B Pq u64
 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 uint
 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 uint
 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 dbuf_mutex_cache_shift Ns = Ns Sy 0 Pq uint
 Set the size of the mutex array for the dbuf cache.
 When set to
 .Sy 0
 the array is dynamically sized based on total system memory.
 .
 .It Sy dmu_object_alloc_chunk_shift Ns = Ns Sy 7 Po 128 Pc Pq uint
 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_ddt_copies Ns = Ns Sy 3 Pq uint
 Controls the number of copies stored for DeDup Table
 .Pq DDT
 objects.
 Reducing the number of copies to 1 from the previous default of 3
 can reduce the write inflation caused by deduplication.
 This assumes redundancy for this data is provided by the vdev layer.
 If the DDT is damaged, space may be leaked
 .Pq not freed
 when the DDT can not report the correct reference count.
 .
 .It Sy dmu_prefetch_max Ns = Ns Sy 134217728 Ns B Po 128 MiB Pc Pq uint
 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 u64
 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 u64
 Seconds between L2ARC writing.
 .
 .It Sy l2arc_headroom Ns = Ns Sy 8 Pq u64
 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 u64
 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_exclude_special Ns = Ns Sy 0 Ns | Ns 1 Pq int
 Controls whether buffers present on special vdevs are eligible for caching
 into L2ARC.
 If set to 1, exclude dbufs on special vdevs from being cached to L2ARC.
 .
 .It Sy l2arc_mfuonly Ns = Ns Sy 0 Ns | Ns 1 Ns | Ns 2 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 0,
 meaning both MRU and MFU data and metadata are cached.
 When turning off this feature (setting it to 0), 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
 Setting it to 1 means to L2 cache only MFU data and metadata.
 .Pp
 Setting it to 2 means to L2 cache all metadata (MRU+MFU) but
 only MFU data (ie: MRU data are not cached). This can be the right setting
 to cache as much metadata as possible even when having high data turnover.
 .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 uint
 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 u64
 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 64 MiB
 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 33554432 Ns B Po 32 MiB Pc Pq u64
 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 33554432 Ns B Po 32 MiB Pc Pq u64
 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 1 GiB Pc Pq u64
 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 1 GiB, 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 1048576 Ns B Po 1 MiB Pc Pq u64
 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 each disk
 before moving on to the next top-level vdev.
 .
 .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 Po 16 MiB + 1 B Pc Pq u64
 Make some blocks above a certain size be gang blocks.
 This option is used by the test suite to facilitate testing.
 .
 .It Sy metaslab_force_ganging_pct Ns = Ns Sy 3 Ns % Pq uint
 For blocks that could be forced to be a gang block (due to
 .Sy metaslab_force_ganging ) ,
 force this many of them to be gang blocks.
 .
 .It Sy brt_zap_prefetch Ns = Ns Sy 1 Ns | Ns 0 Pq int
 Controls prefetching BRT records for blocks which are going to be cloned.
 .
 .It Sy brt_zap_default_bs Ns = Ns Sy 12 Po 4 KiB Pc Pq int
 Default BRT ZAP data block size as a power of 2. Note that changing this after
 creating a BRT on the pool will not affect existing BRTs, only newly created
 ones.
 .
 .It Sy brt_zap_default_ibs Ns = Ns Sy 12 Po 4 KiB Pc Pq int
 Default BRT ZAP indirect block size as a power of 2. Note that changing this
 after creating a BRT on the pool will not affect existing BRTs, only newly
 created ones.
 .
 .It Sy ddt_zap_default_bs Ns = Ns Sy 15 Po 32 KiB Pc Pq int
 Default DDT ZAP data block size as a power of 2. Note that changing this after
 creating a DDT on the pool will not affect existing DDTs, only newly created
 ones.
 .
 .It Sy ddt_zap_default_ibs Ns = Ns Sy 15 Po 32 KiB Pc Pq int
 Default DDT ZAP indirect block size as a power of 2. Note that changing this
 after creating a DDT on the pool will not affect existing DDTs, only newly
 created ones.
 .
 .It Sy zfs_default_bs Ns = Ns Sy 9 Po 512 B Pc Pq int
 Default dnode block size as a power of 2.
 .
 .It Sy zfs_default_ibs Ns = Ns Sy 17 Po 128 KiB Pc Pq int
 Default dnode indirect block size as a power of 2.
 .
 .It Sy zfs_dio_enabled Ns = Ns Sy 0 Ns | Ns 1 Pq int
 Enable Direct I/O.
 If this setting is 0, then all I/O requests will be directed through the ARC
 acting as though the dataset property
 .Sy direct
 was set to
 .Sy disabled .
 .
 .It Sy zfs_history_output_max Ns = Ns Sy 1048576 Ns B Po 1 MiB Pc Pq u64
 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 64 MiB .
 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 16 MiB Pc Pq uint
 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 16 MiB ,
 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 16 MiB
 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 1 hour Pc Pq u64
 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 uint
 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 uint
 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 uint
 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 512 MiB Pc Pq uint
 Default lower limit for metaslab size.
 .
 .It Sy zfs_vdev_max_ms_shift Ns = Ns Sy 34 Po 16 GiB Pc Pq uint
 Default upper limit for metaslab size.
 .
 .It Sy zfs_vdev_max_auto_ashift Ns = Ns Sy 14 Pq uint
 Maximum ashift used when optimizing for logical \[->] physical sector size on
 new
 top-level vdevs.
 May be increased up to
 .Sy ASHIFT_MAX Po 16 Pc ,
 but this may negatively impact pool space efficiency.
 .
 .It Sy zfs_vdev_direct_write_verify Ns = Ns Sy Linux 1 | FreeBSD 0 Pq uint
 If non-zero, then a Direct I/O write's checksum will be verified every
 time the write is issued and before it is commited to the block pointer.
 In the event the checksum is not valid then the I/O operation will return EIO.
 This module parameter can be used to detect if the
 contents of the users buffer have changed in the process of doing a Direct I/O
 write.
 It can also help to identify if reported checksum errors are tied to Direct I/O
 writes.
 Each verify error causes a
-.Sy dio_verify
+.Sy dio_verify_wr
 zevent.
 Direct Write I/O checkum verify errors can be seen with
 .Nm zpool Cm status Fl d .
 The default value for this is 1 on Linux, but is 0 for
 .Fx
 because user pages can be placed under write protection in
 .Fx
 before the Direct I/O write is issued.
 .
 .It Sy zfs_vdev_min_auto_ashift Ns = Ns Sy ASHIFT_MIN Po 9 Pc Pq uint
 Minimum ashift used when creating new top-level vdevs.
 .
 .It Sy zfs_vdev_min_ms_count Ns = Ns Sy 16 Pq uint
 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 uint
 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_preload_limit Ns = Ns Sy 10 Pq uint
 Maximum number of metaslabs per group to preload
 .
 .It Sy metaslab_preload_pct Ns = Ns Sy 50 Pq uint
 Percentage of CPUs to run a metaslab preload taskq
 .
 .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 uint
 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 10 min Pc Pq uint
 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 uint
 Maximum reference holders being tracked when reference_tracking_enable is
 active.
 .It Sy raidz_expand_max_copy_bytes Ns = Ns Sy 160MB Pq ulong
 Max amount of memory to use for RAID-Z expansion I/O.
 This limits how much I/O can be outstanding at once.
 .
 .It Sy raidz_expand_max_reflow_bytes Ns = Ns Sy 0 Pq ulong
 For testing, pause RAID-Z expansion when reflow amount reaches this value.
 .
 .It Sy raidz_io_aggregate_rows Ns = Ns Sy 4 Pq ulong
 For expanded RAID-Z, aggregate reads that have more rows than this.
 .
 .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 uint
 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 uint
 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 spa_num_allocators Ns = Ns Sy 4 Pq int
 Determines the number of block alloctators to use per spa instance.
 Capped by the number of actual CPUs in the system via
 .Sy spa_cpus_per_allocator .
 .Pp
 Note that setting this value too high could result in performance
 degredation and/or excess fragmentation.
 Set value only applies to pools imported/created after that.
 .
 .It Sy spa_cpus_per_allocator Ns = Ns Sy 4 Pq int
 Determines the minimum number of CPUs in a system for block alloctator
 per spa instance.
 Set value only applies to pools imported/created after that.
 .
 .It Sy spa_upgrade_errlog_limit Ns = Ns Sy 0 Pq uint
 Limits the number of on-disk error log entries that will be converted to the
 new format when enabling the
 .Sy head_errlog
 feature.
 The default is to convert all log entries.
 .
 .It Sy vdev_removal_max_span Ns = Ns Sy 32768 Ns B Po 32 KiB Pc Pq uint
 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 512 B Pc Pq u64
 Logical ashift for file-based devices.
 .
 .It Sy vdev_file_physical_ashift Ns = Ns Sy 9 Po 512 B Pc Pq u64
 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 zap_micro_max_size Ns = Ns Sy 131072 Ns B Po 128 KiB Pc Pq int
 Maximum micro ZAP size.
 A "micro" ZAP is upgraded to a "fat" ZAP once it grows beyond the specified
 size.
 Sizes higher than 128KiB will be clamped to 128KiB unless the
 .Sy large_microzap
 feature is enabled.
 .
 .It Sy zap_shrink_enabled Ns = Ns Sy 1 Ns | Ns 0 Pq int
 If set, adjacent empty ZAP blocks will be collapsed, reducing disk space.
 .
 .It Sy zfetch_min_distance Ns = Ns Sy 4194304 Ns B Po 4 MiB Pc Pq uint
 Min bytes to prefetch per stream.
 Prefetch distance starts from the demand access size and quickly grows to
 this value, doubling on each hit.
 After that it may grow further by 1/8 per hit, but only if some prefetch
 since last time haven't completed in time to satisfy demand request, i.e.
 prefetch depth didn't cover the read latency or the pool got saturated.
 .
 .It Sy zfetch_max_distance Ns = Ns Sy 67108864 Ns B Po 64 MiB Pc Pq uint
 Max bytes to prefetch per stream.
 .
 .It Sy zfetch_max_idistance Ns = Ns Sy 67108864 Ns B Po 64 MiB Pc Pq uint
 Max bytes to prefetch indirects for per stream.
 .
 .It Sy zfetch_max_reorder Ns = Ns Sy 16777216 Ns B Po 16 MiB Pc Pq uint
 Requests within this byte distance from the current prefetch stream position
 are considered parts of the stream, reordered due to parallel processing.
 Such requests do not advance the stream position immediately unless
 .Sy zfetch_hole_shift
 fill threshold is reached, but saved to fill holes in the stream later.
 .
 .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 1 Pq uint
 Min time before inactive prefetch stream can be reclaimed
 .
 .It Sy zfetch_max_sec_reap Ns = Ns Sy 2 Pq uint
 Max time before inactive prefetch stream can be deleted
 .
 .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.5 KiB 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 u64
 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.
 .It Sy zfs_arc_dnode_limit_percent Ns = Ns Sy 10 Ns % Pq u64
 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 u64
 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 8 KiB Pc Pq uint
 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 1 MiB of hash table per 1 GiB 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 uint
 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 2 KiB
 that's evicted,
 .Em 1 KiB
 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 uint
 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 uint
 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 u64
 Max size of ARC in bytes.
 If
 .Sy 0 ,
 then the max size of ARC is determined by the amount of system memory installed.
 The larger of
 .Sy all_system_memory No \- Sy 1 GiB
 and
 .Sy 5/8 No \(mu Sy all_system_memory
 will be used as the limit.
 This value must be at least
 .Sy 67108864 Ns B Pq 64 MiB .
 .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_balance Ns = Ns Sy 500 Pq uint
 Balance between metadata and data on ghost hits.
 Values above 100 increase metadata caching by proportionally reducing effect
 of ghost data hits on target data/metadata rate.
 .
 .It Sy zfs_arc_min Ns = Ns Sy 0 Ns B Pq u64
 Min size of ARC in bytes.
 .No If set to Sy 0 , arc_c_min
 will default to consuming the larger of
 .Sy 32 MiB
 and
 .Sy all_system_memory No / Sy 32 .
 .
 .It Sy zfs_arc_min_prefetch_ms Ns = Ns Sy 0 Ns ms Ns Po Ns ≡ Ns 1s Pc Pq uint
 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 uint
 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_arc_prune_task_threads Ns = Ns Sy 1 Pq int
 Number of arc_prune threads.
 .Fx
 does not need more than one.
 Linux may theoretically use one per mount point up to number of CPUs,
 but that was not proven to be useful.
 .
 .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 u64
 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 128 MiB
 under Linux.
 .
 .It Sy zfs_multilist_num_sublists Ns = Ns Sy 0 Pq uint
 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 No >> Sy zfs_arc_overflow_shift ) No / Sy 2
 starts ARC reclamation process.
 If that appears insufficient, exceeding by
 .Sy ( arc_c No >> Sy zfs_arc_overflow_shift ) No \(mu Sy 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_shrink_shift Ns = Ns Sy 0 Pq uint
 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.
 To reduce OOM risk, this limit is applied for kswapd reclaims only.
 .Pp
 The default limit of
 .Sy 10000 Pq in practice, Em 160 MiB No per allocation attempt with 4 KiB pages
 limits the amount of time spent attempting to reclaim ARC memory to
 less than 100 ms per allocation attempt,
 even with a small average compressed block size of ~8 KiB.
 .Pp
 The parameter can be set to 0 (zero) to disable the limit,
 and only applies on Linux.
 .
 .It Sy zfs_arc_shrinker_seeks Ns = Ns Sy 2 Pq int
 Relative cost of ARC eviction on Linux, AKA number of seeks needed to
 restore evicted page.
 Bigger values make ARC more precious and evictions smaller, comparing to
 other kernel subsystems.
 Value of 4 means parity with page cache.
 .
 .It Sy zfs_arc_sys_free Ns = Ns Sy 0 Ns B Pq u64
 The target number of bytes the ARC should leave as free memory on the system.
 If zero, equivalent to the bigger of
 .Sy 512 KiB 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 10 Ns % Pq uint
 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 uint
 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 1 GiB Pc Pq u64
 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 128 KiB Pc Pq u64
 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 4 MiB Pc Pq uint
 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_checktime_ms Ns = Ns Sy 60000 Ns ms Po 1 min Pc Pq u64
 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_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/O operations only being logged.
 The deadman is automatically disabled when a pool gets suspended.
 .
 .It Sy zfs_deadman_events_per_second Ns = Ns Sy 1 Ns /s Pq int
 Rate limit deadman zevents (which report hung I/O operations) to this many per
 second.
 .
 .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_synctime_ms Ns = Ns Sy 600000 Ns ms Po 10 min Pc Pq u64
 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 5 min Pc Pq u64
 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_dedup_log_flush_passes_max Ns = Ns Sy 8 Ns Pq uint
 Maximum number of dedup log flush passes (iterations) each transaction.
 .Pp
 At the start of each transaction, OpenZFS will estimate how many entries it
 needs to flush out to keep up with the change rate, taking the amount and time
 taken to flush on previous txgs into account (see
 .Sy zfs_dedup_log_flush_flow_rate_txgs ) .
 It will spread this amount into a number of passes.
 At each pass, it will use the amount already flushed and the total time taken
 by flushing and by other IO to recompute how much it should do for the remainder
 of the txg.
 .Pp
 Reducing the max number of passes will make flushing more aggressive, flushing
 out more entries on each pass.
 This can be faster, but also more likely to compete with other IO.
 Increasing the max number of passes will put fewer entries onto each pass,
 keeping the overhead of dedup changes to a minimum but possibly causing a large
 number of changes to be dumped on the last pass, which can blow out the txg
 sync time beyond
 .Sy zfs_txg_timeout .
 .
 .It Sy zfs_dedup_log_flush_min_time_ms Ns = Ns Sy 1000 Ns Pq uint
 Minimum time to spend on dedup log flush each transaction.
 .Pp
 At least this long will be spent flushing dedup log entries each transaction,
 up to
 .Sy zfs_txg_timeout .
 This occurs even if doing so would delay the transaction, that is, other IO
 completes under this time.
 .
 .It Sy zfs_dedup_log_flush_entries_min Ns = Ns Sy 1000 Ns Pq uint
 Flush at least this many entries each transaction.
 .Pp
 OpenZFS will estimate how many entries it needs to flush each transaction to
 keep up with the ingest rate (see
 .Sy zfs_dedup_log_flush_flow_rate_txgs ) .
 This sets the minimum for that estimate.
 Raising it can force OpenZFS to flush more aggressively, keeping the log small
 and so reducing pool import times, but can make it less able to back off if
 log flushing would compete with other IO too much.
 .
 .It Sy zfs_dedup_log_flush_flow_rate_txgs Ns = Ns Sy 10 Ns Pq uint
 Number of transactions to use to compute the flow rate.
 .Pp
 OpenZFS will estimate how many entries it needs to flush each transaction by
 monitoring the number of entries changed (ingest rate), number of entries
 flushed (flush rate) and time spent flushing (flush time rate) and combining
 these into an overall "flow rate".
 It will use an exponential weighted moving average over some number of recent
 transactions to compute these rates.
 This sets the number of transactions to compute these averages over.
 Setting it higher can help to smooth out the flow rate in the face of spiky
 workloads, but will take longer for the flow rate to adjust to a sustained
 change in the ingress rate.
 .
 .It Sy zfs_dedup_log_txg_max Ns = Ns Sy 8 Ns Pq uint
 Max transactions to before starting to flush dedup logs.
 .Pp
 OpenZFS maintains two dedup logs, one receiving new changes, one flushing.
 If there is nothing to flush, it will accumulate changes for no more than this
 many transactions before switching the logs and starting to flush entries out.
 .
 .It Sy zfs_dedup_log_mem_max Ns = Ns Sy 0 Ns Pq u64
 Max memory to use for dedup logs.
 .Pp
 OpenZFS will spend no more than this much memory on maintaining the in-memory
 dedup log.
 Flushing will begin when around half this amount is being spent on logs.
 The default value of
 .Sy 0
 will cause it to be set by
 .Sy zfs_dedup_log_mem_max_percent
 instead.
 .
 .It Sy zfs_dedup_log_mem_max_percent Ns = Ns Sy 1 Ns % Pq uint
 Max memory to use for dedup logs, as a percentage of total memory.
 .Pp
 If
 .Sy zfs_dedup_log_mem_max
 is not set, it will be initialised as a percentage of the total memory in the
 system.
 .
 .It Sy zfs_delay_min_dirty_percent Ns = Ns Sy 60 Ns % Pq uint
 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 No \(mu Sy zfs_dirty_data_max Em must No be smaller than Sy 2^64 .
 .
 .It Sy zfs_dio_write_verify_events_per_second Ns = Ns Sy 20 Ns /s Pq uint
 Rate limit Direct I/O write verify events to this many per second.
 .
 .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 zevents (which report slow I/O operations) to this many per
 second.
 .
 .It Sy zfs_unflushed_max_mem_amt Ns = Ns Sy 1073741824 Ns B Po 1 GiB Pc Pq u64
 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 u64
 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 131072 Po 128k Pc Pq u64
 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 131072
 blocks (which means
 .Em 16 GiB
 of logical space before compression and ditto blocks,
 assuming that blocksize is
 .Em 128 KiB ) .
 .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/O operations 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 u64
 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 u64
 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
 unflushed metaslabs in the pool.
 .
 .It Sy zfs_unflushed_log_txg_max Ns = Ns Sy 1000 Pq u64
 Tunable limiting maximum time in TXGs any metaslab may remain unflushed.
 It effectively limits maximum number of unflushed per-TXG spacemap logs
 that need to be read after unclean pool export.
 .
 .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.
 This only applies on Linux.
 .
 .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 min(physical_ram/4, 4GiB) ,
 or
 .Sy min(physical_ram/4, 1GiB)
 for 32-bit systems.
 .
 .It Sy zfs_dirty_data_max_max_percent Ns = Ns Sy 25 Ns % Pq uint
 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 uint
 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 uint
 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_wrlog_data_max Ns = Pq int
 The upper limit of write-transaction zil log data size in bytes.
 Write operations are throttled when approaching the limit until log data is
 cleared out after transaction group sync.
 Because of some overhead, it should be set at least 2 times the size of
 .Sy zfs_dirty_data_max
 .No to prevent harming normal write throughput .
 It also should be smaller than the size of the slog device if slog is present.
 .Pp
 Defaults to
 .Sy zfs_dirty_data_max*2
 .
 .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_bclone_enabled Ns = Ns Sy 1 Ns | Ns 0 Pq int
 Enable the experimental block cloning feature.
 If this setting is 0, then even if feature@block_cloning is enabled,
 attempts to clone blocks will act as though the feature is disabled.
 .
 .It Sy zfs_bclone_wait_dirty Ns = Ns Sy 0 Ns | Ns 1 Pq int
 When set to 1 the FICLONE and FICLONERANGE ioctls wait for dirty data to be
 written to disk.
 This allows the clone operation to reliably succeed when a file is
 modified and then immediately cloned.
 For small files this may be slower than making a copy of the file.
 Therefore, this setting defaults to 0 which causes a clone operation to
 immediately fail when encountering a dirty block.
 .
 .It Sy zfs_blake3_impl Ns = Ns Sy fastest Pq string
 Select a BLAKE3 implementation.
 .Pp
 Supported selectors are:
 .Sy cycle , fastest , generic , sse2 , sse41 , avx2 , avx512 .
 All except
 .Sy cycle , fastest No and Sy generic
 require instruction set extensions to be available,
 and will only appear if ZFS detects that they are present at runtime.
 If multiple implementations of BLAKE3 are available, the
 .Sy fastest will be chosen using a micro benchmark. You can see the
 benchmark results by reading this kstat file:
 .Pa /proc/spl/kstat/zfs/chksum_bench .
 .
 .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 UINT64_MAX Po unlimited Pc Pq u64
 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 u64
 Maximum number of dedup blocks freed in a single TXG.
 .
 .It Sy zfs_vdev_async_read_max_active Ns = Ns Sy 3 Pq uint
 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 uint
 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 uint
 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 uint
 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 10 Pq uint
 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 uint
 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 uint
 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 uint
 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 uint
 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_open_timeout_ms Ns = Ns Sy 1000 Pq uint
 Timeout value to wait before determining a device is missing
 during import.
 This is helpful for transient missing paths due
 to links being briefly removed and recreated in response to
 udev events.
 .
 .It Sy zfs_vdev_rebuild_max_active Ns = Ns Sy 3 Pq uint
 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 uint
 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 uint
 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 uint
 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 uint
 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 uint
 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 uint
 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 uint
 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 uint
 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 uint
 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 uint
 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 uint
 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 uint
 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 operations 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 uint
 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 uint
 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_vdev_def_queue_depth Ns = Ns Sy 32 Pq uint
 Default queue depth for each vdev IO allocator.
 Higher values allow for better coalescing of sequential writes before sending
 them to the disk, but can increase transaction commit times.
 .
 .It Sy zfs_vdev_failfast_mask Ns = Ns Sy 1 Pq uint
 Defines if the driver should retire on a given error type.
 The following options may be bitwise-ored together:
 .TS
 box;
 lbz r l l .
 	Value	Name	Description
 _
 	1	Device	No driver retries on device errors
 	2	Transport	No driver retries on transport errors.
 	4	Driver	No driver retries on driver errors.
 .TE
 .
 .It Sy zfs_vdev_disk_max_segs Ns = Ns Sy 0 Pq uint
 Maximum number of segments to add to a BIO (min 4).
 If this is higher than the maximum allowed by the device queue or the kernel
 itself, it will be clamped.
 Setting it to zero will cause the kernel's ideal size to be used.
 This parameter only applies on Linux.
 This parameter is ignored if
 .Sy zfs_vdev_disk_classic Ns = Ns Sy 1 .
 .
 .It Sy zfs_vdev_disk_classic Ns = Ns Sy 0 Ns | Ns 1 Pq uint
 If set to 1, OpenZFS will submit IO to Linux using the method it used in 2.2
 and earlier.
 This "classic" method has known issues with highly fragmented IO requests and
 is slower on many workloads, but it has been in use for many years and is known
 to be very stable.
 If you set this parameter, please also open a bug report why you did so,
 including the workload involved and any error messages.
 .Pp
 This parameter and the classic submission method will be removed once we have
 total confidence in the new method.
 .Pp
 This parameter only applies on Linux, and can only be set at module load time.
 .
 .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_snapshot_no_setuid Ns = Ns Sy 0 Ns | Ns 1 Pq int
 Whether to disable
 .Em setuid/setgid
 support for snapshot mounts triggered by access to the
 .Sy .zfs/snapshot
 directory by setting the
 .Em nosuid
 mount option.
 .
 .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	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_btree_verify_intensity Ns = Ns Sy 0 Pq uint
 Enables btree verification.
 The following settings are culminative:
 .TS
 box;
 lbz r l l .
 	Value	Description
 
 	1	Verify height.
 	2	Verify pointers from children to parent.
 	3	Verify element counts.
 	4	Verify element order. (expensive)
 *	5	Verify unused memory is poisoned. (expensive)
 .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 uint
 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 uint
 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 32 KiB Pc Pq s64
 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 u64
 Pattern written to vdev free space by
 .Xr zpool-initialize 8 .
 .
 .It Sy zfs_initialize_chunk_size Ns = Ns Sy 1048576 Ns B Po 1 MiB Pc Pq u64
 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 u64
 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 \(em
 .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 u64
 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 100 MiB Pc Pq u64
 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 u64
 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 u64
 Maximum number of rows allowed in the summary of the spacemap log.
 .
 .It Sy zfs_max_recordsize Ns = Ns Sy 16777216 Po 16 MiB Pc Pq uint
 We currently support block sizes from
 .Em 512 Po 512 B Pc No to Em 16777216 Po 16 MiB Pc .
 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 formerly forbade creating blocks larger than 1M.
 Larger blocks could be created by changing it,
 and pools with larger blocks can always be imported and used,
 regardless of this setting.
 .Pp
 Note that it is still limited by default to
 .Ar 1 MiB
 on x86_32, because Linux's
 3/1 memory split doesn't leave much room for 16M chunks.
 .
 .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 u64
 Minimum number of metaslabs to flush per dirty TXG.
 .
 .It Sy zfs_metaslab_fragmentation_threshold Ns = Ns Sy 70 Ns % Pq uint
 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 uint
 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 uint
 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 uint
 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 1 s Pc Pq u64
 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 No / Sy 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 No \(mu Sy 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 100 ms
 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 No \(mu Sy 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 1 Ns | Ns 0 Pq int
 Enable forcing TXG sync to find holes.
 When enabled forces ZFS to sync data when
 .Sy SEEK_HOLE No or Sy SEEK_DATA
 flags are used allowing holes in a file to be accurately reported.
 When disabled holes will not be reported in recently dirtied files.
 .
 .It Sy zfs_pd_bytes_max Ns = Ns Sy 52428800 Ns B Po 50 MiB 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 uint
 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 30 Ns % Pq u64
 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
 .Pq 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 1 MiB Pc Pq u64
 Bytes to read per chunk.
 .
 .It Sy zfs_read_history Ns = Ns Sy 0 Pq uint
 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 1 MiB Pc Pq u64
 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 67108864 Ns B Po 64 MiB Pc Pq u64
 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 I/O errors during device removal.
 When set, if a device encounters a hard I/O 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 uint
 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 16 MiB Pc Pq uint
 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_defer_percent Ns = Ns Sy 10 Ns % Pq uint
 If the ongoing resilver progress is below this threshold, a new resilver will
 restart from scratch instead of being deferred after the current one finishes,
 even if the
 .Sy resilver_defer
 feature is enabled.
 .
 .It Sy zfs_resilver_min_time_ms Ns = Ns Sy 3000 Ns ms Po 3 s Pc Pq uint
 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_after_expand Ns = Ns Sy 1 Ns | Ns 0 Pq int
 Automatically start a pool scrub after a RAIDZ expansion completes
 in order to verify the checksums of all blocks which have been
 copied during the expansion.
 This is enabled by default and strongly recommended.
 .
 .It Sy zfs_scrub_min_time_ms Ns = Ns Sy 1000 Ns ms Po 1 s Pc Pq uint
 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_scrub_error_blocks_per_txg Ns = Ns Sy 4096 Pq uint
 Error blocks to be scrubbed in one txg.
 .
 .It Sy zfs_scan_checkpoint_intval Ns = Ns Sy 7200 Ns s Po 2 hour Pc Pq uint
 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 uint
 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 effect on scrub or resilver
 performance.
 .
 .It Sy zfs_scan_issue_strategy Ns = Ns Sy 0 Pq uint
 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 2 MiB 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 uint
 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 uint
 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_report_txgs Ns = Ns Sy 0 Ns | Ns 1 Pq uint
 When reporting resilver throughput and estimated completion time use the
 performance observed over roughly the last
 .Sy zfs_scan_report_txgs
 TXGs.
 When set to zero performance is calculated over the time between checkpoints.
 .
 .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 16777216 Ns B Po 16 MiB 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 uint
 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 1 MiB Pc Pq uint
 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 uint
 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 16 MiB Pc Pq uint
 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 uint
 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 16 MiB Pc Pq uint
 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 1 MiB Pc Pq uint
 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 32 MiB .
 .
 .It Sy zfs_recv_best_effort_corrective Ns = Ns Sy 0 Pq int
 When this variable is set to non-zero a corrective receive:
 .Bl -enum -compact -offset 4n -width "1."
 .It
 Does not enforce the restriction of source & destination snapshot GUIDs
 matching.
 .It
 If there is an error during healing, the healing receive is not
 terminated instead it moves on to the next record.
 .El
 .
 .It Sy zfs_override_estimate_recordsize Ns = Ns Sy 0 Ns | Ns 1 Pq uint
 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 uint
 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 16 MiB 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 uint
 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 uint
 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 128 KiB
 allocations (e.g. for indirect blocks and spacemaps)
 because these will not be compressed.
 The
 .Em 128 KiB
 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 uint
 Rewrite new block pointers starting in this pass.
 .
 .It Sy zfs_trim_extent_bytes_max Ns = Ns Sy 134217728 Ns B Po 128 MiB 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 32 KiB 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 100 Pq uint
 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 uint
 Flush dirty data to disk at least every this many seconds (maximum TXG
 duration).
 .
 .It Sy zfs_vdev_aggregation_limit Ns = Ns Sy 1048576 Ns B Po 1 MiB Pc Pq uint
 Max vdev I/O aggregation size.
 .
 .It Sy zfs_vdev_aggregation_limit_non_rotating Ns = Ns Sy 131072 Ns B Po 128 KiB Pc Pq uint
 Max vdev I/O aggregation size for non-rotating media.
 .
 .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 1 MiB 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 32 KiB Pc Pq uint
 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 4 KiB Pc Pq uint
 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 uint
 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 15 min 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 128 KiB Pc Pq uint
 This sets the maximum block size used by the ZIL.
 On very fragmented pools, lowering this
 .Pq typically to Sy 36 KiB
 can improve performance.
 .
 .It Sy zil_maxcopied Ns = Ns Sy 7680 Ns B Po 7.5 KiB Pc Pq uint
 This sets the maximum number of write bytes logged via WR_COPIED.
 It tunes a tradeoff between additional memory copy and possibly worse log
 space efficiency vs additional range lock/unlock.
 .
 .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 67108864 Ns B Po 64 MiB Pc Pq u64
 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_zil_saxattr Ns = Ns Sy 1 Ns | Ns 0 Pq int
 Setting this tunable to zero disables ZIL logging of new
 .Sy xattr Ns = Ns Sy sa
 records if the
 .Sy org.openzfs:zilsaxattr
 feature is enabled on the pool.
 This would only be necessary to work around bugs in the ZIL logging or replay
 code for this record type.
 The tunable has no effect if the feature is disabled.
 .
 .It Sy zfs_embedded_slog_min_ms Ns = Ns Sy 64 Pq uint
 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 zstd_earlyabort_pass Ns = Ns Sy 1 Pq uint
 Whether heuristic for detection of incompressible data with zstd levels >= 3
 using LZ4 and zstd-1 passes is enabled.
 .
 .It Sy zstd_abort_size Ns = Ns Sy 131072 Pq uint
 Minimal uncompressed size (inclusive) of a record before the early abort
 heuristic will be attempted.
 .
 .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 30 s 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 zfs_xattr_compat Ns = Ns 0 Ns | Ns 1 Pq int
 Control the naming scheme used when setting new xattrs in the user namespace.
 If
 .Sy 0
 .Pq the default on Linux ,
 user namespace xattr names are prefixed with the namespace, to be backwards
 compatible with previous versions of ZFS on Linux.
 If
 .Sy 1
 .Pq the default on Fx ,
 user namespace xattr names are not prefixed, to be backwards compatible with
 previous versions of ZFS on illumos and
 .Fx .
 .Pp
 Either naming scheme can be read on this and future versions of ZFS, regardless
 of this tunable, but legacy ZFS on illumos or
 .Fx
 are unable to read user namespace xattrs written in the Linux format, and
 legacy versions of ZFS on Linux are unable to read user namespace xattrs written
 in the legacy ZFS format.
 .Pp
 An existing xattr with the alternate naming scheme is removed when overwriting
 the xattr so as to not accumulate duplicates.
 .
 .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, encryption,
 checksum and parity 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.
 Set value only applies to pools imported/created after that.
 .
 .It Sy zio_taskq_batch_tpq Ns = Ns Sy 0 Pq uint
 Number of worker threads per taskq.
 Higher values improve I/O ordering and CPU utilization,
 while lower reduce lock contention.
 Set value only applies to pools imported/created after that.
 .Pp
 If
 .Sy 0 ,
 generate a system-dependent value close to 6 threads per taskq.
 Set value only applies to pools imported/created after that.
 .
 .It Sy zio_taskq_write_tpq Ns = Ns Sy 16 Pq uint
 Determines the minumum number of threads per write issue taskq.
 Higher values improve CPU utilization on high throughput,
 while lower reduce taskq locks contention on high IOPS.
 Set value only applies to pools imported/created after that.
 .
 .It Sy zio_taskq_read Ns = Ns Sy fixed,1,8 null scale null Pq charp
 Set the queue and thread configuration for the IO read queues.
 This is an advanced debugging parameter.
 Don't change this unless you understand what it does.
 Set values only apply to pools imported/created after that.
 .
 .It Sy zio_taskq_write Ns = Ns Sy sync null scale null Pq charp
 Set the queue and thread configuration for the IO write queues.
 This is an advanced debugging parameter.
 Don't change this unless you understand what it does.
 Set values only apply to pools imported/created after that.
 .
 .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 long
 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 128 KiB 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 .
 .Sy zvol_request_sync
 is ignored when running on a kernel that supports block multiqueue
 .Pq Li blk-mq .
 .
 .It Sy zvol_num_taskqs Ns = Ns Sy 0 Pq uint
 Number of zvol taskqs.
 If
 .Sy 0
 (the default) then scaling is done internally to prefer 6 threads per taskq.
 This only applies on Linux.
 .
 .It Sy zvol_threads Ns = Ns Sy 0 Pq uint
 The number of system wide threads to use for processing zvol block IOs.
 If
 .Sy 0
 (the default) then internally set
 .Sy zvol_threads
 to the number of CPUs present or 32 (whichever is greater).
 .
 .It Sy zvol_blk_mq_threads Ns = Ns Sy 0 Pq uint
 The number of threads per zvol to use for queuing IO requests.
 This parameter will only appear if your kernel supports
 .Li blk-mq
 and is only read and assigned to a zvol at zvol load time.
 If
 .Sy 0
 (the default) then internally set
 .Sy zvol_blk_mq_threads
 to the number of CPUs present.
 .
 .It Sy zvol_use_blk_mq Ns = Ns Sy 0 Ns | Ns 1 Pq uint
 Set to
 .Sy 1
 to use the
 .Li blk-mq
 API for zvols.
 Set to
 .Sy 0
 (the default) to use the legacy zvol APIs.
 This setting can give better or worse zvol performance depending on
 the workload.
 This parameter will only appear if your kernel supports
 .Li blk-mq
 and is only read and assigned to a zvol at zvol load time.
 .
 .It Sy zvol_blk_mq_blocks_per_thread Ns = Ns Sy 8 Pq uint
 If
 .Sy zvol_use_blk_mq
 is enabled, then process this number of
 .Sy volblocksize Ns -sized blocks per zvol thread.
 This tunable can be use to favor better performance for zvol reads (lower
 values) or writes (higher values).
 If set to
 .Sy 0 ,
 then the zvol layer will process the maximum number of blocks
 per thread that it can.
 This parameter will only appear if your kernel supports
 .Li blk-mq
 and is only applied at each zvol's load time.
 .
 .It Sy zvol_blk_mq_queue_depth Ns = Ns Sy 0 Pq uint
 The queue_depth value for the zvol
 .Li blk-mq
 interface.
 This parameter will only appear if your kernel supports
 .Li blk-mq
 and is only applied at each zvol's load time.
 If
 .Sy 0
 (the default) then use the kernel's default queue depth.
 Values are clamped to the kernel's
 .Dv BLKDEV_MIN_RQ
 and
 .Dv BLKDEV_MAX_RQ Ns / Ns Dv BLKDEV_DEFAULT_RQ
 limits.
 .
 .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
 .
 .It Sy zvol_enforce_quotas Ns = Ns Sy 0 Ns | Ns 1 Pq uint
 Enable strict ZVOL quota enforcement.
 The strict quota enforcement may have a performance impact.
 .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 simultaneous operations also stabilizes the
 response time of operations from other queues, in particular synchronous ones.
 In broad strokes, the I/O scheduler will issue more concurrent operations
 from the async write queue as there is 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
 .D1 min_time = min( Ns Sy zfs_delay_scale No \(mu Po Sy dirty No \- Sy min Pc / Po Sy max No \- Sy dirty Pc , 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 500 us
 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/man/man5/vdev_id.conf.5 b/sys/contrib/openzfs/man/man5/vdev_id.conf.5
index a2d38add4ee0..aaf91825a6c6 100644
--- a/sys/contrib/openzfs/man/man5/vdev_id.conf.5
+++ b/sys/contrib/openzfs/man/man5/vdev_id.conf.5
@@ -1,249 +1,257 @@
 .\"
 .\" 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.
 .\"
 .Dd May 26, 2021
 .Dt VDEV_ID.CONF 5
 .Os
 .
 .Sh NAME
 .Nm vdev_id.conf
 .Nd configuration file for vdev_id(8)
 .Sh DESCRIPTION
 .Nm
 is the configuration file for
 .Xr vdev_id 8 .
 It controls the default behavior of
 .Xr vdev_id 8
 while it is mapping a disk device name to an alias.
 .Pp
 The
 .Nm
 file uses a simple format consisting of a keyword followed by one or
 more values on a single line.
 Any line not beginning with a recognized keyword is ignored.
 Comments may optionally begin with a hash character.
 .Pp
 The following keywords and values are used.
 .Bl -tag -width "-h"
 .It Sy alias Ar name Ar devlink
 Maps a device link in the
 .Pa /dev
 directory hierarchy to a new device name.
 The udev rule defining the device link must have run prior to
 .Xr vdev_id 8 .
 A defined alias takes precedence over a topology-derived name, but the
 two naming methods can otherwise coexist.
 For example, one might name drives in a JBOD with the
 .Sy sas_direct
 topology while naming an internal L2ARC device with an alias.
 .Pp
 .Ar name
 is the name of the link to the device that will by created under
 .Pa /dev/disk/by-vdev .
 .Pp
 .Ar devlink
 is the name of the device link that has already been
 defined by udev.
 This may be an absolute path or the base filename.
 .
 .It Sy channel [ Ns Ar pci_slot ] Ar port Ar name
 Maps a physical path to a channel name (typically representing a single
 disk enclosure).
 .
 .It Sy enclosure_symlinks Sy yes Ns | Ns Sy no
 Additionally create
 .Pa /dev/by-enclosure
 symlinks to the disk enclosure
 .Em sg
 devices using the naming scheme from
 .Pa vdev_id.conf .
 .Sy enclosure_symlinks
 is only allowed for
 .Sy sas_direct
 mode.
 .
 .It Sy enclosure_symlinks_prefix Ar prefix
 Specify the prefix for the enclosure symlinks in the form
 .Pa /dev/by-enclosure/ Ns Ao Ar prefix Ac Ns - Ns Ao Ar channel Ac Ns Aq Ar num
 .Pp
 Defaults to
 .Dq Em enc .
 .
 .It Sy slot Ar prefix Ar new Op Ar channel
 Maps a disk slot number as reported by the operating system to an
 alternative slot number.
 If the
 .Ar channel
 parameter is specified
 then the mapping is only applied to slots in the named channel,
 otherwise the mapping is applied to all channels.
 The first-specified
 .Ar slot
 rule that can match a slot takes precedence.
 Therefore a channel-specific mapping for a given slot should generally appear
 before a generic mapping for the same slot.
 In this way a custom mapping may be applied to a particular channel
 and a default mapping applied to the others.
 .
+.It Sy zpad_slot Ar digits
+Pad slot numbers with zeros to make them
+.Ar digits
+long, which can help to make disk names a consistent length and easier to sort.
+.
 .It Sy multipath Sy yes Ns | Ns Sy no
 Specifies whether
 .Xr vdev_id 8
 will handle only dm-multipath devices.
 If set to
 .Sy yes
 then
 .Xr vdev_id 8
 will examine the first running component disk of a dm-multipath
 device as provided by the driver command to determine the physical path.
 .
 .It Sy topology Sy sas_direct Ns | Ns Sy sas_switch Ns | Ns Sy scsi
 Identifies a physical topology that governs how physical paths are
 mapped to channels:
 .Bl -tag -compact -width "sas_direct and scsi"
 .It Sy sas_direct No and Sy scsi
 channels are uniquely identified by a PCI slot and HBA port number
 .It Sy sas_switch
 channels are uniquely identified by a SAS switch port number
 .El
 .
 .It Sy phys_per_port Ar num
 Specifies the number of PHY devices associated with a SAS HBA port or SAS
 switch port.
 .Xr vdev_id 8
 internally uses this value to determine which HBA or switch port a
 device is connected to.
 The default is
 .Sy 4 .
 .
-.It Sy slot Sy bay Ns | Ns Sy phy Ns | Ns Sy port Ns | Ns Sy id Ns | Ns Sy lun Ns | Ns Sy ses
+.It Sy slot Sy bay Ns | Ns Sy phy Ns | Ns Sy port Ns | Ns Sy id Ns | Ns Sy lun Ns | Ns Sy bay_lun Ns | Ns Sy ses
 Specifies from which element of a SAS identifier the slot number is
 taken.
 The default is
 .Sy bay :
 .Bl -tag -compact -width "port"
 .It Sy bay
 read the slot number from the bay identifier.
 .It Sy phy
 read the slot number from the phy identifier.
 .It Sy port
 use the SAS port as the slot number.
 .It Sy id
 use the scsi id as the slot number.
 .It Sy lun
 use the scsi lun as the slot number.
+.It Sy bay_lun
+read the slot number from the bay identifier and append the lun number.
+Useful for multi-lun multi-actuator hard drives.
 .It Sy ses
 use the SCSI Enclosure Services (SES) enclosure device slot number,
 as reported by
 .Xr sg_ses 8 .
 Intended for use only on systems where
 .Sy bay
 is unsupported,
 noting that
 .Sy port
 and
 .Sy id
 may be unstable across disk replacement.
 .El
 .El
 .
 .Sh FILES
 .Bl -tag -width "-v v"
 .It Pa /etc/zfs/vdev_id.conf
 The configuration file for
 .Xr vdev_id 8 .
 .El
 .
 .Sh EXAMPLES
 A non-multipath configuration with direct-attached SAS enclosures and an
 arbitrary slot re-mapping:
 .Bd -literal -compact -offset Ds
 multipath     no
 topology      sas_direct
 phys_per_port 4
 slot          bay
 
 #       PCI_SLOT 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
 .Ed
 .Pp
 A SAS-switch topology.
 Note, that the
 .Ar channel
 keyword takes only two arguments in this example:
 .Bd -literal -compact -offset Ds
 topology      sas_switch
 
 #       SWITCH PORT  CHANNEL NAME
 channel 1            A
 channel 2            B
 channel 3            C
 channel 4            D
 .Ed
 .Pp
 A multipath configuration.
 Note that channel names have multiple definitions - one per physical path:
 .Bd -literal -compact -offset Ds
 multipath yes
 
 #       PCI_SLOT 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
 .Ed
 .Pp
 A configuration with enclosure_symlinks enabled:
 .Bd -literal -compact -offset Ds
 multipath yes
 enclosure_symlinks yes
 
 #          PCI_ID      HBA PORT     CHANNEL NAME
 channel    05:00.0     1            U
 channel    05:00.0     0            L
 channel    06:00.0     1            U
 channel    06:00.0     0            L
 .Ed
 In addition to the disks symlinks, this configuration will create:
 .Bd -literal -compact -offset Ds
 /dev/by-enclosure/enc-L0
 /dev/by-enclosure/enc-L1
 /dev/by-enclosure/enc-U0
 /dev/by-enclosure/enc-U1
 .Ed
 .Pp
 A configuration using device link aliases:
 .Bd -literal -compact -offset Ds
 #     by-vdev
 #     name     fully qualified or base name of device link
 alias d1       /dev/disk/by-id/wwn-0x5000c5002de3b9ca
 alias d2       wwn-0x5000c5002def789e
 .Ed
 .
 .Sh SEE ALSO
 .Xr vdev_id 8
diff --git a/sys/contrib/openzfs/man/man8/zfs-list.8 b/sys/contrib/openzfs/man/man8/zfs-list.8
index b49def08b72b..0fa7e9cc2613 100644
--- a/sys/contrib/openzfs/man/man8/zfs-list.8
+++ b/sys/contrib/openzfs/man/man8/zfs-list.8
@@ -1,353 +1,353 @@
 .\"
 .\" CDDL HEADER START
 .\"
 .\" The contents of this file are subject to the terms of the
 .\" Common Development and Distribution License (the "License").
 .\" You may not use this file except in compliance with the License.
 .\"
 .\" You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 .\" or https://opensource.org/licenses/CDDL-1.0.
 .\" See the License for the specific language governing permissions
 .\" and limitations under the License.
 .\"
 .\" When distributing Covered Code, include this CDDL HEADER in each
 .\" file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 .\" If applicable, add the following below this CDDL HEADER, with the
 .\" fields enclosed by brackets "[]" replaced with your own identifying
 .\" information: Portions Copyright [yyyy] [name of copyright owner]
 .\"
 .\" CDDL HEADER END
 .\"
 .\" Copyright (c) 2009 Sun Microsystems, Inc. All Rights Reserved.
 .\" Copyright 2011 Joshua M. Clulow <josh@sysmgr.org>
 .\" Copyright (c) 2011, 2019 by Delphix. All rights reserved.
 .\" Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
 .\" Copyright (c) 2014, Joyent, Inc. All rights reserved.
 .\" Copyright (c) 2014 by Adam Stevko. All rights reserved.
 .\" Copyright (c) 2014 Integros [integros.com]
 .\" Copyright 2019 Richard Laager. All rights reserved.
 .\" Copyright 2018 Nexenta Systems, Inc.
 .\" Copyright 2019 Joyent, Inc.
 .\"
 .Dd February 8, 2024
 .Dt ZFS-LIST 8
 .Os
 .
 .Sh NAME
 .Nm zfs-list
 .Nd list properties of ZFS datasets
 .Sh SYNOPSIS
 .Nm zfs
 .Cm list
 .Op Fl r Ns | Ns Fl d Ar depth
 .Op Fl Hp
 .Op Fl j Op Ar --json-int
 .Oo Fl o Ar property Ns Oo , Ns Ar property Oc Ns … Oc
 .Oo Fl s Ar property Oc Ns …
 .Oo Fl S Ar property Oc Ns …
 .Oo Fl t Ar type Ns Oo , Ns Ar type Oc Ns … Oc
 .Oo Ar filesystem Ns | Ns Ar volume Ns | Ns Ar snapshot Oc Ns …
 .
 .Sh DESCRIPTION
 If specified, you can list property information by the absolute pathname or the
 relative pathname.
 By default, all file systems and volumes are displayed.
 Snapshots are displayed if the
 .Sy listsnapshots
 pool property is
 .Sy on
 .Po the default is
 .Sy off
 .Pc ,
 or if the
 .Fl t Sy snapshot
 or
 .Fl t Sy all
 options are specified.
 The following fields are displayed:
 .Sy name , Sy used , Sy available , Sy referenced , Sy mountpoint .
 .Bl -tag -width "-H"
 .It Fl H
 Used for scripting mode.
 Do not print headers and separate fields by a single tab instead of arbitrary
 white space.
-.It Fl j Op Ar --json-int
+.It Fl j , -json Op Ar --json-int
 Print the output in JSON format.
 Specify
 .Sy --json-int
 to print the numbers in integer format instead of strings in JSON output.
 .It Fl d Ar depth
 Recursively display any children of the dataset, limiting the recursion to
 .Ar depth .
 A
 .Ar depth
 of
 .Sy 1
 will display only the dataset and its direct children.
 .It Fl o Ar property
 A comma-separated list of properties to display.
 The property must be:
 .Bl -bullet -compact
 .It
 One of the properties described in the
 .Sx Native Properties
 section of
 .Xr zfsprops 7
 .It
 A user property
 .It
 The value
 .Sy name
 to display the dataset name
 .It
 The value
 .Sy space
 to display space usage properties on file systems and volumes.
 This is a shortcut for specifying
 .Fl o Ns \ \& Ns Sy name , Ns Sy avail , Ns Sy used , Ns Sy usedsnap , Ns
 .Sy usedds , Ns Sy usedrefreserv , Ns Sy usedchild
 .Fl t Sy filesystem , Ns Sy volume .
 .El
 .It Fl p
 Display numbers in parsable
 .Pq exact
 values.
 .It Fl r
 Recursively display any children of the dataset on the command line.
 .It Fl s Ar property
 A property for sorting the output by column in ascending order based on the
 value of the property.
 The property must be one of the properties described in the
 .Sx Properties
 section of
 .Xr zfsprops 7
 or the value
 .Sy name
 to sort by the dataset name.
 Multiple properties can be specified at one time using multiple
 .Fl s
 property options.
 Multiple
 .Fl s
 options are evaluated from left to right in decreasing order of importance.
 The following is a list of sorting criteria:
 .Bl -bullet -compact
 .It
 Numeric types sort in numeric order.
 .It
 String types sort in alphabetical order.
 .It
 Types inappropriate for a row sort that row to the literal bottom, regardless of
 the specified ordering.
 .El
 .Pp
 If no sorting options are specified the existing behavior of
 .Nm zfs Cm list
 is preserved.
 .It Fl S Ar property
 Same as
 .Fl s ,
 but sorts by property in descending order.
 .It Fl t Ar type
 A comma-separated list of types to display, where
 .Ar type
 is one of
 .Sy filesystem ,
 .Sy snapshot ,
 .Sy volume ,
 .Sy bookmark ,
 or
 .Sy all .
 For example, specifying
 .Fl t Sy snapshot
 displays only snapshots.
 .Sy fs ,
 .Sy snap ,
 or
 .Sy vol
 can be used as aliases for
 .Sy filesystem ,
 .Sy snapshot ,
 or
 .Sy volume .
 .El
 .
 .Sh EXAMPLES
 .\" These are, respectively, examples 5 from zfs.8
 .\" Make sure to update them bidirectionally
 .Ss Example 1 : No Listing ZFS Datasets
 The following command lists all active file systems and volumes in the system.
 Snapshots are displayed if
 .Sy listsnaps Ns = Ns Sy on .
 The default is
 .Sy off .
 See
 .Xr zpoolprops 7
 for more information on pool properties.
 .Bd -literal -compact -offset Ds
 .No # Nm zfs Cm list
 NAME                      USED  AVAIL  REFER  MOUNTPOINT
 pool                      450K   457G    18K  /pool
 pool/home                 315K   457G    21K  /export/home
 pool/home/anne             18K   457G    18K  /export/home/anne
 pool/home/bob             276K   457G   276K  /export/home/bob
 .Ed
 .Ss Example 2 : No Listing ZFS filesystems and snapshots in JSON format
 .Bd -literal -compact -offset Ds
 .No # Nm zfs Cm list Fl j Fl t Ar filesystem,snapshot | Cm jq
 {
   "output_version": {
     "command": "zfs list",
     "vers_major": 0,
     "vers_minor": 1
   },
   "datasets": {
     "pool": {
       "name": "pool",
       "type": "FILESYSTEM",
       "pool": "pool",
       "properties": {
         "used": {
           "value": "290K",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "available": {
           "value": "30.5G",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "referenced": {
           "value": "24K",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "mountpoint": {
           "value": "/pool",
           "source": {
             "type": "DEFAULT",
             "data": "-"
           }
         }
       }
     },
     "pool/home": {
       "name": "pool/home",
       "type": "FILESYSTEM",
       "pool": "pool",
       "properties": {
         "used": {
           "value": "48K",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "available": {
           "value": "30.5G",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "referenced": {
           "value": "24K",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "mountpoint": {
           "value": "/mnt/home",
           "source": {
             "type": "LOCAL",
             "data": "-"
           }
         }
       }
     },
     "pool/home/bob": {
       "name": "pool/home/bob",
       "type": "FILESYSTEM",
       "pool": "pool",
       "properties": {
         "used": {
           "value": "24K",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "available": {
           "value": "30.5G",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "referenced": {
           "value": "24K",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "mountpoint": {
           "value": "/mnt/home/bob",
           "source": {
             "type": "INHERITED",
             "data": "pool/home"
           }
         }
       }
     },
     "pool/home/bob@v1": {
       "name": "pool/home/bob@v1",
       "type": "SNAPSHOT",
       "pool": "pool",
       "dataset": "pool/home/bob",
       "snapshot_name": "v1",
       "properties": {
         "used": {
           "value": "0B",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "available": {
           "value": "-",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "referenced": {
           "value": "24K",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "mountpoint": {
           "value": "-",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         }
       }
     }
   }
 }
 .Ed
 .
 .Sh SEE ALSO
 .Xr zfsprops 7 ,
 .Xr zfs-get 8
diff --git a/sys/contrib/openzfs/man/man8/zfs-mount.8 b/sys/contrib/openzfs/man/man8/zfs-mount.8
index 6116fbaab77f..921e2499e31b 100644
--- a/sys/contrib/openzfs/man/man8/zfs-mount.8
+++ b/sys/contrib/openzfs/man/man8/zfs-mount.8
@@ -1,139 +1,139 @@
 .\"
 .\" CDDL HEADER START
 .\"
 .\" The contents of this file are subject to the terms of the
 .\" Common Development and Distribution License (the "License").
 .\" You may not use this file except in compliance with the License.
 .\"
 .\" You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 .\" or https://opensource.org/licenses/CDDL-1.0.
 .\" See the License for the specific language governing permissions
 .\" and limitations under the License.
 .\"
 .\" When distributing Covered Code, include this CDDL HEADER in each
 .\" file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 .\" If applicable, add the following below this CDDL HEADER, with the
 .\" fields enclosed by brackets "[]" replaced with your own identifying
 .\" information: Portions Copyright [yyyy] [name of copyright owner]
 .\"
 .\" CDDL HEADER END
 .\"
 .\" Copyright (c) 2009 Sun Microsystems, Inc. All Rights Reserved.
 .\" Copyright 2011 Joshua M. Clulow <josh@sysmgr.org>
 .\" Copyright (c) 2011, 2019 by Delphix. All rights reserved.
 .\" Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
 .\" Copyright (c) 2014, Joyent, Inc. All rights reserved.
 .\" Copyright (c) 2014 by Adam Stevko. All rights reserved.
 .\" Copyright (c) 2014 Integros [integros.com]
 .\" Copyright 2019 Richard Laager. All rights reserved.
 .\" Copyright 2018 Nexenta Systems, Inc.
 .\" Copyright 2019 Joyent, Inc.
 .\"
 .Dd February 16, 2019
 .Dt ZFS-MOUNT 8
 .Os
 .
 .Sh NAME
 .Nm zfs-mount
 .Nd manage mount state of ZFS filesystems
 .Sh SYNOPSIS
 .Nm zfs
 .Cm mount
 .Op Fl j
 .Nm zfs
 .Cm mount
 .Op Fl Oflv
 .Op Fl o Ar options
 .Fl a Ns | Ns Fl R Ar filesystem Ns | Ns Ar filesystem
 .Nm zfs
 .Cm unmount
 .Op Fl fu
 .Fl a Ns | Ns Ar filesystem Ns | Ns Ar mountpoint
 .
 .Sh DESCRIPTION
 .Bl -tag -width ""
 .It Xo
 .Nm zfs
 .Cm mount
 .Op Fl j
 .Xc
 Displays all ZFS file systems currently mounted.
 .Bl -tag -width "-j"
-.It Fl j
+.It Fl j , -json
 Displays all mounted file systems in JSON format.
 .El
 .It Xo
 .Nm zfs
 .Cm mount
 .Op Fl Oflv
 .Op Fl o Ar options
 .Fl a Ns | Ns Fl R Ar filesystem Ns | Ns Ar filesystem
 .Xc
 Mount ZFS filesystem on a path described by its
 .Sy mountpoint
 property, if the path exists and is empty.
 If
 .Sy mountpoint
 is set to
 .Em legacy ,
 the filesystem should be instead mounted using
 .Xr mount 8 .
 .Bl -tag -width "-O"
 .It Fl O
 Perform an overlay mount.
 Allows mounting in non-empty
 .Sy mountpoint .
 See
 .Xr mount 8
 for more information.
 .It Fl a
 Mount all available ZFS file systems.
 Invoked automatically as part of the boot process if configured.
 .It Fl R
 Mount the specified filesystems along with all their children.
 .It Ar filesystem
 Mount the specified filesystem.
 .It Fl o Ar options
 An optional, comma-separated list of mount options to use temporarily for the
 duration of the mount.
 See the
 .Em Temporary Mount Point Properties
 section of
 .Xr zfsprops 7
 for details.
 .It Fl l
 Load keys for encrypted filesystems as they are being mounted.
 This is equivalent to executing
 .Nm zfs Cm load-key
 on each encryption root before mounting it.
 Note that if a filesystem has
 .Sy keylocation Ns = Ns Sy prompt ,
 this will cause the terminal to interactively block after asking for the key.
 .It Fl v
 Report mount progress.
 .It Fl f
 Attempt to force mounting of all filesystems, even those that couldn't normally
 be mounted (e.g. redacted datasets).
 .El
 .It Xo
 .Nm zfs
 .Cm unmount
 .Op Fl fu
 .Fl a Ns | Ns Ar filesystem Ns | Ns Ar mountpoint
 .Xc
 Unmounts currently mounted ZFS file systems.
 .Bl -tag -width "-a"
 .It Fl a
 Unmount all available ZFS file systems.
 Invoked automatically as part of the shutdown process.
 .It Fl f
 Forcefully unmount the file system, even if it is currently in use.
 This option is not supported on Linux.
 .It Fl u
 Unload keys for any encryption roots unmounted by this command.
 .It Ar filesystem Ns | Ns Ar mountpoint
 Unmount the specified filesystem.
 The command can also be given a path to a ZFS file system mount point on the
 system.
 .El
 .El
diff --git a/sys/contrib/openzfs/man/man8/zfs-program.8 b/sys/contrib/openzfs/man/man8/zfs-program.8
index 928620362be7..460cd2e11cf3 100644
--- a/sys/contrib/openzfs/man/man8/zfs-program.8
+++ b/sys/contrib/openzfs/man/man8/zfs-program.8
@@ -1,644 +1,644 @@
 .\"
 .\" This file and its contents are supplied under the terms of the
 .\" Common Development and Distribution License ("CDDL"), version 1.0.
 .\" You may only use this file in accordance with the terms of version
 .\" 1.0 of the CDDL.
 .\"
 .\" A full copy of the text of the CDDL should have accompanied this
 .\" source.  A copy of the CDDL is also available via the Internet at
 .\" http://www.illumos.org/license/CDDL.
 .\"
 .\" Copyright (c) 2016, 2019 by Delphix. All Rights Reserved.
 .\" Copyright (c) 2019, 2020 by Christian Schwarz. All Rights Reserved.
 .\" Copyright 2020 Joyent, Inc.
 .\"
 .Dd May 27, 2021
 .Dt ZFS-PROGRAM 8
 .Os
 .
 .Sh NAME
 .Nm zfs-program
 .Nd execute ZFS channel programs
 .Sh SYNOPSIS
 .Nm zfs
 .Cm program
 .Op Fl jn
 .Op Fl t Ar instruction-limit
 .Op Fl m Ar memory-limit
 .Ar pool
 .Ar script
 .Op Ar script arguments
 .
 .Sh DESCRIPTION
 The ZFS channel program interface allows ZFS administrative operations to be
 run programmatically as a Lua script.
 The entire script is executed atomically, with no other administrative
 operations taking effect concurrently.
 A library of ZFS calls is made available to channel program scripts.
 Channel programs may only be run with root privileges.
 .Pp
 A modified version of the Lua 5.2 interpreter is used to run channel program
 scripts.
 The Lua 5.2 manual can be found at
 .Lk http://www.lua.org/manual/5.2/
 .Pp
 The channel program given by
 .Ar script
 will be run on
 .Ar pool ,
 and any attempts to access or modify other pools will cause an error.
 .
 .Sh OPTIONS
 .Bl -tag -width "-t"
-.It Fl j
+.It Fl j , -json
 Display channel program output in JSON format.
 When this flag is specified and standard output is empty -
 channel program encountered an error.
 The details of such an error will be printed to standard error in plain text.
 .It Fl n
 Executes a read-only channel program, which runs faster.
 The program cannot change on-disk state by calling functions from the
 zfs.sync submodule.
 The program can be used to gather information such as properties and
 determining if changes would succeed (zfs.check.*).
 Without this flag, all pending changes must be synced to disk before a
 channel program can complete.
 .It Fl t Ar instruction-limit
 Limit the number of Lua instructions to execute.
 If a channel program executes more than the specified number of instructions,
 it will be stopped and an error will be returned.
 The default limit is 10 million instructions, and it can be set to a maximum of
 100 million instructions.
 .It Fl m Ar memory-limit
 Memory limit, in bytes.
 If a channel program attempts to allocate more memory than the given limit, it
 will be stopped and an error returned.
 The default memory limit is 10 MiB, and can be set to a maximum of 100 MiB.
 .El
 .Pp
 All remaining argument strings will be passed directly to the Lua script as
 described in the
 .Sx LUA INTERFACE
 section below.
 .
 .Sh LUA INTERFACE
 A channel program can be invoked either from the command line, or via a library
 call to
 .Fn lzc_channel_program .
 .
 .Ss Arguments
 Arguments passed to the channel program are converted to a Lua table.
 If invoked from the command line, extra arguments to the Lua script will be
 accessible as an array stored in the argument table with the key 'argv':
 .Bd -literal -compact -offset indent
 args = ...
 argv = args["argv"]
 -- argv == {1="arg1", 2="arg2", ...}
 .Ed
 .Pp
 If invoked from the libzfs interface, an arbitrary argument list can be
 passed to the channel program, which is accessible via the same
 .Qq Li ...
 syntax in Lua:
 .Bd -literal -compact -offset indent
 args = ...
 -- args == {"foo"="bar", "baz"={...}, ...}
 .Ed
 .Pp
 Note that because Lua arrays are 1-indexed, arrays passed to Lua from the
 libzfs interface will have their indices incremented by 1.
 That is, the element
 in
 .Va arr[0]
 in a C array passed to a channel program will be stored in
 .Va arr[1]
 when accessed from Lua.
 .
 .Ss Return Values
 Lua return statements take the form:
 .Dl return ret0, ret1, ret2, ...
 .Pp
 Return statements returning multiple values are permitted internally in a
 channel program script, but attempting to return more than one value from the
 top level of the channel program is not permitted and will throw an error.
 However, tables containing multiple values can still be returned.
 If invoked from the command line, a return statement:
 .Bd -literal -compact -offset indent
 a = {foo="bar", baz=2}
 return a
 .Ed
 .Pp
 Will be output formatted as:
 .Bd -literal -compact -offset indent
 Channel program fully executed with return value:
     return:
         baz: 2
         foo: 'bar'
 .Ed
 .
 .Ss Fatal Errors
 If the channel program encounters a fatal error while running, a non-zero exit
 status will be returned.
 If more information about the error is available, a singleton list will be
 returned detailing the error:
 .Dl error: \&"error string, including Lua stack trace"
 .Pp
 If a fatal error is returned, the channel program may have not executed at all,
 may have partially executed, or may have fully executed but failed to pass a
 return value back to userland.
 .Pp
 If the channel program exhausts an instruction or memory limit, a fatal error
 will be generated and the program will be stopped, leaving the program partially
 executed.
 No attempt is made to reverse or undo any operations already performed.
 Note that because both the instruction count and amount of memory used by a
 channel program are deterministic when run against the same inputs and
 filesystem state, as long as a channel program has run successfully once, you
 can guarantee that it will finish successfully against a similar size system.
 .Pp
 If a channel program attempts to return too large a value, the program will
 fully execute but exit with a nonzero status code and no return value.
 .Pp
 .Em Note :
 ZFS API functions do not generate Fatal Errors when correctly invoked, they
 return an error code and the channel program continues executing.
 See the
 .Sx ZFS API
 section below for function-specific details on error return codes.
 .
 .Ss Lua to C Value Conversion
 When invoking a channel program via the libzfs interface, it is necessary to
 translate arguments and return values from Lua values to their C equivalents,
 and vice-versa.
 .Pp
 There is a correspondence between nvlist values in C and Lua tables.
 A Lua table which is returned from the channel program will be recursively
 converted to an nvlist, with table values converted to their natural
 equivalents:
 .TS
 cw3 l c l .
 	string	->	string
 	number	->	int64
 	boolean	->	boolean_value
 	nil	->	boolean (no value)
 	table	->	nvlist
 .TE
 .Pp
 Likewise, table keys are replaced by string equivalents as follows:
 .TS
 cw3 l c l .
 	string	->	no change
 	number	->	signed decimal string ("%lld")
 	boolean	->	"true" | "false"
 .TE
 .Pp
 Any collision of table key strings (for example, the string "true" and a
 true boolean value) will cause a fatal error.
 .Pp
 Lua numbers are represented internally as signed 64-bit integers.
 .
 .Sh LUA STANDARD LIBRARY
 The following Lua built-in base library functions are available:
 .TS
 cw3 l l l l .
 	assert	rawlen	collectgarbage	rawget
 	error	rawset	getmetatable	select
 	ipairs	setmetatable	next	tonumber
 	pairs	tostring	rawequal	type
 .TE
 .Pp
 All functions in the
 .Em coroutine ,
 .Em string ,
 and
 .Em table
 built-in submodules are also available.
 A complete list and documentation of these modules is available in the Lua
 manual.
 .Pp
 The following functions base library functions have been disabled and are
 not available for use in channel programs:
 .TS
 cw3 l l l l l l .
 	dofile	loadfile	load	pcall	print	xpcall
 .TE
 .
 .Sh ZFS API
 .
 .Ss Function Arguments
 Each API function takes a fixed set of required positional arguments and
 optional keyword arguments.
 For example, the destroy function takes a single positional string argument
 (the name of the dataset to destroy) and an optional "defer" keyword boolean
 argument.
 When using parentheses to specify the arguments to a Lua function, only
 positional arguments can be used:
 .Dl Sy zfs.sync.destroy Ns Pq \&"rpool@snap"
 .Pp
 To use keyword arguments, functions must be called with a single argument that
 is a Lua table containing entries mapping integers to positional arguments and
 strings to keyword arguments:
 .Dl Sy zfs.sync.destroy Ns Pq {1="rpool@snap", defer=true}
 .Pp
 The Lua language allows curly braces to be used in place of parenthesis as
 syntactic sugar for this calling convention:
 .Dl Sy zfs.sync.snapshot Ns {"rpool@snap", defer=true}
 .
 .Ss Function Return Values
 If an API function succeeds, it returns 0.
 If it fails, it returns an error code and the channel program continues
 executing.
 API functions do not generate Fatal Errors except in the case of an
 unrecoverable internal file system error.
 .Pp
 In addition to returning an error code, some functions also return extra
 details describing what caused the error.
 This extra description is given as a second return value, and will always be a
 Lua table, or Nil if no error details were returned.
 Different keys will exist in the error details table depending on the function
 and error case.
 Any such function may be called expecting a single return value:
 .Dl errno = Sy zfs.sync.promote Ns Pq dataset
 .Pp
 Or, the error details can be retrieved:
 .Bd -literal -compact -offset indent
 .No errno, details = Sy zfs.sync.promote Ns Pq dataset
 if (errno == EEXIST) then
     assert(details ~= Nil)
     list_of_conflicting_snapshots = details
 end
 .Ed
 .Pp
 The following global aliases for API function error return codes are defined
 for use in channel programs:
 .TS
 cw3 l l l l l l l .
 	EPERM	ECHILD	ENODEV	ENOSPC	ENOENT	EAGAIN	ENOTDIR
 	ESPIPE	ESRCH	ENOMEM	EISDIR	EROFS	EINTR	EACCES
 	EINVAL	EMLINK	EIO	EFAULT	ENFILE	EPIPE	ENXIO
 	ENOTBLK	EMFILE	EDOM	E2BIG	EBUSY	ENOTTY	ERANGE
 	ENOEXEC	EEXIST	ETXTBSY	EDQUOT	EBADF	EXDEV	EFBIG
 .TE
 .
 .Ss API Functions
 For detailed descriptions of the exact behavior of any ZFS administrative
 operations, see the main
 .Xr zfs 8
 manual page.
 .Bl -tag -width "xx"
 .It Fn zfs.debug msg
 Record a debug message in the zfs_dbgmsg log.
 A log of these messages can be printed via mdb's "::zfs_dbgmsg" command, or
 can be monitored live by running
 .Dl dtrace -n 'zfs-dbgmsg{trace(stringof(arg0))}'
 .Pp
 .Bl -tag -compact -width "property (string)"
 .It Ar msg Pq string
 Debug message to be printed.
 .El
 .It Fn zfs.exists dataset
 Returns true if the given dataset exists, or false if it doesn't.
 A fatal error will be thrown if the dataset is not in the target pool.
 That is, in a channel program running on rpool,
 .Sy zfs.exists Ns Pq \&"rpool/nonexistent_fs"
 returns false, but
 .Sy zfs.exists Ns Pq \&"somepool/fs_that_may_exist"
 will error.
 .Pp
 .Bl -tag -compact -width "property (string)"
 .It Ar dataset Pq string
 Dataset to check for existence.
 Must be in the target pool.
 .El
 .It Fn zfs.get_prop dataset property
 Returns two values.
 First, a string, number or table containing the property value for the given
 dataset.
 Second, a string containing the source of the property (i.e. the name of the
 dataset in which it was set or nil if it is readonly).
 Throws a Lua error if the dataset is invalid or the property doesn't exist.
 Note that Lua only supports int64 number types whereas ZFS number properties
 are uint64.
 This means very large values (like GUIDs) may wrap around and appear negative.
 .Pp
 .Bl -tag -compact -width "property (string)"
 .It Ar dataset Pq string
 Filesystem or snapshot path to retrieve properties from.
 .It Ar property Pq string
 Name of property to retrieve.
 All filesystem, snapshot and volume properties are supported except for
 .Sy mounted
 and
 .Sy iscsioptions .
 Also supports the
 .Sy written@ Ns Ar snap
 and
 .Sy written# Ns Ar bookmark
 properties and the
 .Ao Sy user Ns | Ns Sy group Ac Ns Ao Sy quota Ns | Ns Sy used Ac Ns Sy @ Ns Ar id
 properties, though the id must be in numeric form.
 .El
 .El
 .Bl -tag -width "xx"
 .It Sy zfs.sync submodule
 The sync submodule contains functions that modify the on-disk state.
 They are executed in "syncing context".
 .Pp
 The available sync submodule functions are as follows:
 .Bl -tag -width "xx"
 .It Sy zfs.sync.destroy Ns Pq Ar dataset , Op Ar defer Ns = Ns Sy true Ns | Ns Sy false
 Destroy the given dataset.
 Returns 0 on successful destroy, or a nonzero error code if the dataset could
 not be destroyed (for example, if the dataset has any active children or
 clones).
 .Pp
 .Bl -tag -compact -width "newbookmark (string)"
 .It Ar dataset Pq string
 Filesystem or snapshot to be destroyed.
 .It Op Ar defer Pq boolean
 Valid only for destroying snapshots.
 If set to true, and the snapshot has holds or clones, allows the snapshot to be
 marked for deferred deletion rather than failing.
 .El
 .It Fn zfs.sync.inherit dataset property
 Clears the specified property in the given dataset, causing it to be inherited
 from an ancestor, or restored to the default if no ancestor property is set.
 The
 .Nm zfs Cm inherit Fl S
 option has not been implemented.
 Returns 0 on success, or a nonzero error code if the property could not be
 cleared.
 .Pp
 .Bl -tag -compact -width "newbookmark (string)"
 .It Ar dataset Pq string
 Filesystem or snapshot containing the property to clear.
 .It Ar property Pq string
 The property to clear.
 Allowed properties are the same as those for the
 .Nm zfs Cm inherit
 command.
 .El
 .It Fn zfs.sync.promote dataset
 Promote the given clone to a filesystem.
 Returns 0 on successful promotion, or a nonzero error code otherwise.
 If EEXIST is returned, the second return value will be an array of the clone's
 snapshots whose names collide with snapshots of the parent filesystem.
 .Pp
 .Bl -tag -compact -width "newbookmark (string)"
 .It Ar dataset Pq string
 Clone to be promoted.
 .El
 .It Fn zfs.sync.rollback filesystem
 Rollback to the previous snapshot for a dataset.
 Returns 0 on successful rollback, or a nonzero error code otherwise.
 Rollbacks can be performed on filesystems or zvols, but not on snapshots
 or mounted datasets.
 EBUSY is returned in the case where the filesystem is mounted.
 .Pp
 .Bl -tag -compact -width "newbookmark (string)"
 .It Ar filesystem Pq string
 Filesystem to rollback.
 .El
 .It Fn zfs.sync.set_prop dataset property value
 Sets the given property on a dataset.
 Currently only user properties are supported.
 Returns 0 if the property was set, or a nonzero error code otherwise.
 .Pp
 .Bl -tag -compact -width "newbookmark (string)"
 .It Ar dataset Pq string
 The dataset where the property will be set.
 .It Ar property Pq string
 The property to set.
 .It Ar value Pq string
 The value of the property to be set.
 .El
 .It Fn zfs.sync.snapshot dataset
 Create a snapshot of a filesystem.
 Returns 0 if the snapshot was successfully created,
 and a nonzero error code otherwise.
 .Pp
 Note: Taking a snapshot will fail on any pool older than legacy version 27.
 To enable taking snapshots from ZCP scripts, the pool must be upgraded.
 .Pp
 .Bl -tag -compact -width "newbookmark (string)"
 .It Ar dataset Pq string
 Name of snapshot to create.
 .El
 .It Fn zfs.sync.rename_snapshot dataset oldsnapname newsnapname
 Rename a snapshot of a filesystem or a volume.
 Returns 0 if the snapshot was successfully renamed,
 and a nonzero error code otherwise.
 .Pp
 .Bl -tag -compact -width "newbookmark (string)"
 .It Ar dataset Pq string
 Name of the snapshot's parent dataset.
 .It Ar oldsnapname Pq string
 Original name of the snapshot.
 .It Ar newsnapname Pq string
 New name of the snapshot.
 .El
 .It Fn zfs.sync.bookmark source newbookmark
 Create a bookmark of an existing source snapshot or bookmark.
 Returns 0 if the new bookmark was successfully created,
 and a nonzero error code otherwise.
 .Pp
 Note: Bookmarking requires the corresponding pool feature to be enabled.
 .Pp
 .Bl -tag -compact -width "newbookmark (string)"
 .It Ar source Pq string
 Full name of the existing snapshot or bookmark.
 .It Ar newbookmark Pq string
 Full name of the new bookmark.
 .El
 .El
 .It Sy zfs.check submodule
 For each function in the
 .Sy zfs.sync
 submodule, there is a corresponding
 .Sy zfs.check
 function which performs a "dry run" of the same operation.
 Each takes the same arguments as its
 .Sy zfs.sync
 counterpart and returns 0 if the operation would succeed,
 or a non-zero error code if it would fail, along with any other error details.
 That is, each has the same behavior as the corresponding sync function except
 for actually executing the requested change.
 For example,
 .Fn zfs.check.destroy \&"fs"
 returns 0 if
 .Fn zfs.sync.destroy \&"fs"
 would successfully destroy the dataset.
 .Pp
 The available
 .Sy zfs.check
 functions are:
 .Bl -tag -compact -width "xx"
 .It Sy zfs.check.destroy Ns Pq Ar dataset , Op Ar defer Ns = Ns Sy true Ns | Ns Sy false
 .It Fn zfs.check.promote dataset
 .It Fn zfs.check.rollback filesystem
 .It Fn zfs.check.set_property dataset property value
 .It Fn zfs.check.snapshot dataset
 .El
 .It Sy zfs.list submodule
 The zfs.list submodule provides functions for iterating over datasets and
 properties.
 Rather than returning tables, these functions act as Lua iterators, and are
 generally used as follows:
 .Bd -literal -compact -offset indent
 .No for child in Fn zfs.list.children \&"rpool" No do
     ...
 end
 .Ed
 .Pp
 The available
 .Sy zfs.list
 functions are:
 .Bl -tag -width "xx"
 .It Fn zfs.list.clones snapshot
 Iterate through all clones of the given snapshot.
 .Pp
 .Bl -tag -compact -width "snapshot (string)"
 .It Ar snapshot Pq string
 Must be a valid snapshot path in the current pool.
 .El
 .It Fn zfs.list.snapshots dataset
 Iterate through all snapshots of the given dataset.
 Each snapshot is returned as a string containing the full dataset name,
 e.g. "pool/fs@snap".
 .Pp
 .Bl -tag -compact -width "snapshot (string)"
 .It Ar dataset Pq string
 Must be a valid filesystem or volume.
 .El
 .It Fn zfs.list.children dataset
 Iterate through all direct children of the given dataset.
 Each child is returned as a string containing the full dataset name,
 e.g. "pool/fs/child".
 .Pp
 .Bl -tag -compact -width "snapshot (string)"
 .It Ar dataset Pq string
 Must be a valid filesystem or volume.
 .El
 .It Fn zfs.list.bookmarks dataset
 Iterate through all bookmarks of the given dataset.
 Each bookmark is returned as a string containing the full dataset name,
 e.g. "pool/fs#bookmark".
 .Pp
 .Bl -tag -compact -width "snapshot (string)"
 .It Ar dataset Pq string
 Must be a valid filesystem or volume.
 .El
 .It Fn zfs.list.holds snapshot
 Iterate through all user holds on the given snapshot.
 Each hold is returned
 as a pair of the hold's tag and the timestamp (in seconds since the epoch) at
 which it was created.
 .Pp
 .Bl -tag -compact -width "snapshot (string)"
 .It Ar snapshot Pq string
 Must be a valid snapshot.
 .El
 .It Fn zfs.list.properties dataset
 An alias for zfs.list.user_properties (see relevant entry).
 .Pp
 .Bl -tag -compact -width "snapshot (string)"
 .It Ar dataset Pq string
 Must be a valid filesystem, snapshot, or volume.
 .El
 .It Fn zfs.list.user_properties dataset
 Iterate through all user properties for the given dataset.
 For each step of the iteration, output the property name, its value,
 and its source.
 Throws a Lua error if the dataset is invalid.
 .Pp
 .Bl -tag -compact -width "snapshot (string)"
 .It Ar dataset Pq string
 Must be a valid filesystem, snapshot, or volume.
 .El
 .It Fn zfs.list.system_properties dataset
 Returns an array of strings, the names of the valid system (non-user defined)
 properties for the given dataset.
 Throws a Lua error if the dataset is invalid.
 .Pp
 .Bl -tag -compact -width "snapshot (string)"
 .It Ar dataset Pq string
 Must be a valid filesystem, snapshot or volume.
 .El
 .El
 .El
 .
 .Sh EXAMPLES
 .
 .Ss Example 1
 The following channel program recursively destroys a filesystem and all its
 snapshots and children in a naive manner.
 Note that this does not involve any error handling or reporting.
 .Bd -literal -offset indent
 function destroy_recursive(root)
     for child in zfs.list.children(root) do
         destroy_recursive(child)
     end
     for snap in zfs.list.snapshots(root) do
         zfs.sync.destroy(snap)
     end
     zfs.sync.destroy(root)
 end
 destroy_recursive("pool/somefs")
 .Ed
 .
 .Ss Example 2
 A more verbose and robust version of the same channel program, which
 properly detects and reports errors, and also takes the dataset to destroy
 as a command line argument, would be as follows:
 .Bd -literal -offset indent
 succeeded = {}
 failed = {}
 
 function destroy_recursive(root)
     for child in zfs.list.children(root) do
         destroy_recursive(child)
     end
     for snap in zfs.list.snapshots(root) do
         err = zfs.sync.destroy(snap)
         if (err ~= 0) then
             failed[snap] = err
         else
             succeeded[snap] = err
         end
     end
     err = zfs.sync.destroy(root)
     if (err ~= 0) then
         failed[root] = err
     else
         succeeded[root] = err
     end
 end
 
 args = ...
 argv = args["argv"]
 
 destroy_recursive(argv[1])
 
 results = {}
 results["succeeded"] = succeeded
 results["failed"] = failed
 return results
 .Ed
 .
 .Ss Example 3
 The following function performs a forced promote operation by attempting to
 promote the given clone and destroying any conflicting snapshots.
 .Bd -literal -offset indent
 function force_promote(ds)
    errno, details = zfs.check.promote(ds)
    if (errno == EEXIST) then
        assert(details ~= Nil)
        for i, snap in ipairs(details) do
            zfs.sync.destroy(ds .. "@" .. snap)
        end
    elseif (errno ~= 0) then
        return errno
    end
    return zfs.sync.promote(ds)
 end
 .Ed
diff --git a/sys/contrib/openzfs/man/man8/zfs-set.8 b/sys/contrib/openzfs/man/man8/zfs-set.8
index 204450d72ec9..f1718608b44b 100644
--- a/sys/contrib/openzfs/man/man8/zfs-set.8
+++ b/sys/contrib/openzfs/man/man8/zfs-set.8
@@ -1,376 +1,376 @@
 .\"
 .\" CDDL HEADER START
 .\"
 .\" The contents of this file are subject to the terms of the
 .\" Common Development and Distribution License (the "License").
 .\" You may not use this file except in compliance with the License.
 .\"
 .\" You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 .\" or https://opensource.org/licenses/CDDL-1.0.
 .\" See the License for the specific language governing permissions
 .\" and limitations under the License.
 .\"
 .\" When distributing Covered Code, include this CDDL HEADER in each
 .\" file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 .\" If applicable, add the following below this CDDL HEADER, with the
 .\" fields enclosed by brackets "[]" replaced with your own identifying
 .\" information: Portions Copyright [yyyy] [name of copyright owner]
 .\"
 .\" CDDL HEADER END
 .\"
 .\" Copyright (c) 2009 Sun Microsystems, Inc. All Rights Reserved.
 .\" Copyright 2011 Joshua M. Clulow <josh@sysmgr.org>
 .\" Copyright (c) 2011, 2019 by Delphix. All rights reserved.
 .\" Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
 .\" Copyright (c) 2014, Joyent, Inc. All rights reserved.
 .\" Copyright (c) 2014 by Adam Stevko. All rights reserved.
 .\" Copyright (c) 2014 Integros [integros.com]
 .\" Copyright 2019 Richard Laager. All rights reserved.
 .\" Copyright 2018 Nexenta Systems, Inc.
 .\" Copyright 2019 Joyent, Inc.
 .\"
 .Dd April 20, 2024
 .Dt ZFS-SET 8
 .Os
 .
 .Sh NAME
 .Nm zfs-set
 .Nd set properties on ZFS datasets
 .Sh SYNOPSIS
 .Nm zfs
 .Cm set
 .Op Fl u
 .Ar property Ns = Ns Ar value Oo Ar property Ns = Ns Ar value Oc Ns …
 .Ar filesystem Ns | Ns Ar volume Ns | Ns Ar snapshot Ns …
 .Nm zfs
 .Cm get
 .Op Fl r Ns | Ns Fl d Ar depth
 .Op Fl Hp
 .Op Fl j Op Ar --json-int
 .Oo Fl o Ar field Ns Oo , Ns Ar field Oc Ns … Oc
 .Oo Fl s Ar source Ns Oo , Ns Ar source Oc Ns … Oc
 .Oo Fl t Ar type Ns Oo , Ns Ar type Oc Ns … Oc
 .Cm all Ns | Ns Ar property Ns Oo , Ns Ar property Oc Ns …
 .Oo Ar filesystem Ns | Ns Ar volume Ns | Ns Ar snapshot Ns | Ns Ar bookmark Oc Ns …
 .Nm zfs
 .Cm inherit
 .Op Fl rS
 .Ar property Ar filesystem Ns | Ns Ar volume Ns | Ns Ar snapshot Ns …
 .
 .Sh DESCRIPTION
 .Bl -tag -width ""
 .It Xo
 .Nm zfs
 .Cm set
 .Op Fl u
 .Ar property Ns = Ns Ar value Oo Ar property Ns = Ns Ar value Oc Ns …
 .Ar filesystem Ns | Ns Ar volume Ns | Ns Ar snapshot Ns …
 .Xc
 Only some properties can be edited.
 See
 .Xr zfsprops 7
 for more information on what properties can be set and acceptable
 values.
 Numeric values can be specified as exact values, or in a human-readable form
 with a suffix of
 .Sy B , K , M , G , T , P , E , Z
 .Po for bytes, kilobytes, megabytes, gigabytes, terabytes, petabytes, exabytes,
 or zettabytes, respectively
 .Pc .
 User properties can be set on snapshots.
 For more information, see the
 .Em User Properties
 section of
 .Xr zfsprops 7 .
 .Bl -tag -width "-u"
 .It Fl u
 Update mountpoint, sharenfs, sharesmb property but do not mount or share the
 dataset.
 .El
 .It Xo
 .Nm zfs
 .Cm get
 .Op Fl r Ns | Ns Fl d Ar depth
 .Op Fl Hp
 .Op Fl j Op Ar --json-int
 .Oo Fl o Ar field Ns Oo , Ns Ar field Oc Ns … Oc
 .Oo Fl s Ar source Ns Oo , Ns Ar source Oc Ns … Oc
 .Oo Fl t Ar type Ns Oo , Ns Ar type Oc Ns … Oc
 .Cm all Ns | Ns Ar property Ns Oo , Ns Ar property Oc Ns …
 .Oo Ar filesystem Ns | Ns Ar volume Ns | Ns Ar snapshot Ns | Ns Ar bookmark Oc Ns …
 .Xc
 Displays properties for the given datasets.
 If no datasets are specified, then the command displays properties for all
 datasets on the system.
 For each property, the following columns are displayed:
 .Bl -tag -compact -offset 4n -width "property"
 .It Sy name
 Dataset name
 .It Sy property
 Property name
 .It Sy value
 Property value
 .It Sy source
 Property source
 .Sy local , default , inherited , temporary , received , No or Sy - Pq none .
 .El
 .Pp
 All columns are displayed by default, though this can be controlled by using the
 .Fl o
 option.
 This command takes a comma-separated list of properties as described in the
 .Sx Native Properties
 and
 .Sx User Properties
 sections of
 .Xr zfsprops 7 .
 .Pp
 The value
 .Sy all
 can be used to display all properties that apply to the given dataset's type
 .Pq Sy filesystem , volume , snapshot , No or Sy bookmark .
 .Bl -tag -width "-s source"
-.It Fl j Op Ar --json-int
+.It Fl j , -json Op Ar --json-int
 Display the output in JSON format.
 Specify
 .Sy --json-int
 to display numbers in integer format instead of strings for JSON output.
 .It Fl H
 Display output in a form more easily parsed by scripts.
 Any headers are omitted, and fields are explicitly separated by a single tab
 instead of an arbitrary amount of space.
 .It Fl d Ar depth
 Recursively display any children of the dataset, limiting the recursion to
 .Ar depth .
 A depth of
 .Sy 1
 will display only the dataset and its direct children.
 .It Fl o Ar field
 A comma-separated list of columns to display, defaults to
 .Sy name , Ns Sy property , Ns Sy value , Ns Sy source .
 .It Fl p
 Display numbers in parsable
 .Pq exact
 values.
 .It Fl r
 Recursively display properties for any children.
 .It Fl s Ar source
 A comma-separated list of sources to display.
 Those properties coming from a source other than those in this list are ignored.
 Each source must be one of the following:
 .Sy local , default , inherited , temporary , received , No or Sy none .
 The default value is all sources.
 .It Fl t Ar type
 A comma-separated list of types to display, where
 .Ar type
 is one of
 .Sy filesystem , snapshot , volume , bookmark , No or Sy all .
 .Sy fs ,
 .Sy snap ,
 or
 .Sy vol
 can be used as aliases for
 .Sy filesystem ,
 .Sy snapshot ,
 or
 .Sy volume .
 .El
 .It Xo
 .Nm zfs
 .Cm inherit
 .Op Fl rS
 .Ar property Ar filesystem Ns | Ns Ar volume Ns | Ns Ar snapshot Ns …
 .Xc
 Clears the specified property, causing it to be inherited from an ancestor,
 restored to default if no ancestor has the property set, or with the
 .Fl S
 option reverted to the received value if one exists.
 See
 .Xr zfsprops 7
 for a listing of default values, and details on which properties can be
 inherited.
 .Bl -tag -width "-r"
 .It Fl r
 Recursively inherit the given property for all children.
 .It Fl S
 Revert the property to the received value, if one exists;
 otherwise, for non-inheritable properties, to the default;
 otherwise, operate as if the
 .Fl S
 option was not specified.
 .El
 .El
 .
 .Sh EXAMPLES
 .\" These are, respectively, examples 1, 4, 6, 7, 11, 14, 16 from zfs.8
 .\" Make sure to update them bidirectionally
 .Ss Example 1 : No Creating a ZFS File System Hierarchy
 The following commands create a file system named
 .Ar pool/home
 and a file system named
 .Ar pool/home/bob .
 The mount point
 .Pa /export/home
 is set for the parent file system, and is automatically inherited by the child
 file system.
 .Dl # Nm zfs Cm create Ar pool/home
 .Dl # Nm zfs Cm set Sy mountpoint Ns = Ns Ar /export/home pool/home
 .Dl # Nm zfs Cm create Ar pool/home/bob
 .
 .Ss Example 2 : No Disabling and Enabling File System Compression
 The following command disables the
 .Sy compression
 property for all file systems under
 .Ar pool/home .
 The next command explicitly enables
 .Sy compression
 for
 .Ar pool/home/anne .
 .Dl # Nm zfs Cm set Sy compression Ns = Ns Sy off Ar pool/home
 .Dl # Nm zfs Cm set Sy compression Ns = Ns Sy on Ar pool/home/anne
 .
 .Ss Example 3 : No Setting a Quota on a ZFS File System
 The following command sets a quota of 50 Gbytes for
 .Ar pool/home/bob :
 .Dl # Nm zfs Cm set Sy quota Ns = Ns Ar 50G pool/home/bob
 .
 .Ss Example 4 : No Listing ZFS Properties
 The following command lists all properties for
 .Ar pool/home/bob :
 .Bd -literal -compact -offset Ds
 .No # Nm zfs Cm get Sy all Ar pool/home/bob
 NAME           PROPERTY              VALUE                  SOURCE
 pool/home/bob  type                  filesystem             -
 pool/home/bob  creation              Tue Jul 21 15:53 2009  -
 pool/home/bob  used                  21K                    -
 pool/home/bob  available             20.0G                  -
 pool/home/bob  referenced            21K                    -
 pool/home/bob  compressratio         1.00x                  -
 pool/home/bob  mounted               yes                    -
 pool/home/bob  quota                 20G                    local
 pool/home/bob  reservation           none                   default
 pool/home/bob  recordsize            128K                   default
 pool/home/bob  mountpoint            /pool/home/bob         default
 pool/home/bob  sharenfs              off                    default
 pool/home/bob  checksum              on                     default
 pool/home/bob  compression           on                     local
 pool/home/bob  atime                 on                     default
 pool/home/bob  devices               on                     default
 pool/home/bob  exec                  on                     default
 pool/home/bob  setuid                on                     default
 pool/home/bob  readonly              off                    default
 pool/home/bob  zoned                 off                    default
 pool/home/bob  snapdir               hidden                 default
 pool/home/bob  acltype               off                    default
 pool/home/bob  aclmode               discard                default
 pool/home/bob  aclinherit            restricted             default
 pool/home/bob  canmount              on                     default
 pool/home/bob  xattr                 on                     default
 pool/home/bob  copies                1                      default
 pool/home/bob  version               4                      -
 pool/home/bob  utf8only              off                    -
 pool/home/bob  normalization         none                   -
 pool/home/bob  casesensitivity       sensitive              -
 pool/home/bob  vscan                 off                    default
 pool/home/bob  nbmand                off                    default
 pool/home/bob  sharesmb              off                    default
 pool/home/bob  refquota              none                   default
 pool/home/bob  refreservation        none                   default
 pool/home/bob  primarycache          all                    default
 pool/home/bob  secondarycache        all                    default
 pool/home/bob  usedbysnapshots       0                      -
 pool/home/bob  usedbydataset         21K                    -
 pool/home/bob  usedbychildren        0                      -
 pool/home/bob  usedbyrefreservation  0                      -
 .Ed
 .Pp
 The following command gets a single property value:
 .Bd -literal -compact -offset Ds
 .No # Nm zfs Cm get Fl H o Sy value compression Ar pool/home/bob
 on
 .Ed
 .Pp
 The following command gets a single property value recursively in JSON format:
 .Bd -literal -compact -offset Ds
 .No # Nm zfs Cm get Fl j Fl r Sy mountpoint Ar pool/home | Nm jq
 {
   "output_version": {
     "command": "zfs get",
     "vers_major": 0,
     "vers_minor": 1
   },
   "datasets": {
     "pool/home": {
       "name": "pool/home",
       "type": "FILESYSTEM",
       "pool": "pool",
       "createtxg": "10",
       "properties": {
         "mountpoint": {
           "value": "/pool/home",
           "source": {
             "type": "DEFAULT",
             "data": "-"
           }
         }
       }
     },
     "pool/home/bob": {
       "name": "pool/home/bob",
       "type": "FILESYSTEM",
       "pool": "pool",
       "createtxg": "1176",
       "properties": {
         "mountpoint": {
           "value": "/pool/home/bob",
           "source": {
             "type": "DEFAULT",
             "data": "-"
           }
         }
       }
     }
   }
 }
 .Ed
 .Pp
 The following command lists all properties with local settings for
 .Ar pool/home/bob :
 .Bd -literal -compact -offset Ds
 .No # Nm zfs Cm get Fl r s Sy local Fl o Sy name , Ns Sy property , Ns Sy value all Ar pool/home/bob
 NAME           PROPERTY              VALUE
 pool/home/bob  quota                 20G
 pool/home/bob  compression           on
 .Ed
 .
 .Ss Example 5 : No Inheriting ZFS Properties
 The following command causes
 .Ar pool/home/bob No and Ar pool/home/anne
 to inherit the
 .Sy checksum
 property from their parent.
 .Dl # Nm zfs Cm inherit Sy checksum Ar pool/home/bob pool/home/anne
 .
 .Ss Example 6 : No Setting User Properties
 The following example sets the user-defined
 .Ar com.example : Ns Ar department
 property for a dataset:
 .Dl # Nm zfs Cm set Ar com.example : Ns Ar department Ns = Ns Ar 12345 tank/accounting
 .
 .Ss Example 7 : No Setting sharenfs Property Options on a ZFS File System
 The following commands show how to set
 .Sy sharenfs
 property options to enable read-write
 access for a set of IP addresses and to enable root access for system
 .Qq neo
 on the
 .Ar tank/home
 file system:
 .Dl # Nm zfs Cm set Sy sharenfs Ns = Ns ' Ns Ar rw Ns =@123.123.0.0/16:[::1],root= Ns Ar neo Ns ' tank/home
 .Pp
 If you are using DNS for host name resolution,
 specify the fully-qualified hostname.
 .
 .Sh SEE ALSO
 .Xr zfsprops 7 ,
 .Xr zfs-list 8
diff --git a/sys/contrib/openzfs/man/man8/zpool-events.8 b/sys/contrib/openzfs/man/man8/zpool-events.8
index 234612baea8d..01f849845bd9 100644
--- a/sys/contrib/openzfs/man/man8/zpool-events.8
+++ b/sys/contrib/openzfs/man/man8/zpool-events.8
@@ -1,479 +1,482 @@
 .\"
 .\" CDDL HEADER START
 .\"
 .\" The contents of this file are subject to the terms of the
 .\" Common Development and Distribution License (the "License").
 .\" You may not use this file except in compliance with the License.
 .\"
 .\" You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 .\" or https://opensource.org/licenses/CDDL-1.0.
 .\" See the License for the specific language governing permissions
 .\" and limitations under the License.
 .\"
 .\" When distributing Covered Code, include this CDDL HEADER in each
 .\" file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 .\" If applicable, add the following below this CDDL HEADER, with the
 .\" fields enclosed by brackets "[]" replaced with your own identifying
 .\" information: Portions Copyright [yyyy] [name of copyright owner]
 .\"
 .\" CDDL HEADER END
 .\"
 .\" Copyright (c) 2007, Sun Microsystems, Inc. All Rights Reserved.
 .\" Copyright (c) 2012, 2018 by Delphix. All rights reserved.
 .\" Copyright (c) 2012 Cyril Plisko. All Rights Reserved.
 .\" Copyright (c) 2017 Datto Inc.
 .\" Copyright (c) 2018 George Melikov. All Rights Reserved.
 .\" Copyright 2017 Nexenta Systems, Inc.
 .\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
 .\" Copyright (c) 2024, Klara Inc.
 .\"
 .Dd February 28, 2024
 .Dt ZPOOL-EVENTS 8
 .Os
 .
 .Sh NAME
 .Nm zpool-events
 .Nd list recent events generated by kernel
 .Sh SYNOPSIS
 .Nm zpool
 .Cm events
 .Op Fl vHf
 .Op Ar pool
 .Nm zpool
 .Cm events
 .Fl c
 .
 .Sh DESCRIPTION
 Lists all recent events generated by the ZFS kernel modules.
 These events are consumed by the
 .Xr zed 8
 and used to automate administrative tasks such as replacing a failed device
 with a hot spare.
 For more information about the subclasses and event payloads
 that can be generated see
 .Sx EVENTS
 and the following sections.
 .
 .Sh OPTIONS
 .Bl -tag -compact -width Ds
 .It Fl c
 Clear all previous events.
 .It Fl f
 Follow mode.
 .It Fl H
 Scripted mode.
 Do not display headers, and separate fields by a
 single tab instead of arbitrary space.
 .It Fl v
 Print the entire payload for each event.
 .El
 .
 .Sh EVENTS
 These are the different event subclasses.
 The full event name would be
 .Sy ereport.fs.zfs.\& Ns Em SUBCLASS ,
 but only the last part is listed here.
 .Pp
 .Bl -tag -compact -width "vdev.bad_guid_sum"
 .It Sy checksum
 Issued when a checksum error has been detected.
 .It Sy io
 Issued when there is an I/O error in a vdev in the pool.
 .It Sy data
 Issued when there have been data errors in the pool.
 .It Sy deadman
 Issued when an I/O request is determined to be "hung", this can be caused
 by lost completion events due to flaky hardware or drivers.
 See
 .Sy zfs_deadman_failmode
 in
 .Xr zfs 4
 for additional information regarding "hung" I/O detection and configuration.
 .It Sy delay
 Issued when a completed I/O request exceeds the maximum allowed time
 specified by the
 .Sy zio_slow_io_ms
 module parameter.
 This can be an indicator of problems with the underlying storage device.
 The number of delay events is ratelimited by the
 .Sy zfs_slow_io_events_per_second
 module parameter.
-.It Sy dio_verify
+.It Sy dio_verify_rd
+Issued when there was a checksum verify error after a Direct I/O read has been
+issued.
+.It Sy dio_verify_wr
 Issued when there was a checksum verify error after a Direct I/O write has been
 issued.
 This event can only take place if the module parameter
 .Sy zfs_vdev_direct_write_verify
 is not set to zero.
 See
 .Xr zfs 4
 for more details on the
 .Sy zfs_vdev_direct_write_verify
 module paramter.
 .It Sy config
 Issued every time a vdev change have been done to the pool.
 .It Sy zpool
 Issued when a pool cannot be imported.
 .It Sy zpool.destroy
 Issued when a pool is destroyed.
 .It Sy zpool.export
 Issued when a pool is exported.
 .It Sy zpool.import
 Issued when a pool is imported.
 .It Sy zpool.reguid
 Issued when a REGUID (new unique identifier for the pool have been regenerated)
 have been detected.
 .It Sy vdev.unknown
 Issued when the vdev is unknown.
 Such as trying to clear device errors on a vdev that have failed/been kicked
 from the system/pool and is no longer available.
 .It Sy vdev.open_failed
 Issued when a vdev could not be opened (because it didn't exist for example).
 .It Sy vdev.corrupt_data
 Issued when corrupt data have been detected on a vdev.
 .It Sy vdev.no_replicas
 Issued when there are no more replicas to sustain the pool.
 This would lead to the pool being
 .Em DEGRADED .
 .It Sy vdev.bad_guid_sum
 Issued when a missing device in the pool have been detected.
 .It Sy vdev.too_small
 Issued when the system (kernel) have removed a device, and ZFS
 notices that the device isn't there any more.
 This is usually followed by a
 .Sy probe_failure
 event.
 .It Sy vdev.bad_label
 Issued when the label is OK but invalid.
 .It Sy vdev.bad_ashift
 Issued when the ashift alignment requirement has increased.
 .It Sy vdev.remove
 Issued when a vdev is detached from a mirror (or a spare detached from a
 vdev where it have been used to replace a failed drive - only works if
 the original drive have been re-added).
 .It Sy vdev.clear
 Issued when clearing device errors in a pool.
 Such as running
 .Nm zpool Cm clear
 on a device in the pool.
 .It Sy vdev.check
 Issued when a check to see if a given vdev could be opened is started.
 .It Sy vdev.spare
 Issued when a spare have kicked in to replace a failed device.
 .It Sy vdev.autoexpand
 Issued when a vdev can be automatically expanded.
 .It Sy io_failure
 Issued when there is an I/O failure in a vdev in the pool.
 .It Sy probe_failure
 Issued when a probe fails on a vdev.
 This would occur if a vdev
 have been kicked from the system outside of ZFS (such as the kernel
 have removed the device).
 .It Sy log_replay
 Issued when the intent log cannot be replayed.
 The can occur in the case of a missing or damaged log device.
 .It Sy resilver.start
 Issued when a resilver is started.
 .It Sy resilver.finish
 Issued when the running resilver have finished.
 .It Sy scrub.start
 Issued when a scrub is started on a pool.
 .It Sy scrub.finish
 Issued when a pool has finished scrubbing.
 .It Sy scrub.abort
 Issued when a scrub is aborted on a pool.
 .It Sy scrub.resume
 Issued when a scrub is resumed on a pool.
 .It Sy scrub.paused
 Issued when a scrub is paused on a pool.
 .It Sy bootfs.vdev.attach
 .El
 .
 .Sh PAYLOADS
 This is the payload (data, information) that accompanies an
 event.
 .Pp
 For
 .Xr zed 8 ,
 these are set to uppercase and prefixed with
 .Sy ZEVENT_ .
 .Pp
 .Bl -tag -compact -width "vdev_cksum_errors"
 .It Sy pool
 Pool name.
 .It Sy pool_failmode
 Failmode -
 .Sy wait ,
 .Sy continue ,
 or
 .Sy panic .
 See the
 .Sy failmode
 property in
 .Xr zpoolprops 7
 for more information.
 .It Sy pool_guid
 The GUID of the pool.
 .It Sy pool_context
 The load state for the pool (0=none, 1=open, 2=import, 3=tryimport, 4=recover
 5=error).
 .It Sy vdev_guid
 The GUID of the vdev in question (the vdev failing or operated upon with
 .Nm zpool Cm clear ,
 etc.).
 .It Sy vdev_type
 Type of vdev -
 .Sy disk ,
 .Sy file ,
 .Sy mirror ,
 etc.
 See the
 .Sy Virtual Devices
 section of
 .Xr zpoolconcepts 7
 for more information on possible values.
 .It Sy vdev_path
 Full path of the vdev, including any
 .Em -partX .
 .It Sy vdev_devid
 ID of vdev (if any).
 .It Sy vdev_fru
 Physical FRU location.
 .It Sy vdev_state
 State of vdev (0=uninitialized, 1=closed, 2=offline, 3=removed, 4=failed to
 open, 5=faulted, 6=degraded, 7=healthy).
 .It Sy vdev_ashift
 The ashift value of the vdev.
 .It Sy vdev_complete_ts
 The time the last I/O request completed for the specified vdev.
 .It Sy vdev_delta_ts
 The time since the last I/O request completed for the specified vdev.
 .It Sy vdev_spare_paths
 List of spares, including full path and any
 .Em -partX .
 .It Sy vdev_spare_guids
 GUID(s) of spares.
 .It Sy vdev_read_errors
 How many read errors that have been detected on the vdev.
 .It Sy vdev_write_errors
 How many write errors that have been detected on the vdev.
 .It Sy vdev_cksum_errors
 How many checksum errors that have been detected on the vdev.
 .It Sy parent_guid
 GUID of the vdev parent.
 .It Sy parent_type
 Type of parent.
 See
 .Sy vdev_type .
 .It Sy parent_path
 Path of the vdev parent (if any).
 .It Sy parent_devid
 ID of the vdev parent (if any).
 .It Sy zio_objset
 The object set number for a given I/O request.
 .It Sy zio_object
 The object number for a given I/O request.
 .It Sy zio_level
 The indirect level for the block.
 Level 0 is the lowest level and includes data blocks.
 Values > 0 indicate metadata blocks at the appropriate level.
 .It Sy zio_blkid
 The block ID for a given I/O request.
 .It Sy zio_err
 The error number for a failure when handling a given I/O request,
 compatible with
 .Xr errno 3
 with the value of
 .Sy EBADE
 used to indicate a ZFS checksum error.
 .It Sy zio_offset
 The offset in bytes of where to write the I/O request for the specified vdev.
 .It Sy zio_size
 The size in bytes of the I/O request.
 .It Sy zio_flags
 The current flags describing how the I/O request should be handled.
 See the
 .Sy I/O FLAGS
 section for the full list of I/O flags.
 .It Sy zio_stage
 The current stage of the I/O in the pipeline.
 See the
 .Sy I/O STAGES
 section for a full list of all the I/O stages.
 .It Sy zio_pipeline
 The valid pipeline stages for the I/O.
 See the
 .Sy I/O STAGES
 section for a full list of all the I/O stages.
 .It Sy zio_delay
 The time elapsed (in nanoseconds) waiting for the block layer to complete the
 I/O request.
 Unlike
 .Sy zio_delta ,
 this does not include any vdev queuing time and is
 therefore solely a measure of the block layer performance.
 .It Sy zio_timestamp
 The time when a given I/O request was submitted.
 .It Sy zio_delta
 The time required to service a given I/O request.
 .It Sy prev_state
 The previous state of the vdev.
 .It Sy cksum_algorithm
 Checksum algorithm used.
 See
 .Xr zfsprops 7
 for more information on the available checksum algorithms.
 .It Sy cksum_byteswap
 Whether or not the data is byteswapped.
 .It Sy bad_ranges
 .No [\& Ns Ar start , end )
 pairs of corruption offsets.
 Offsets are always aligned on a 64-bit boundary,
 and can include some gaps of non-corruption.
 (See
 .Sy bad_ranges_min_gap )
 .It Sy bad_ranges_min_gap
 In order to bound the size of the
 .Sy bad_ranges
 array, gaps of non-corruption
 less than or equal to
 .Sy bad_ranges_min_gap
 bytes have been merged with
 adjacent corruption.
 Always at least 8 bytes, since corruption is detected on a 64-bit word basis.
 .It Sy bad_range_sets
 This array has one element per range in
 .Sy bad_ranges .
 Each element contains
 the count of bits in that range which were clear in the good data and set
 in the bad data.
 .It Sy bad_range_clears
 This array has one element per range in
 .Sy bad_ranges .
 Each element contains
 the count of bits for that range which were set in the good data and clear in
 the bad data.
 .It Sy bad_set_bits
 If this field exists, it is an array of
 .Pq Ar bad data No & ~( Ns Ar good data ) ;
 that is, the bits set in the bad data which are cleared in the good data.
 Each element corresponds a byte whose offset is in a range in
 .Sy bad_ranges ,
 and the array is ordered by offset.
 Thus, the first element is the first byte in the first
 .Sy bad_ranges
 range, and the last element is the last byte in the last
 .Sy bad_ranges
 range.
 .It Sy bad_cleared_bits
 Like
 .Sy bad_set_bits ,
 but contains
 .Pq Ar good data No & ~( Ns Ar bad data ) ;
 that is, the bits set in the good data which are cleared in the bad data.
 .El
 .
 .Sh I/O STAGES
 The ZFS I/O pipeline is comprised of various stages which are defined below.
 The individual stages are used to construct these basic I/O
 operations: Read, Write, Free, Claim, Flush and Trim.
 These stages may be
 set on an event to describe the life cycle of a given I/O request.
 .Pp
 .TS
 tab(:);
 l l l .
 Stage:Bit Mask:Operations
 _:_:_
 ZIO_STAGE_OPEN:0x00000001:RWFCXT
 
 ZIO_STAGE_READ_BP_INIT:0x00000002:R-----
 ZIO_STAGE_WRITE_BP_INIT:0x00000004:-W----
 ZIO_STAGE_FREE_BP_INIT:0x00000008:--F---
 ZIO_STAGE_ISSUE_ASYNC:0x00000010:-WF--T
 ZIO_STAGE_WRITE_COMPRESS:0x00000020:-W----
 
 ZIO_STAGE_ENCRYPT:0x00000040:-W----
 ZIO_STAGE_CHECKSUM_GENERATE:0x00000080:-W----
 
 ZIO_STAGE_NOP_WRITE:0x00000100:-W----
 
 ZIO_STAGE_BRT_FREE:0x00000200:--F---
 
 ZIO_STAGE_DDT_READ_START:0x00000400:R-----
 ZIO_STAGE_DDT_READ_DONE:0x00000800:R-----
 ZIO_STAGE_DDT_WRITE:0x00001000:-W----
 ZIO_STAGE_DDT_FREE:0x00002000:--F---
 
 ZIO_STAGE_GANG_ASSEMBLE:0x00004000:RWFC--
 ZIO_STAGE_GANG_ISSUE:0x00008000:RWFC--
 
 ZIO_STAGE_DVA_THROTTLE:0x00010000:-W----
 ZIO_STAGE_DVA_ALLOCATE:0x00020000:-W----
 ZIO_STAGE_DVA_FREE:0x00040000:--F---
 ZIO_STAGE_DVA_CLAIM:0x00080000:---C--
 
 ZIO_STAGE_READY:0x00100000:RWFCIT
 
 ZIO_STAGE_VDEV_IO_START:0x00200000:RW--XT
 ZIO_STAGE_VDEV_IO_DONE:0x00400000:RW--XT
 ZIO_STAGE_VDEV_IO_ASSESS:0x00800000:RW--XT
 
 ZIO_STAGE_CHECKSUM_VERIFY:0x01000000:R-----
 ZIO_STAGE_DIO_CHECKSUM_VERIFY:0x02000000:-W----
 
 ZIO_STAGE_DONE:0x04000000:RWFCXT
 .TE
 .
 .Sh I/O FLAGS
 Every I/O request in the pipeline contains a set of flags which describe its
 function and are used to govern its behavior.
 These flags will be set in an event as a
 .Sy zio_flags
 payload entry.
 .Pp
 .TS
 tab(:);
 l l .
 Flag:Bit Mask
 _:_
 ZIO_FLAG_DONT_AGGREGATE:0x00000001
 ZIO_FLAG_IO_REPAIR:0x00000002
 ZIO_FLAG_SELF_HEAL:0x00000004
 ZIO_FLAG_RESILVER:0x00000008
 ZIO_FLAG_SCRUB:0x00000010
 ZIO_FLAG_SCAN_THREAD:0x00000020
 ZIO_FLAG_PHYSICAL:0x00000040
 
 ZIO_FLAG_CANFAIL:0x00000080
 ZIO_FLAG_SPECULATIVE:0x00000100
 ZIO_FLAG_CONFIG_WRITER:0x00000200
 ZIO_FLAG_DONT_RETRY:0x00000400
 ZIO_FLAG_NODATA:0x00001000
 ZIO_FLAG_INDUCE_DAMAGE:0x00002000
 
 ZIO_FLAG_IO_ALLOCATING:0x00004000
 ZIO_FLAG_IO_RETRY:0x00008000
 ZIO_FLAG_PROBE:0x00010000
 ZIO_FLAG_TRYHARD:0x00020000
 ZIO_FLAG_OPTIONAL:0x00040000
 
 ZIO_FLAG_DONT_QUEUE:0x00080000
 ZIO_FLAG_DONT_PROPAGATE:0x00100000
 ZIO_FLAG_IO_BYPASS:0x00200000
 ZIO_FLAG_IO_REWRITE:0x00400000
 ZIO_FLAG_RAW_COMPRESS:0x00800000
 ZIO_FLAG_RAW_ENCRYPT:0x01000000
 
 ZIO_FLAG_GANG_CHILD:0x02000000
 ZIO_FLAG_DDT_CHILD:0x04000000
 ZIO_FLAG_GODFATHER:0x08000000
 ZIO_FLAG_NOPWRITE:0x10000000
 ZIO_FLAG_REEXECUTED:0x20000000
 ZIO_FLAG_DELEGATED:0x40000000
 ZIO_FLAG_FASTWRITE:0x80000000
 .TE
 .
 .Sh SEE ALSO
 .Xr zfs 4 ,
 .Xr zed 8 ,
 .Xr zpool-wait 8
diff --git a/sys/contrib/openzfs/man/man8/zpool-get.8 b/sys/contrib/openzfs/man/man8/zpool-get.8
index 5384906f17f2..1be83526d22d 100644
--- a/sys/contrib/openzfs/man/man8/zpool-get.8
+++ b/sys/contrib/openzfs/man/man8/zpool-get.8
@@ -1,204 +1,204 @@
 .\"
 .\" CDDL HEADER START
 .\"
 .\" The contents of this file are subject to the terms of the
 .\" Common Development and Distribution License (the "License").
 .\" You may not use this file except in compliance with the License.
 .\"
 .\" You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 .\" or https://opensource.org/licenses/CDDL-1.0.
 .\" See the License for the specific language governing permissions
 .\" and limitations under the License.
 .\"
 .\" When distributing Covered Code, include this CDDL HEADER in each
 .\" file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 .\" If applicable, add the following below this CDDL HEADER, with the
 .\" fields enclosed by brackets "[]" replaced with your own identifying
 .\" information: Portions Copyright [yyyy] [name of copyright owner]
 .\"
 .\" CDDL HEADER END
 .\"
 .\" Copyright (c) 2007, Sun Microsystems, Inc. All Rights Reserved.
 .\" Copyright (c) 2012, 2018 by Delphix. All rights reserved.
 .\" Copyright (c) 2012 Cyril Plisko. All Rights Reserved.
 .\" Copyright (c) 2017 Datto Inc.
 .\" Copyright (c) 2018 George Melikov. All Rights Reserved.
 .\" Copyright 2017 Nexenta Systems, Inc.
 .\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
 .\"
 .Dd August 9, 2019
 .Dt ZPOOL-GET 8
 .Os
 .
 .Sh NAME
 .Nm zpool-get
 .Nd retrieve properties of ZFS storage pools
 .Sh SYNOPSIS
 .Nm zpool
 .Cm get
 .Op Fl Hp
 .Op Fl j Op Ar --json-int, --json-pool-key-guid
 .Op Fl o Ar field Ns Oo , Ns Ar field Oc Ns …
 .Sy all Ns | Ns Ar property Ns Oo , Ns Ar property Oc Ns …
 .Oo Ar pool Oc Ns …
 .
 .Nm zpool
 .Cm get
 .Op Fl Hp
 .Op Fl j Op Ar --json-int
 .Op Fl o Ar field Ns Oo , Ns Ar field Oc Ns …
 .Sy all Ns | Ns Ar property Ns Oo , Ns Ar property Oc Ns …
 .Ar pool
 .Oo Sy all-vdevs Ns | Ns
 .Ar vdev Oc Ns …
 .
 .Nm zpool
 .Cm set
 .Ar property Ns = Ns Ar value
 .Ar pool
 .
 .Nm zpool
 .Cm set
 .Ar property Ns = Ns Ar value
 .Ar pool
 .Ar vdev
 .
 .Sh DESCRIPTION
 .Bl -tag -width Ds
 .It Xo
 .Nm zpool
 .Cm get
 .Op Fl Hp
 .Op Fl j Op Ar --json-int, --json-pool-key-guid
 .Op Fl o Ar field Ns Oo , Ns Ar field Oc Ns …
 .Sy all Ns | Ns Ar property Ns Oo , Ns Ar property Oc Ns …
 .Oo Ar pool Oc Ns …
 .Xc
 Retrieves the given list of properties
 .Po
 or all properties if
 .Sy all
 is used
 .Pc
 for the specified storage pool(s).
 These properties are displayed with the following fields:
 .Bl -tag -compact -offset Ds -width "property"
 .It Sy name
 Name of storage pool.
 .It Sy property
 Property name.
 .It Sy value
 Property value.
 .It Sy source
 Property source, either
 .Sy default No or Sy local .
 .El
 .Pp
 See the
 .Xr zpoolprops 7
 manual page for more information on the available pool properties.
 .Bl -tag -compact -offset Ds -width "-o field"
-.It Fl j Op Ar --json-int, --json-pool-key-guid
+.It Fl j , -json Op Ar --json-int, --json-pool-key-guid
 Display the list of properties in JSON format.
 Specify
 .Sy --json-int
 to display the numbers in integer format instead of strings in JSON output.
 Specify
 .Sy --json-pool-key-guid
 to set pool GUID as key for pool objects instead of pool name.
 .It Fl H
 Scripted mode.
 Do not display headers, and separate fields by a single tab instead of arbitrary
 space.
 .It Fl o Ar field
 A comma-separated list of columns to display, defaults to
 .Sy name , Ns Sy property , Ns Sy value , Ns Sy source .
 .It Fl p
 Display numbers in parsable (exact) values.
 .El
 .It Xo
 .Nm zpool
 .Cm get
 .Op Fl j Op Ar --json-int
 .Op Fl Hp
 .Op Fl o Ar field Ns Oo , Ns Ar field Oc Ns …
 .Sy all Ns | Ns Ar property Ns Oo , Ns Ar property Oc Ns …
 .Ar pool
 .Oo Sy all-vdevs Ns | Ns
 .Ar vdev Oc Ns …
 .Xc
 Retrieves the given list of properties
 .Po
 or all properties if
 .Sy all
 is used
 .Pc
 for the specified vdevs
 .Po
 or all vdevs if
 .Sy all-vdevs
 is used
 .Pc
 in the specified pool.
 These properties are displayed with the following fields:
 .Bl -tag -compact -offset Ds -width "property"
 .It Sy name
 Name of vdev.
 .It Sy property
 Property name.
 .It Sy value
 Property value.
 .It Sy source
 Property source, either
 .Sy default No or Sy local .
 .El
 .Pp
 See the
 .Xr vdevprops 7
 manual page for more information on the available pool properties.
 .Bl -tag -compact -offset Ds -width "-o field"
-.It Fl j Op Ar --json-int
+.It Fl j , -json Op Ar --json-int
 Display the list of properties in JSON format.
 Specify
 .Sy --json-int
 to display the numbers in integer format instead of strings in JSON output.
 .It Fl H
 Scripted mode.
 Do not display headers, and separate fields by a single tab instead of arbitrary
 space.
 .It Fl o Ar field
 A comma-separated list of columns to display, defaults to
 .Sy name , Ns Sy property , Ns Sy value , Ns Sy source .
 .It Fl p
 Display numbers in parsable (exact) values.
 .El
 .It Xo
 .Nm zpool
 .Cm set
 .Ar property Ns = Ns Ar value
 .Ar pool
 .Xc
 Sets the given property on the specified pool.
 See the
 .Xr zpoolprops 7
 manual page for more information on what properties can be set and acceptable
 values.
 .It Xo
 .Nm zpool
 .Cm set
 .Ar property Ns = Ns Ar value
 .Ar pool
 .Ar vdev
 .Xc
 Sets the given property on the specified vdev in the specified pool.
 See the
 .Xr vdevprops 7
 manual page for more information on what properties can be set and acceptable
 values.
 .El
 .
 .Sh SEE ALSO
 .Xr vdevprops 7 ,
 .Xr zpool-features 7 ,
 .Xr zpoolprops 7 ,
 .Xr zpool-list 8
diff --git a/sys/contrib/openzfs/man/man8/zpool-list.8 b/sys/contrib/openzfs/man/man8/zpool-list.8
index b0ee659701d4..6d3478a68711 100644
--- a/sys/contrib/openzfs/man/man8/zpool-list.8
+++ b/sys/contrib/openzfs/man/man8/zpool-list.8
@@ -1,253 +1,253 @@
 .\"
 .\" CDDL HEADER START
 .\"
 .\" The contents of this file are subject to the terms of the
 .\" Common Development and Distribution License (the "License").
 .\" You may not use this file except in compliance with the License.
 .\"
 .\" You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 .\" or https://opensource.org/licenses/CDDL-1.0.
 .\" See the License for the specific language governing permissions
 .\" and limitations under the License.
 .\"
 .\" When distributing Covered Code, include this CDDL HEADER in each
 .\" file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 .\" If applicable, add the following below this CDDL HEADER, with the
 .\" fields enclosed by brackets "[]" replaced with your own identifying
 .\" information: Portions Copyright [yyyy] [name of copyright owner]
 .\"
 .\" CDDL HEADER END
 .\"
 .\" Copyright (c) 2007, Sun Microsystems, Inc. All Rights Reserved.
 .\" Copyright (c) 2012, 2018 by Delphix. All rights reserved.
 .\" Copyright (c) 2012 Cyril Plisko. All Rights Reserved.
 .\" Copyright (c) 2017 Datto Inc.
 .\" Copyright (c) 2018 George Melikov. All Rights Reserved.
 .\" Copyright 2017 Nexenta Systems, Inc.
 .\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
 .\"
 .Dd March 16, 2022
 .Dt ZPOOL-LIST 8
 .Os
 .
 .Sh NAME
 .Nm zpool-list
 .Nd list information about ZFS storage pools
 .Sh SYNOPSIS
 .Nm zpool
 .Cm list
 .Op Fl HgLpPv
 .Op Fl j Op Ar --json-int, --json-pool-key-guid
 .Op Fl o Ar property Ns Oo , Ns Ar property Oc Ns …
 .Op Fl T Sy u Ns | Ns Sy d
 .Oo Ar pool Oc Ns …
 .Op Ar interval Op Ar count
 .
 .Sh DESCRIPTION
 Lists the given pools along with a health status and space usage.
 If no
 .Ar pool Ns s
 are specified, all pools in the system are listed.
 When given an
 .Ar interval ,
 the information is printed every
 .Ar interval
 seconds until killed.
 If
 .Ar count
 is specified, the command exits after
 .Ar count
 reports are printed.
 .Bl -tag -width Ds
-.It Fl j Op Ar --json-int, --json-pool-key-guid
+.It Fl j , -json Op Ar --json-int, --json-pool-key-guid
 Display the list of pools in JSON format.
 Specify
 .Sy --json-int
 to display the numbers in integer format instead of strings.
 Specify
 .Sy --json-pool-key-guid
 to set pool GUID as key for pool objects instead of pool names.
 .It Fl g
 Display vdev GUIDs instead of the normal device names.
 These GUIDs can be used in place of device names for the zpool
 detach/offline/remove/replace commands.
 .It Fl H
 Scripted mode.
 Do not display headers, and separate fields by a single tab instead of arbitrary
 space.
 .It Fl o Ar property
 Comma-separated list of properties to display.
 See the
 .Xr zpoolprops 7
 manual page for a list of valid properties.
 The default list is
 .Sy name , size , allocated , free , checkpoint, expandsize , fragmentation ,
 .Sy capacity , dedupratio , health , altroot .
 .It Fl L
 Display real paths for vdevs resolving all symbolic links.
 This can be used to look up the current block device name regardless of the
 .Pa /dev/disk
 path used to open it.
 .It Fl p
 Display numbers in parsable
 .Pq exact
 values.
 .It Fl P
 Display full paths for vdevs instead of only the last component of
 the path.
 This can be used in conjunction with the
 .Fl L
 flag.
 .It Fl T Sy u Ns | Ns Sy d
 Display a time stamp.
 Specify
 .Sy u
 for a printed representation of the internal representation of time.
 See
 .Xr time 1 .
 Specify
 .Sy d
 for standard date format.
 See
 .Xr date 1 .
 .It Fl v
 Verbose statistics.
 Reports usage statistics for individual vdevs within the pool, in addition to
 the pool-wide statistics.
 .El
 .
 .Sh EXAMPLES
 .\" These are, respectively, examples 6, 15 from zpool.8
 .\" Make sure to update them bidirectionally
 .Ss Example 1 : No Listing Available ZFS Storage Pools
 The following command lists all available pools on the system.
 In this case, the pool
 .Ar zion
 is faulted due to a missing device.
 The results from this command are similar to the following:
 .Bd -literal -compact -offset Ds
 .No # Nm zpool Cm list
 NAME    SIZE  ALLOC   FREE  EXPANDSZ   FRAG    CAP  DEDUP  HEALTH  ALTROOT
 rpool  19.9G  8.43G  11.4G         -    33%    42%  1.00x  ONLINE  -
 tank   61.5G  20.0G  41.5G         -    48%    32%  1.00x  ONLINE  -
 zion       -      -      -         -      -      -      -  FAULTED -
 .Ed
 .
 .Ss Example 2 : No Displaying expanded space on a device
 The following command displays the detailed information for the pool
 .Ar data .
 This pool is comprised of a single raidz vdev where one of its devices
 increased its capacity by 10 GiB.
 In this example, the pool will not be able to utilize this extra capacity until
 all the devices under the raidz vdev have been expanded.
 .Bd -literal -compact -offset Ds
 .No # Nm zpool Cm list Fl v Ar data
 NAME         SIZE  ALLOC   FREE  EXPANDSZ   FRAG    CAP  DEDUP  HEALTH  ALTROOT
 data        23.9G  14.6G  9.30G         -    48%    61%  1.00x  ONLINE  -
   raidz1    23.9G  14.6G  9.30G         -    48%
     sda         -      -      -         -      -
     sdb         -      -      -       10G      -
     sdc         -      -      -         -      -
 .Ed
 .
 .Ss Example 3 : No Displaying expanded space on a device
 The following command lists all available pools on the system in JSON
 format.
 .Bd -literal -compact -offset Ds
 .No # Nm zpool Cm list Fl j | Nm jq
 {
   "output_version": {
     "command": "zpool list",
     "vers_major": 0,
     "vers_minor": 1
   },
   "pools": {
     "tank": {
       "name": "tank",
       "type": "POOL",
       "state": "ONLINE",
       "guid": "15220353080205405147",
       "txg": "2671",
       "spa_version": "5000",
       "zpl_version": "5",
       "properties": {
         "size": {
           "value": "111G",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "allocated": {
           "value": "30.8G",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "free": {
           "value": "80.2G",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "checkpoint": {
           "value": "-",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "expandsize": {
           "value": "-",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "fragmentation": {
           "value": "0%",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "capacity": {
           "value": "27%",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "dedupratio": {
           "value": "1.00x",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "health": {
           "value": "ONLINE",
           "source": {
             "type": "NONE",
             "data": "-"
           }
         },
         "altroot": {
           "value": "-",
           "source": {
             "type": "DEFAULT",
             "data": "-"
           }
         }
       }
     }
   }
 }
 
 .Ed
 .
 .Sh SEE ALSO
 .Xr zpool-import 8 ,
 .Xr zpool-status 8
diff --git a/sys/contrib/openzfs/man/man8/zpool-status.8 b/sys/contrib/openzfs/man/man8/zpool-status.8
index 868fc4414dbb..b9b54185d050 100644
--- a/sys/contrib/openzfs/man/man8/zpool-status.8
+++ b/sys/contrib/openzfs/man/man8/zpool-status.8
@@ -1,361 +1,365 @@
 .\"
 .\" CDDL HEADER START
 .\"
 .\" The contents of this file are subject to the terms of the
 .\" Common Development and Distribution License (the "License").
 .\" You may not use this file except in compliance with the License.
 .\"
 .\" You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 .\" or https://opensource.org/licenses/CDDL-1.0.
 .\" See the License for the specific language governing permissions
 .\" and limitations under the License.
 .\"
 .\" When distributing Covered Code, include this CDDL HEADER in each
 .\" file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 .\" If applicable, add the following below this CDDL HEADER, with the
 .\" fields enclosed by brackets "[]" replaced with your own identifying
 .\" information: Portions Copyright [yyyy] [name of copyright owner]
 .\"
 .\" CDDL HEADER END
 .\"
 .\" Copyright (c) 2007, Sun Microsystems, Inc. All Rights Reserved.
 .\" Copyright (c) 2012, 2018 by Delphix. All rights reserved.
 .\" Copyright (c) 2012 Cyril Plisko. All Rights Reserved.
 .\" Copyright (c) 2017 Datto Inc.
 .\" Copyright (c) 2018 George Melikov. All Rights Reserved.
 .\" Copyright 2017 Nexenta Systems, Inc.
 .\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
 .\"
 .Dd February 14, 2024
 .Dt ZPOOL-STATUS 8
 .Os
 .
 .Sh NAME
 .Nm zpool-status
 .Nd show detailed health status for ZFS storage pools
 .Sh SYNOPSIS
 .Nm zpool
 .Cm status
 .Op Fl dDegiLpPstvx
 .Op Fl T Sy u Ns | Ns Sy d
 .Op Fl c Op Ar SCRIPT1 Ns Oo , Ns Ar SCRIPT2 Oc Ns …
 .Oo Ar pool Oc Ns …
 .Op Ar interval Op Ar count
 .Op Fl j Op Ar --json-int, --json-flat-vdevs, --json-pool-key-guid
 .
 .Sh DESCRIPTION
 Displays the detailed health status for the given pools.
 If no
 .Ar pool
 is specified, then the status of each pool in the system is displayed.
 For more information on pool and device health, see the
 .Sx Device Failure and Recovery
 section of
 .Xr zpoolconcepts 7 .
 .Pp
 If a scrub or resilver is in progress, this command reports the percentage done
 and the estimated time to completion.
 Both of these are only approximate, because the amount of data in the pool and
 the other workloads on the system can change.
 .Bl -tag -width Ds
 .It Fl -power
 Display vdev enclosure slot power status (on or off).
 .It Fl c Op Ar SCRIPT1 Ns Oo , Ns Ar SCRIPT2 Oc Ns …
 Run a script (or scripts) on each vdev and include the output as a new column
 in the
 .Nm zpool Cm status
 output.
 See the
 .Fl c
 option of
 .Nm zpool Cm iostat
 for complete details.
-.It Fl j Op Ar --json-int, --json-flat-vdevs, --json-pool-key-guid
+.It Fl j , -json Op Ar --json-int, --json-flat-vdevs, --json-pool-key-guid
 Display the status for ZFS pools in JSON format.
 Specify
 .Sy --json-int
 to display numbers in integer format instead of strings.
 Specify
 .Sy --json-flat-vdevs
 to display vdevs in flat hierarchy instead of nested vdev objects.
 Specify
 .Sy --json-pool-key-guid
 to set pool GUID as key for pool objects instead of pool names.
 .It Fl d
-Display the number of Direct I/O write checksum verify errors that have occured
-on a top-level VDEV.
+Display the number of Direct I/O read/write checksum verify errors that have
+occured on a top-level VDEV.
 See
 .Sx zfs_vdev_direct_write_verify
 in
 .Xr zfs 4
 for details about the conditions that can cause Direct I/O write checksum
 verify failures to occur.
+Direct I/O reads checksum verify errors can also occur if the contents of the
+buffer are being manipulated after the I/O has been issued and is in flight.
+In the case of Direct I/O read checksum verify errors, the I/O will be reissued
+through the ARC.
 .It Fl D
 Display a histogram of deduplication statistics, showing the allocated
 .Pq physically present on disk
 and referenced
 .Pq logically referenced in the pool
 block counts and sizes by reference count.
 If repeated, (-DD), also shows statistics on how much of the DDT is resident
 in the ARC.
 .It Fl e
 Only show unhealthy vdevs (not-ONLINE or with errors).
 .It Fl g
 Display vdev GUIDs instead of the normal device names
 These GUIDs can be used in place of device names for the zpool
 detach/offline/remove/replace commands.
 .It Fl i
 Display vdev initialization status.
 .It Fl L
 Display real paths for vdevs resolving all symbolic links.
 This can be used to look up the current block device name regardless of the
 .Pa /dev/disk/
 path used to open it.
 .It Fl p
 Display numbers in parsable (exact) values.
 .It Fl P
 Display full paths for vdevs instead of only the last component of
 the path.
 This can be used in conjunction with the
 .Fl L
 flag.
 .It Fl s
 Display the number of leaf vdev slow I/O operations.
 This is the number of I/O operations that didn't complete in
 .Sy zio_slow_io_ms
 milliseconds
 .Pq Sy 30000 No by default .
 This does not necessarily mean the I/O operations failed to complete, just took
 an
 unreasonably long amount of time.
 This may indicate a problem with the underlying storage.
 .It Fl t
 Display vdev TRIM status.
 .It Fl T Sy u Ns | Ns Sy d
 Display a time stamp.
 Specify
 .Sy u
 for a printed representation of the internal representation of time.
 See
 .Xr time 1 .
 Specify
 .Sy d
 for standard date format.
 See
 .Xr date 1 .
 .It Fl v
 Displays verbose data error information, printing out a complete list of all
 data errors since the last complete pool scrub.
 If the head_errlog feature is enabled and files containing errors have been
 removed then the respective filenames will not be reported in subsequent runs
 of this command.
 .It Fl x
 Only display status for pools that are exhibiting errors or are otherwise
 unavailable.
 Warnings about pools not using the latest on-disk format will not be included.
 .El
 .
 .Sh EXAMPLES
 .\" These are, respectively, examples 16 from zpool.8
 .\" Make sure to update them bidirectionally
 .Ss Example 1 : No Adding output columns
 Additional columns can be added to the
 .Nm zpool Cm status No and Nm zpool Cm iostat No output with Fl c .
 .Bd -literal -compact -offset Ds
 .No # Nm zpool Cm status Fl c Pa vendor , Ns Pa model , Ns Pa size
    NAME     STATE  READ WRITE CKSUM vendor  model        size
    tank     ONLINE 0    0     0
    mirror-0 ONLINE 0    0     0
    U1       ONLINE 0    0     0     SEAGATE ST8000NM0075 7.3T
    U10      ONLINE 0    0     0     SEAGATE ST8000NM0075 7.3T
    U11      ONLINE 0    0     0     SEAGATE ST8000NM0075 7.3T
    U12      ONLINE 0    0     0     SEAGATE ST8000NM0075 7.3T
    U13      ONLINE 0    0     0     SEAGATE ST8000NM0075 7.3T
    U14      ONLINE 0    0     0     SEAGATE ST8000NM0075 7.3T
 
 .No # Nm zpool Cm iostat Fl vc Pa size
               capacity     operations     bandwidth
 pool        alloc   free   read  write   read  write  size
 ----------  -----  -----  -----  -----  -----  -----  ----
 rpool       14.6G  54.9G      4     55   250K  2.69M
   sda1      14.6G  54.9G      4     55   250K  2.69M   70G
 ----------  -----  -----  -----  -----  -----  -----  ----
 .Ed
 .
 .Ss Example 2 : No Display the status output in JSON format
 .Nm zpool Cm status No can output in JSON format if
 .Fl j
 is specified.
 .Fl c
 can be used to run a script on each VDEV.
 .Bd -literal -compact -offset Ds
 .No # Nm zpool Cm status Fl j Fl c Pa vendor , Ns Pa model , Ns Pa size | Nm jq
 {
   "output_version": {
     "command": "zpool status",
     "vers_major": 0,
     "vers_minor": 1
   },
   "pools": {
     "tank": {
       "name": "tank",
       "state": "ONLINE",
       "guid": "3920273586464696295",
       "txg": "16597",
       "spa_version": "5000",
       "zpl_version": "5",
       "status": "OK",
       "vdevs": {
         "tank": {
           "name": "tank",
           "alloc_space": "62.6G",
           "total_space": "15.0T",
           "def_space": "11.3T",
           "read_errors": "0",
           "write_errors": "0",
           "checksum_errors": "0",
           "vdevs": {
             "raidz1-0": {
               "name": "raidz1-0",
               "vdev_type": "raidz",
               "guid": "763132626387621737",
               "state": "HEALTHY",
               "alloc_space": "62.5G",
               "total_space": "10.9T",
               "def_space": "7.26T",
               "rep_dev_size": "10.9T",
               "read_errors": "0",
               "write_errors": "0",
               "checksum_errors": "0",
               "vdevs": {
                 "ca1eb824-c371-491d-ac13-37637e35c683": {
                   "name": "ca1eb824-c371-491d-ac13-37637e35c683",
                   "vdev_type": "disk",
                   "guid": "12841765308123764671",
                   "path": "/dev/disk/by-partuuid/ca1eb824-c371-491d-ac13-37637e35c683",
                   "state": "HEALTHY",
                   "rep_dev_size": "3.64T",
                   "phys_space": "3.64T",
                   "read_errors": "0",
                   "write_errors": "0",
                   "checksum_errors": "0",
                   "vendor": "ATA",
                   "model": "WDC WD40EFZX-68AWUN0",
                   "size": "3.6T"
                 },
                 "97cd98fb-8fb8-4ac4-bc84-bd8950a7ace7": {
                   "name": "97cd98fb-8fb8-4ac4-bc84-bd8950a7ace7",
                   "vdev_type": "disk",
                   "guid": "1527839927278881561",
                   "path": "/dev/disk/by-partuuid/97cd98fb-8fb8-4ac4-bc84-bd8950a7ace7",
                   "state": "HEALTHY",
                   "rep_dev_size": "3.64T",
                   "phys_space": "3.64T",
                   "read_errors": "0",
                   "write_errors": "0",
                   "checksum_errors": "0",
                   "vendor": "ATA",
                   "model": "WDC WD40EFZX-68AWUN0",
                   "size": "3.6T"
                 },
                 "e9ddba5f-f948-4734-a472-cb8aa5f0ff65": {
                   "name": "e9ddba5f-f948-4734-a472-cb8aa5f0ff65",
                   "vdev_type": "disk",
                   "guid": "6982750226085199860",
                   "path": "/dev/disk/by-partuuid/e9ddba5f-f948-4734-a472-cb8aa5f0ff65",
                   "state": "HEALTHY",
                   "rep_dev_size": "3.64T",
                   "phys_space": "3.64T",
                   "read_errors": "0",
                   "write_errors": "0",
                   "checksum_errors": "0",
                   "vendor": "ATA",
                   "model": "WDC WD40EFZX-68AWUN0",
                   "size": "3.6T"
                 }
               }
             }
           }
         }
       },
       "dedup": {
         "mirror-2": {
           "name": "mirror-2",
           "vdev_type": "mirror",
           "guid": "2227766268377771003",
           "state": "HEALTHY",
           "alloc_space": "89.1M",
           "total_space": "3.62T",
           "def_space": "3.62T",
           "rep_dev_size": "3.62T",
           "read_errors": "0",
           "write_errors": "0",
           "checksum_errors": "0",
           "vdevs": {
             "db017360-d8e9-4163-961b-144ca75293a3": {
               "name": "db017360-d8e9-4163-961b-144ca75293a3",
               "vdev_type": "disk",
               "guid": "17880913061695450307",
               "path": "/dev/disk/by-partuuid/db017360-d8e9-4163-961b-144ca75293a3",
               "state": "HEALTHY",
               "rep_dev_size": "3.63T",
               "phys_space": "3.64T",
               "read_errors": "0",
               "write_errors": "0",
               "checksum_errors": "0",
               "vendor": "ATA",
               "model": "WDC WD40EFZX-68AWUN0",
               "size": "3.6T"
             },
             "952c3baf-b08a-4a8c-b7fa-33a07af5fe6f": {
               "name": "952c3baf-b08a-4a8c-b7fa-33a07af5fe6f",
               "vdev_type": "disk",
               "guid": "10276374011610020557",
               "path": "/dev/disk/by-partuuid/952c3baf-b08a-4a8c-b7fa-33a07af5fe6f",
               "state": "HEALTHY",
               "rep_dev_size": "3.63T",
               "phys_space": "3.64T",
               "read_errors": "0",
               "write_errors": "0",
               "checksum_errors": "0",
               "vendor": "ATA",
               "model": "WDC WD40EFZX-68AWUN0",
               "size": "3.6T"
             }
           }
         }
       },
       "special": {
         "25d418f8-92bd-4327-b59f-7ef5d5f50d81": {
           "name": "25d418f8-92bd-4327-b59f-7ef5d5f50d81",
           "vdev_type": "disk",
           "guid": "3935742873387713123",
           "path": "/dev/disk/by-partuuid/25d418f8-92bd-4327-b59f-7ef5d5f50d81",
           "state": "HEALTHY",
           "alloc_space": "37.4M",
           "total_space": "444G",
           "def_space": "444G",
           "rep_dev_size": "444G",
           "phys_space": "447G",
           "read_errors": "0",
           "write_errors": "0",
           "checksum_errors": "0",
           "vendor": "ATA",
           "model": "Micron_5300_MTFDDAK480TDS",
           "size": "447.1G"
         }
       },
       "error_count": "0"
     }
   }
 }
 .Ed
 .
 .Sh SEE ALSO
 .Xr zpool-events 8 ,
 .Xr zpool-history 8 ,
 .Xr zpool-iostat 8 ,
 .Xr zpool-list 8 ,
 .Xr zpool-resilver 8 ,
 .Xr zpool-scrub 8 ,
 .Xr zpool-wait 8
diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/abd_os.c b/sys/contrib/openzfs/module/os/freebsd/zfs/abd_os.c
index f20dc5d8c325..ab4f49a4ec5a 100644
--- a/sys/contrib/openzfs/module/os/freebsd/zfs/abd_os.c
+++ b/sys/contrib/openzfs/module/os/freebsd/zfs/abd_os.c
@@ -1,650 +1,683 @@
 /*
  * This file and its contents are supplied under the terms of the
  * Common Development and Distribution License ("CDDL"), version 1.0.
  * You may only use this file in accordance with the terms of version
  * 1.0 of the CDDL.
  *
  * A full copy of the text of the CDDL should have accompanied this
  * source.  A copy of the CDDL is also available via the Internet at
  * http://www.illumos.org/license/CDDL.
  */
 
 /*
  * Copyright (c) 2014 by Chunwei Chen. All rights reserved.
  * Copyright (c) 2016 by Delphix. All rights reserved.
  */
 
 /*
  * See abd.c for a general overview of the arc buffered data (ABD).
  *
  * Using a large proportion of scattered ABDs decreases ARC fragmentation since
  * when we are at the limit of allocatable space, using equal-size chunks will
  * allow us to quickly reclaim enough space for a new large allocation (assuming
  * it is also scattered).
  *
  * ABDs are allocated scattered by default unless the caller uses
  * abd_alloc_linear() or zfs_abd_scatter_enabled is disabled.
  */
 
 #include <sys/abd_impl.h>
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/zio.h>
 #include <sys/zfs_context.h>
 #include <sys/zfs_znode.h>
 #include <sys/vm.h>
 
 typedef struct abd_stats {
 	kstat_named_t abdstat_struct_size;
 	kstat_named_t abdstat_scatter_cnt;
 	kstat_named_t abdstat_scatter_data_size;
 	kstat_named_t abdstat_scatter_chunk_waste;
 	kstat_named_t abdstat_linear_cnt;
 	kstat_named_t abdstat_linear_data_size;
 } abd_stats_t;
 
 static abd_stats_t abd_stats = {
 	/* Amount of memory occupied by all of the abd_t struct allocations */
 	{ "struct_size",			KSTAT_DATA_UINT64 },
 	/*
 	 * The number of scatter ABDs which are currently allocated, excluding
 	 * ABDs which don't own their data (for instance the ones which were
 	 * allocated through abd_get_offset()).
 	 */
 	{ "scatter_cnt",			KSTAT_DATA_UINT64 },
 	/* Amount of data stored in all scatter ABDs tracked by scatter_cnt */
 	{ "scatter_data_size",			KSTAT_DATA_UINT64 },
 	/*
 	 * The amount of space wasted at the end of the last chunk across all
 	 * scatter ABDs tracked by scatter_cnt.
 	 */
 	{ "scatter_chunk_waste",		KSTAT_DATA_UINT64 },
 	/*
 	 * The number of linear ABDs which are currently allocated, excluding
 	 * ABDs which don't own their data (for instance the ones which were
 	 * allocated through abd_get_offset() and abd_get_from_buf()). If an
 	 * ABD takes ownership of its buf then it will become tracked.
 	 */
 	{ "linear_cnt",				KSTAT_DATA_UINT64 },
 	/* Amount of data stored in all linear ABDs tracked by linear_cnt */
 	{ "linear_data_size",			KSTAT_DATA_UINT64 },
 };
 
 struct {
 	wmsum_t abdstat_struct_size;
 	wmsum_t abdstat_scatter_cnt;
 	wmsum_t abdstat_scatter_data_size;
 	wmsum_t abdstat_scatter_chunk_waste;
 	wmsum_t abdstat_linear_cnt;
 	wmsum_t abdstat_linear_data_size;
 } abd_sums;
 
 /*
  * zfs_abd_scatter_min_size is the minimum allocation size to use scatter
  * ABD's for.  Smaller allocations will use linear ABD's which use
  * zio_[data_]buf_alloc().
  *
  * Scatter ABD's use at least one page each, so sub-page allocations waste
  * some space when allocated as scatter (e.g. 2KB scatter allocation wastes
  * half of each page).  Using linear ABD's for small allocations means that
  * they will be put on slabs which contain many allocations.
  *
  * Linear ABDs for multi-page allocations are easier to use, and in some cases
  * it allows to avoid buffer copying.  But allocation and especially free
  * of multi-page linear ABDs are expensive operations due to KVA mapping and
  * unmapping, and with time they cause KVA fragmentations.
  */
 static size_t zfs_abd_scatter_min_size = PAGE_SIZE + 1;
 
 SYSCTL_DECL(_vfs_zfs);
 
 SYSCTL_INT(_vfs_zfs, OID_AUTO, abd_scatter_enabled, CTLFLAG_RWTUN,
 	&zfs_abd_scatter_enabled, 0, "Enable scattered ARC data buffers");
 SYSCTL_ULONG(_vfs_zfs, OID_AUTO, abd_scatter_min_size, CTLFLAG_RWTUN,
 	&zfs_abd_scatter_min_size, 0, "Minimum size of scatter allocations.");
 
 kmem_cache_t *abd_chunk_cache;
 static kstat_t *abd_ksp;
 
 /*
  * We use a scattered SPA_MAXBLOCKSIZE sized ABD whose chunks are
  * just a single zero'd page-sized buffer. This allows us to conserve
  * memory by only using a single zero buffer for the scatter chunks.
  */
 abd_t *abd_zero_scatter = NULL;
 
 static uint_t
 abd_chunkcnt_for_bytes(size_t size)
 {
 	return ((size + PAGE_MASK) >> PAGE_SHIFT);
 }
 
 static inline uint_t
 abd_scatter_chunkcnt(abd_t *abd)
 {
 	ASSERT(!abd_is_linear(abd));
 	return (abd_chunkcnt_for_bytes(
 	    ABD_SCATTER(abd).abd_offset + abd->abd_size));
 }
 
 boolean_t
 abd_size_alloc_linear(size_t size)
 {
 	return (!zfs_abd_scatter_enabled || size < zfs_abd_scatter_min_size);
 }
 
 void
 abd_update_scatter_stats(abd_t *abd, abd_stats_op_t op)
 {
 	uint_t n;
 
 	n = abd_scatter_chunkcnt(abd);
 	ASSERT(op == ABDSTAT_INCR || op == ABDSTAT_DECR);
 	int waste = (n << PAGE_SHIFT) - abd->abd_size;
 	if (op == ABDSTAT_INCR) {
 		ABDSTAT_BUMP(abdstat_scatter_cnt);
 		ABDSTAT_INCR(abdstat_scatter_data_size, abd->abd_size);
 		ABDSTAT_INCR(abdstat_scatter_chunk_waste, waste);
 		arc_space_consume(waste, ARC_SPACE_ABD_CHUNK_WASTE);
 	} else {
 		ABDSTAT_BUMPDOWN(abdstat_scatter_cnt);
 		ABDSTAT_INCR(abdstat_scatter_data_size, -(int)abd->abd_size);
 		ABDSTAT_INCR(abdstat_scatter_chunk_waste, -waste);
 		arc_space_return(waste, ARC_SPACE_ABD_CHUNK_WASTE);
 	}
 }
 
 void
 abd_update_linear_stats(abd_t *abd, abd_stats_op_t op)
 {
 	ASSERT(op == ABDSTAT_INCR || op == ABDSTAT_DECR);
 	if (op == ABDSTAT_INCR) {
 		ABDSTAT_BUMP(abdstat_linear_cnt);
 		ABDSTAT_INCR(abdstat_linear_data_size, abd->abd_size);
 	} else {
 		ABDSTAT_BUMPDOWN(abdstat_linear_cnt);
 		ABDSTAT_INCR(abdstat_linear_data_size, -(int)abd->abd_size);
 	}
 }
 
 void
 abd_verify_scatter(abd_t *abd)
 {
 	uint_t i, n;
 
 	/*
 	 * There is no scatter linear pages in FreeBSD so there is
 	 * an error if the ABD has been marked as a linear page.
 	 */
 	ASSERT(!abd_is_linear_page(abd));
 	ASSERT3U(ABD_SCATTER(abd).abd_offset, <, PAGE_SIZE);
 	n = abd_scatter_chunkcnt(abd);
 	for (i = 0; i < n; i++) {
 		ASSERT3P(ABD_SCATTER(abd).abd_chunks[i], !=, NULL);
 	}
 }
 
 void
 abd_alloc_chunks(abd_t *abd, size_t size)
 {
 	uint_t i, n;
 
 	n = abd_chunkcnt_for_bytes(size);
 	for (i = 0; i < n; i++) {
 		ABD_SCATTER(abd).abd_chunks[i] =
 		    kmem_cache_alloc(abd_chunk_cache, KM_PUSHPAGE);
 	}
 }
 
 void
 abd_free_chunks(abd_t *abd)
 {
 	uint_t i, n;
 
 	/*
 	 * Scatter ABDs may be constructed by abd_alloc_from_pages() from
 	 * an array of pages. In which case they should not be freed.
 	 */
 	if (!abd_is_from_pages(abd)) {
 		n = abd_scatter_chunkcnt(abd);
 		for (i = 0; i < n; i++) {
 			kmem_cache_free(abd_chunk_cache,
 			    ABD_SCATTER(abd).abd_chunks[i]);
 		}
 	}
 }
 
 abd_t *
 abd_alloc_struct_impl(size_t size)
 {
 	uint_t chunkcnt = abd_chunkcnt_for_bytes(size);
 	/*
 	 * In the event we are allocating a gang ABD, the size passed in
 	 * will be 0. We must make sure to set abd_size to the size of an
 	 * ABD struct as opposed to an ABD scatter with 0 chunks. The gang
 	 * ABD struct allocation accounts for an additional 24 bytes over
 	 * a scatter ABD with 0 chunks.
 	 */
 	size_t abd_size = MAX(sizeof (abd_t),
 	    offsetof(abd_t, abd_u.abd_scatter.abd_chunks[chunkcnt]));
 	abd_t *abd = kmem_alloc(abd_size, KM_PUSHPAGE);
 	ASSERT3P(abd, !=, NULL);
 	ABDSTAT_INCR(abdstat_struct_size, abd_size);
 
 	return (abd);
 }
 
 void
 abd_free_struct_impl(abd_t *abd)
 {
 	uint_t chunkcnt = abd_is_linear(abd) || abd_is_gang(abd) ? 0 :
 	    abd_scatter_chunkcnt(abd);
 	ssize_t size = MAX(sizeof (abd_t),
 	    offsetof(abd_t, abd_u.abd_scatter.abd_chunks[chunkcnt]));
 	kmem_free(abd, size);
 	ABDSTAT_INCR(abdstat_struct_size, -size);
 }
 
 /*
  * Allocate scatter ABD of size SPA_MAXBLOCKSIZE, where
  * each chunk in the scatterlist will be set to the same area.
  */
 _Static_assert(ZERO_REGION_SIZE >= PAGE_SIZE, "zero_region too small");
 static void
 abd_alloc_zero_scatter(void)
 {
 	uint_t i, n;
 
 	n = abd_chunkcnt_for_bytes(SPA_MAXBLOCKSIZE);
 	abd_zero_scatter = abd_alloc_struct(SPA_MAXBLOCKSIZE);
 	abd_zero_scatter->abd_flags |= ABD_FLAG_OWNER;
 	abd_zero_scatter->abd_size = SPA_MAXBLOCKSIZE;
 
 	ABD_SCATTER(abd_zero_scatter).abd_offset = 0;
 
 	for (i = 0; i < n; i++) {
 		ABD_SCATTER(abd_zero_scatter).abd_chunks[i] =
 		    __DECONST(void *, zero_region);
 	}
 
 	ABDSTAT_BUMP(abdstat_scatter_cnt);
 	ABDSTAT_INCR(abdstat_scatter_data_size, PAGE_SIZE);
 }
 
 static void
 abd_free_zero_scatter(void)
 {
 	ABDSTAT_BUMPDOWN(abdstat_scatter_cnt);
 	ABDSTAT_INCR(abdstat_scatter_data_size, -(int)PAGE_SIZE);
 
 	abd_free_struct(abd_zero_scatter);
 	abd_zero_scatter = NULL;
 }
 
 static int
 abd_kstats_update(kstat_t *ksp, int rw)
 {
 	abd_stats_t *as = ksp->ks_data;
 
 	if (rw == KSTAT_WRITE)
 		return (EACCES);
 	as->abdstat_struct_size.value.ui64 =
 	    wmsum_value(&abd_sums.abdstat_struct_size);
 	as->abdstat_scatter_cnt.value.ui64 =
 	    wmsum_value(&abd_sums.abdstat_scatter_cnt);
 	as->abdstat_scatter_data_size.value.ui64 =
 	    wmsum_value(&abd_sums.abdstat_scatter_data_size);
 	as->abdstat_scatter_chunk_waste.value.ui64 =
 	    wmsum_value(&abd_sums.abdstat_scatter_chunk_waste);
 	as->abdstat_linear_cnt.value.ui64 =
 	    wmsum_value(&abd_sums.abdstat_linear_cnt);
 	as->abdstat_linear_data_size.value.ui64 =
 	    wmsum_value(&abd_sums.abdstat_linear_data_size);
 	return (0);
 }
 
 void
 abd_init(void)
 {
 	abd_chunk_cache = kmem_cache_create("abd_chunk", PAGE_SIZE, 0,
 	    NULL, NULL, NULL, NULL, 0, KMC_NODEBUG | KMC_RECLAIMABLE);
 
 	wmsum_init(&abd_sums.abdstat_struct_size, 0);
 	wmsum_init(&abd_sums.abdstat_scatter_cnt, 0);
 	wmsum_init(&abd_sums.abdstat_scatter_data_size, 0);
 	wmsum_init(&abd_sums.abdstat_scatter_chunk_waste, 0);
 	wmsum_init(&abd_sums.abdstat_linear_cnt, 0);
 	wmsum_init(&abd_sums.abdstat_linear_data_size, 0);
 
 	abd_ksp = kstat_create("zfs", 0, "abdstats", "misc", KSTAT_TYPE_NAMED,
 	    sizeof (abd_stats) / sizeof (kstat_named_t), KSTAT_FLAG_VIRTUAL);
 	if (abd_ksp != NULL) {
 		abd_ksp->ks_data = &abd_stats;
 		abd_ksp->ks_update = abd_kstats_update;
 		kstat_install(abd_ksp);
 	}
 
 	abd_alloc_zero_scatter();
 }
 
 void
 abd_fini(void)
 {
 	abd_free_zero_scatter();
 
 	if (abd_ksp != NULL) {
 		kstat_delete(abd_ksp);
 		abd_ksp = NULL;
 	}
 
 	wmsum_fini(&abd_sums.abdstat_struct_size);
 	wmsum_fini(&abd_sums.abdstat_scatter_cnt);
 	wmsum_fini(&abd_sums.abdstat_scatter_data_size);
 	wmsum_fini(&abd_sums.abdstat_scatter_chunk_waste);
 	wmsum_fini(&abd_sums.abdstat_linear_cnt);
 	wmsum_fini(&abd_sums.abdstat_linear_data_size);
 
 	kmem_cache_destroy(abd_chunk_cache);
 	abd_chunk_cache = NULL;
 }
 
 void
 abd_free_linear_page(abd_t *abd)
 {
 	ASSERT3P(abd->abd_u.abd_linear.sf, !=, NULL);
 	zfs_unmap_page(abd->abd_u.abd_linear.sf);
 }
 
 /*
  * If we're going to use this ABD for doing I/O using the block layer, the
  * consumer of the ABD data doesn't care if it's scattered or not, and we don't
  * plan to store this ABD in memory for a long period of time, we should
  * allocate the ABD type that requires the least data copying to do the I/O.
  *
  * Currently this is linear ABDs, however if ldi_strategy() can ever issue I/Os
  * using a scatter/gather list we should switch to that and replace this call
  * with vanilla abd_alloc().
  */
 abd_t *
 abd_alloc_for_io(size_t size, boolean_t is_metadata)
 {
 	return (abd_alloc_linear(size, is_metadata));
 }
 
 static abd_t *
 abd_get_offset_from_pages(abd_t *abd, abd_t *sabd, size_t chunkcnt,
     size_t new_offset)
 {
 	ASSERT(abd_is_from_pages(sabd));
 
 	/*
 	 * Set the child child chunks to point at the parent chunks as
 	 * the chunks are just pages and we don't want to copy them.
 	 */
 	size_t parent_offset = new_offset / PAGE_SIZE;
 	ASSERT3U(parent_offset, <, abd_scatter_chunkcnt(sabd));
 	for (int i = 0; i < chunkcnt; i++)
 		ABD_SCATTER(abd).abd_chunks[i] =
 		    ABD_SCATTER(sabd).abd_chunks[parent_offset + i];
 
 	abd->abd_flags |= ABD_FLAG_FROM_PAGES;
 	return (abd);
 }
 
 abd_t *
 abd_get_offset_scatter(abd_t *abd, abd_t *sabd, size_t off,
     size_t size)
 {
 	abd_verify(sabd);
 	ASSERT3U(off, <=, sabd->abd_size);
 
 	size_t new_offset = ABD_SCATTER(sabd).abd_offset + off;
 	size_t chunkcnt = abd_chunkcnt_for_bytes(
 	    (new_offset & PAGE_MASK) + size);
 
 	ASSERT3U(chunkcnt, <=, abd_scatter_chunkcnt(sabd));
 
 	/*
 	 * If an abd struct is provided, it is only the minimum size.  If we
 	 * need additional chunks, we need to allocate a new struct.
 	 */
 	if (abd != NULL &&
 	    offsetof(abd_t, abd_u.abd_scatter.abd_chunks[chunkcnt]) >
 	    sizeof (abd_t)) {
 		abd = NULL;
 	}
 
 	if (abd == NULL)
 		abd = abd_alloc_struct(chunkcnt << PAGE_SHIFT);
 
 	/*
 	 * Even if this buf is filesystem metadata, we only track that
 	 * if we own the underlying data buffer, which is not true in
 	 * this case. Therefore, we don't ever use ABD_FLAG_META here.
 	 */
 
 	ABD_SCATTER(abd).abd_offset = new_offset & PAGE_MASK;
 
 	if (abd_is_from_pages(sabd)) {
 		return (abd_get_offset_from_pages(abd, sabd, chunkcnt,
 		    new_offset));
 	}
 
 	/* Copy the scatterlist starting at the correct offset */
 	(void) memcpy(&ABD_SCATTER(abd).abd_chunks,
 	    &ABD_SCATTER(sabd).abd_chunks[new_offset >> PAGE_SHIFT],
 	    chunkcnt * sizeof (void *));
 
 	return (abd);
 }
 
 /*
  * Allocate a scatter ABD structure from user pages.
  */
 abd_t *
 abd_alloc_from_pages(vm_page_t *pages, unsigned long offset, uint64_t size)
 {
 	VERIFY3U(size, <=, DMU_MAX_ACCESS);
 	ASSERT3U(offset, <, PAGE_SIZE);
 	ASSERT3P(pages, !=, NULL);
 
 	abd_t *abd = abd_alloc_struct(size);
 	abd->abd_flags |= ABD_FLAG_OWNER | ABD_FLAG_FROM_PAGES;
 	abd->abd_size = size;
 
 	if ((offset + size) <= PAGE_SIZE) {
 		/*
 		 * There is only a single page worth of data, so we will just
 		 * use  a linear ABD. We have to make sure to take into account
 		 * the offset though. In all other cases our offset will be 0
 		 * as we are always PAGE_SIZE aligned.
 		 */
 		abd->abd_flags |= ABD_FLAG_LINEAR | ABD_FLAG_LINEAR_PAGE;
 		ABD_LINEAR_BUF(abd) = (char *)zfs_map_page(pages[0],
 		    &abd->abd_u.abd_linear.sf) + offset;
 	} else {
 		ABD_SCATTER(abd).abd_offset = offset;
 		ASSERT0(ABD_SCATTER(abd).abd_offset);
 
 		/*
 		 * Setting the ABD's abd_chunks to point to the user pages.
 		 */
 		for (int i = 0; i < abd_chunkcnt_for_bytes(size); i++)
 			ABD_SCATTER(abd).abd_chunks[i] = pages[i];
 	}
 
 	return (abd);
 }
 
 /*
  * Initialize the abd_iter.
  */
 void
 abd_iter_init(struct abd_iter *aiter, abd_t *abd)
 {
 	ASSERT(!abd_is_gang(abd));
 	abd_verify(abd);
 	memset(aiter, 0, sizeof (struct abd_iter));
 	aiter->iter_abd = abd;
 }
 
 /*
  * This is just a helper function to see if we have exhausted the
  * abd_iter and reached the end.
  */
 boolean_t
 abd_iter_at_end(struct abd_iter *aiter)
 {
 	return (aiter->iter_pos == aiter->iter_abd->abd_size);
 }
 
 /*
  * Advance the iterator by a certain amount. Cannot be called when a chunk is
  * in use. This can be safely called when the aiter has already exhausted, in
  * which case this does nothing.
  */
 void
 abd_iter_advance(struct abd_iter *aiter, size_t amount)
 {
 	ASSERT3P(aiter->iter_mapaddr, ==, NULL);
 	ASSERT0(aiter->iter_mapsize);
 
 	/* There's nothing left to advance to, so do nothing */
 	if (abd_iter_at_end(aiter))
 		return;
 
 	aiter->iter_pos += amount;
 }
 
 /*
  * Map the current chunk into aiter. This can be safely called when the aiter
  * has already exhausted, in which case this does nothing.
  */
 void
 abd_iter_map(struct abd_iter *aiter)
 {
 	void *paddr;
 
 	ASSERT3P(aiter->iter_mapaddr, ==, NULL);
 	ASSERT0(aiter->iter_mapsize);
 
 	/* There's nothing left to iterate over, so do nothing */
 	if (abd_iter_at_end(aiter))
 		return;
 
 	abd_t *abd = aiter->iter_abd;
 	size_t offset = aiter->iter_pos;
 	if (abd_is_linear(abd)) {
 		aiter->iter_mapsize = abd->abd_size - offset;
 		paddr = ABD_LINEAR_BUF(abd);
 	} else if (abd_is_from_pages(abd)) {
 		aiter->sf = NULL;
 		offset += ABD_SCATTER(abd).abd_offset;
 		size_t index = offset / PAGE_SIZE;
 		offset &= PAGE_MASK;
 		aiter->iter_mapsize = MIN(PAGE_SIZE - offset,
 		    abd->abd_size - aiter->iter_pos);
 		paddr = zfs_map_page(
 		    ABD_SCATTER(aiter->iter_abd).abd_chunks[index],
 		    &aiter->sf);
 	} else {
 		offset += ABD_SCATTER(abd).abd_offset;
 		paddr = ABD_SCATTER(abd).abd_chunks[offset >> PAGE_SHIFT];
 		offset &= PAGE_MASK;
 		aiter->iter_mapsize = MIN(PAGE_SIZE - offset,
 		    abd->abd_size - aiter->iter_pos);
 	}
 	aiter->iter_mapaddr = (char *)paddr + offset;
 }
 
 /*
  * Unmap the current chunk from aiter. This can be safely called when the aiter
  * has already exhausted, in which case this does nothing.
  */
 void
 abd_iter_unmap(struct abd_iter *aiter)
 {
 	if (!abd_iter_at_end(aiter)) {
 		ASSERT3P(aiter->iter_mapaddr, !=, NULL);
 		ASSERT3U(aiter->iter_mapsize, >, 0);
 	}
 
 	if (abd_is_from_pages(aiter->iter_abd) &&
 	    !abd_is_linear_page(aiter->iter_abd)) {
 		ASSERT3P(aiter->sf, !=, NULL);
 		zfs_unmap_page(aiter->sf);
 	}
 
 	aiter->iter_mapaddr = NULL;
 	aiter->iter_mapsize = 0;
 }
 
 void
 abd_cache_reap_now(void)
 {
 	kmem_cache_reap_soon(abd_chunk_cache);
 }
 
 /*
  * Borrow a raw buffer from an ABD without copying the contents of the ABD
  * into the buffer. If the ABD is scattered, this will alloate 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, >=, 0);
 	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
- * no 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.
+ * not change the contents of the ABD. If you want any changes you made to
+ * buf to be copied back to abd, use abd_return_buf_copy() instead. If the
+ * ABD is not constructed from user pages from Direct I/O then an ASSERT
+ * checks to make sure the contents of the buffer have not changed since it was
+ * borrowed. We can not ASSERT the contents of the buffer have not changed if
+ * it is composed of user pages. While Direct I/O write pages are placed under
+ * write protection and can not be changed, this is not the case for Direct I/O
+ * reads. The pages of a Direct I/O read could be manipulated at any time.
+ * Checksum verifications in the ZIO pipeline check for this issue and handle
+ * it by returning an error on checksum verification failure.
  */
 void
 abd_return_buf(abd_t *abd, void *buf, size_t n)
 {
 	abd_verify(abd);
 	ASSERT3U(abd->abd_size, >=, n);
 #ifdef ZFS_DEBUG
 	(void) zfs_refcount_remove_many(&abd->abd_children, n, buf);
 #endif
-	if (abd_is_linear(abd)) {
+	if (abd_is_from_pages(abd)) {
+		if (!abd_is_linear_page(abd))
+			zio_buf_free(buf, n);
+	} else if (abd_is_linear(abd)) {
 		ASSERT3P(buf, ==, abd_to_buf(abd));
+	} else if (abd_is_gang(abd)) {
+#ifdef ZFS_DEBUG
+		/*
+		 * We have to be careful with gang ABD's that we do not ASSERT
+		 * for any ABD's that contain user pages from Direct I/O. See
+		 * the comment above about Direct I/O read buffers possibly
+		 * being manipulated. In order to handle this, we jsut iterate
+		 * through the gang ABD and only verify ABD's that are not from
+		 * user pages.
+		 */
+		void *cmp_buf = buf;
+
+		for (abd_t *cabd = list_head(&ABD_GANG(abd).abd_gang_chain);
+		    cabd != NULL;
+		    cabd = list_next(&ABD_GANG(abd).abd_gang_chain, cabd)) {
+			if (!abd_is_from_pages(cabd)) {
+				ASSERT0(abd_cmp_buf(cabd, cmp_buf,
+				    cabd->abd_size));
+			}
+			cmp_buf = (char *)cmp_buf + cabd->abd_size;
+		}
+#endif
+		zio_buf_free(buf, n);
 	} else {
 		ASSERT0(abd_cmp_buf(abd, buf, n));
 		zio_buf_free(buf, n);
 	}
 }
 
 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);
 }
diff --git a/sys/contrib/openzfs/module/os/linux/zfs/abd_os.c b/sys/contrib/openzfs/module/os/linux/zfs/abd_os.c
index 03362b1ee860..303af48cf3af 100644
--- a/sys/contrib/openzfs/module/os/linux/zfs/abd_os.c
+++ b/sys/contrib/openzfs/module/os/linux/zfs/abd_os.c
@@ -1,1348 +1,1350 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 /*
  * Copyright (c) 2014 by Chunwei Chen. All rights reserved.
  * Copyright (c) 2019 by Delphix. All rights reserved.
  * Copyright (c) 2023, 2024, Klara Inc.
  */
 
 /*
  * See abd.c for a general overview of the arc buffered data (ABD).
  *
  * Linear buffers act exactly like normal buffers and are always mapped into the
  * kernel's virtual memory space, while scattered ABD data chunks are allocated
  * as physical pages and then mapped in only while they are actually being
  * accessed through one of the abd_* library functions. Using scattered ABDs
  * provides several benefits:
  *
  *  (1) They avoid use of kmem_*, preventing performance problems where running
  *      kmem_reap on very large memory systems never finishes and causes
  *      constant TLB shootdowns.
  *
  *  (2) Fragmentation is less of an issue since when we are at the limit of
  *      allocatable space, we won't have to search around for a long free
  *      hole in the VA space for large ARC allocations. Each chunk is mapped in
  *      individually, so even if we are using HIGHMEM (see next point) we
  *      wouldn't need to worry about finding a contiguous address range.
  *
  *  (3) If we are not using HIGHMEM, then all physical memory is always
  *      mapped into the kernel's address space, so we also avoid the map /
  *      unmap costs on each ABD access.
  *
  * If we are not using HIGHMEM, scattered buffers which have only one chunk
  * can be treated as linear buffers, because they are contiguous in the
  * kernel's virtual address space.  See abd_alloc_chunks() for details.
  */
 
 #include <sys/abd_impl.h>
 #include <sys/param.h>
 #include <sys/zio.h>
 #include <sys/arc.h>
 #include <sys/zfs_context.h>
 #include <sys/zfs_znode.h>
 #include <linux/kmap_compat.h>
 #include <linux/mm_compat.h>
 #include <linux/scatterlist.h>
 #include <linux/version.h>
 
 #if defined(MAX_ORDER)
 #define	ABD_MAX_ORDER	(MAX_ORDER)
 #elif defined(MAX_PAGE_ORDER)
 #define	ABD_MAX_ORDER	(MAX_PAGE_ORDER)
 #endif
 
 typedef struct abd_stats {
 	kstat_named_t abdstat_struct_size;
 	kstat_named_t abdstat_linear_cnt;
 	kstat_named_t abdstat_linear_data_size;
 	kstat_named_t abdstat_scatter_cnt;
 	kstat_named_t abdstat_scatter_data_size;
 	kstat_named_t abdstat_scatter_chunk_waste;
 	kstat_named_t abdstat_scatter_orders[ABD_MAX_ORDER];
 	kstat_named_t abdstat_scatter_page_multi_chunk;
 	kstat_named_t abdstat_scatter_page_multi_zone;
 	kstat_named_t abdstat_scatter_page_alloc_retry;
 	kstat_named_t abdstat_scatter_sg_table_retry;
 } abd_stats_t;
 
 static abd_stats_t abd_stats = {
 	/* Amount of memory occupied by all of the abd_t struct allocations */
 	{ "struct_size",			KSTAT_DATA_UINT64 },
 	/*
 	 * The number of linear ABDs which are currently allocated, excluding
 	 * ABDs which don't own their data (for instance the ones which were
 	 * allocated through abd_get_offset() and abd_get_from_buf()). If an
 	 * ABD takes ownership of its buf then it will become tracked.
 	 */
 	{ "linear_cnt",				KSTAT_DATA_UINT64 },
 	/* Amount of data stored in all linear ABDs tracked by linear_cnt */
 	{ "linear_data_size",			KSTAT_DATA_UINT64 },
 	/*
 	 * The number of scatter ABDs which are currently allocated, excluding
 	 * ABDs which don't own their data (for instance the ones which were
 	 * allocated through abd_get_offset()).
 	 */
 	{ "scatter_cnt",			KSTAT_DATA_UINT64 },
 	/* Amount of data stored in all scatter ABDs tracked by scatter_cnt */
 	{ "scatter_data_size",			KSTAT_DATA_UINT64 },
 	/*
 	 * The amount of space wasted at the end of the last chunk across all
 	 * scatter ABDs tracked by scatter_cnt.
 	 */
 	{ "scatter_chunk_waste",		KSTAT_DATA_UINT64 },
 	/*
 	 * The number of compound allocations of a given order.  These
 	 * allocations are spread over all currently allocated ABDs, and
 	 * act as a measure of memory fragmentation.
 	 */
 	{ { "scatter_order_N",			KSTAT_DATA_UINT64 } },
 	/*
 	 * The number of scatter ABDs which contain multiple chunks.
 	 * ABDs are preferentially allocated from the minimum number of
 	 * contiguous multi-page chunks, a single chunk is optimal.
 	 */
 	{ "scatter_page_multi_chunk",		KSTAT_DATA_UINT64 },
 	/*
 	 * The number of scatter ABDs which are split across memory zones.
 	 * ABDs are preferentially allocated using pages from a single zone.
 	 */
 	{ "scatter_page_multi_zone",		KSTAT_DATA_UINT64 },
 	/*
 	 *  The total number of retries encountered when attempting to
 	 *  allocate the pages to populate the scatter ABD.
 	 */
 	{ "scatter_page_alloc_retry",		KSTAT_DATA_UINT64 },
 	/*
 	 *  The total number of retries encountered when attempting to
 	 *  allocate the sg table for an ABD.
 	 */
 	{ "scatter_sg_table_retry",		KSTAT_DATA_UINT64 },
 };
 
 static struct {
 	wmsum_t abdstat_struct_size;
 	wmsum_t abdstat_linear_cnt;
 	wmsum_t abdstat_linear_data_size;
 	wmsum_t abdstat_scatter_cnt;
 	wmsum_t abdstat_scatter_data_size;
 	wmsum_t abdstat_scatter_chunk_waste;
 	wmsum_t abdstat_scatter_orders[ABD_MAX_ORDER];
 	wmsum_t abdstat_scatter_page_multi_chunk;
 	wmsum_t abdstat_scatter_page_multi_zone;
 	wmsum_t abdstat_scatter_page_alloc_retry;
 	wmsum_t abdstat_scatter_sg_table_retry;
 } abd_sums;
 
 #define	abd_for_each_sg(abd, sg, n, i)	\
 	for_each_sg(ABD_SCATTER(abd).abd_sgl, sg, n, i)
 
 /*
  * zfs_abd_scatter_min_size is the minimum allocation size to use scatter
  * ABD's.  Smaller allocations will use linear ABD's which uses
  * zio_[data_]buf_alloc().
  *
  * Scatter ABD's use at least one page each, so sub-page allocations waste
  * some space when allocated as scatter (e.g. 2KB scatter allocation wastes
  * half of each page).  Using linear ABD's for small allocations means that
  * they will be put on slabs which contain many allocations.  This can
  * improve memory efficiency, but it also makes it much harder for ARC
  * evictions to actually free pages, because all the buffers on one slab need
  * to be freed in order for the slab (and underlying pages) to be freed.
  * Typically, 512B and 1KB kmem caches have 16 buffers per slab, so it's
  * possible for them to actually waste more memory than scatter (one page per
  * buf = wasting 3/4 or 7/8th; one buf per slab = wasting 15/16th).
  *
  * Spill blocks are typically 512B and are heavily used on systems running
  * selinux with the default dnode size and the `xattr=sa` property set.
  *
  * By default we use linear allocations for 512B and 1KB, and scatter
  * allocations for larger (1.5KB and up).
  */
 static int zfs_abd_scatter_min_size = 512 * 3;
 
 /*
  * We use a scattered SPA_MAXBLOCKSIZE sized ABD whose pages are
  * just a single zero'd page. This allows us to conserve memory by
  * only using a single zero page for the scatterlist.
  */
 abd_t *abd_zero_scatter = NULL;
 
 struct page;
 
 /*
  * abd_zero_page is assigned to each of the pages of abd_zero_scatter. It will
  * point to ZERO_PAGE if it is available or it will be an allocated zero'd
  * PAGESIZE buffer.
  */
 static struct page *abd_zero_page = NULL;
 
 static kmem_cache_t *abd_cache = NULL;
 static kstat_t *abd_ksp;
 
 static uint_t
 abd_chunkcnt_for_bytes(size_t size)
 {
 	return (P2ROUNDUP(size, PAGESIZE) / PAGESIZE);
 }
 
 abd_t *
 abd_alloc_struct_impl(size_t size)
 {
 	/*
 	 * In Linux we do not use the size passed in during ABD
 	 * allocation, so we just ignore it.
 	 */
 	(void) size;
 	abd_t *abd = kmem_cache_alloc(abd_cache, KM_PUSHPAGE);
 	ASSERT3P(abd, !=, NULL);
 	ABDSTAT_INCR(abdstat_struct_size, sizeof (abd_t));
 
 	return (abd);
 }
 
 void
 abd_free_struct_impl(abd_t *abd)
 {
 	kmem_cache_free(abd_cache, abd);
 	ABDSTAT_INCR(abdstat_struct_size, -(int)sizeof (abd_t));
 }
 
 static unsigned zfs_abd_scatter_max_order = ABD_MAX_ORDER - 1;
 
 /*
  * Mark zfs data pages so they can be excluded from kernel crash dumps
  */
 #ifdef _LP64
 #define	ABD_FILE_CACHE_PAGE	0x2F5ABDF11ECAC4E
 
 static inline void
 abd_mark_zfs_page(struct page *page)
 {
 	get_page(page);
 	SetPagePrivate(page);
 	set_page_private(page, ABD_FILE_CACHE_PAGE);
 }
 
 static inline void
 abd_unmark_zfs_page(struct page *page)
 {
 	set_page_private(page, 0UL);
 	ClearPagePrivate(page);
 	put_page(page);
 }
 #else
 #define	abd_mark_zfs_page(page)
 #define	abd_unmark_zfs_page(page)
 #endif /* _LP64 */
 
 #ifndef CONFIG_HIGHMEM
 
 #ifndef __GFP_RECLAIM
 #define	__GFP_RECLAIM		__GFP_WAIT
 #endif
 
 /*
  * The goal is to minimize fragmentation by preferentially populating ABDs
  * with higher order compound pages from a single zone.  Allocation size is
  * progressively decreased until it can be satisfied without performing
  * reclaim or compaction.  When necessary this function will degenerate to
  * allocating individual pages and allowing reclaim to satisfy allocations.
  */
 void
 abd_alloc_chunks(abd_t *abd, size_t size)
 {
 	struct list_head pages;
 	struct sg_table table;
 	struct scatterlist *sg;
 	struct page *page, *tmp_page = NULL;
 	gfp_t gfp = __GFP_RECLAIMABLE | __GFP_NOWARN | GFP_NOIO;
 	gfp_t gfp_comp = (gfp | __GFP_NORETRY | __GFP_COMP) & ~__GFP_RECLAIM;
 	unsigned int max_order = MIN(zfs_abd_scatter_max_order,
 	    ABD_MAX_ORDER - 1);
 	unsigned int nr_pages = abd_chunkcnt_for_bytes(size);
 	unsigned int chunks = 0, zones = 0;
 	size_t remaining_size;
 	int nid = NUMA_NO_NODE;
 	unsigned int alloc_pages = 0;
 
 	INIT_LIST_HEAD(&pages);
 
 	ASSERT3U(alloc_pages, <, nr_pages);
 
 	while (alloc_pages < nr_pages) {
 		unsigned int chunk_pages;
 		unsigned int order;
 
 		order = MIN(highbit64(nr_pages - alloc_pages) - 1, max_order);
 		chunk_pages = (1U << order);
 
 		page = alloc_pages_node(nid, order ? gfp_comp : gfp, order);
 		if (page == NULL) {
 			if (order == 0) {
 				ABDSTAT_BUMP(abdstat_scatter_page_alloc_retry);
 				schedule_timeout_interruptible(1);
 			} else {
 				max_order = MAX(0, order - 1);
 			}
 			continue;
 		}
 
 		list_add_tail(&page->lru, &pages);
 
 		if ((nid != NUMA_NO_NODE) && (page_to_nid(page) != nid))
 			zones++;
 
 		nid = page_to_nid(page);
 		ABDSTAT_BUMP(abdstat_scatter_orders[order]);
 		chunks++;
 		alloc_pages += chunk_pages;
 	}
 
 	ASSERT3S(alloc_pages, ==, nr_pages);
 
 	while (sg_alloc_table(&table, chunks, gfp)) {
 		ABDSTAT_BUMP(abdstat_scatter_sg_table_retry);
 		schedule_timeout_interruptible(1);
 	}
 
 	sg = table.sgl;
 	remaining_size = size;
 	list_for_each_entry_safe(page, tmp_page, &pages, lru) {
 		size_t sg_size = MIN(PAGESIZE << compound_order(page),
 		    remaining_size);
 		sg_set_page(sg, page, sg_size, 0);
 		abd_mark_zfs_page(page);
 		remaining_size -= sg_size;
 
 		sg = sg_next(sg);
 		list_del(&page->lru);
 	}
 
 	/*
 	 * These conditions ensure that a possible transformation to a linear
 	 * ABD would be valid.
 	 */
 	ASSERT(!PageHighMem(sg_page(table.sgl)));
 	ASSERT0(ABD_SCATTER(abd).abd_offset);
 
 	if (table.nents == 1) {
 		/*
 		 * Since there is only one entry, this ABD can be represented
 		 * as a linear buffer.  All single-page (4K) ABD's can be
 		 * represented this way.  Some multi-page ABD's can also be
 		 * represented this way, if we were able to allocate a single
 		 * "chunk" (higher-order "page" which represents a power-of-2
 		 * series of physically-contiguous pages).  This is often the
 		 * case for 2-page (8K) ABD's.
 		 *
 		 * Representing a single-entry scatter ABD as a linear ABD
 		 * has the performance advantage of avoiding the copy (and
 		 * allocation) in abd_borrow_buf_copy / abd_return_buf_copy.
 		 * A performance increase of around 5% has been observed for
 		 * ARC-cached reads (of small blocks which can take advantage
 		 * of this).
 		 *
 		 * Note that this optimization is only possible because the
 		 * pages are always mapped into the kernel's address space.
 		 * This is not the case for highmem pages, so the
 		 * optimization can not be made there.
 		 */
 		abd->abd_flags |= ABD_FLAG_LINEAR;
 		abd->abd_flags |= ABD_FLAG_LINEAR_PAGE;
 		abd->abd_u.abd_linear.abd_sgl = table.sgl;
 		ABD_LINEAR_BUF(abd) = page_address(sg_page(table.sgl));
 	} else if (table.nents > 1) {
 		ABDSTAT_BUMP(abdstat_scatter_page_multi_chunk);
 		abd->abd_flags |= ABD_FLAG_MULTI_CHUNK;
 
 		if (zones) {
 			ABDSTAT_BUMP(abdstat_scatter_page_multi_zone);
 			abd->abd_flags |= ABD_FLAG_MULTI_ZONE;
 		}
 
 		ABD_SCATTER(abd).abd_sgl = table.sgl;
 		ABD_SCATTER(abd).abd_nents = table.nents;
 	}
 }
 #else
 
 /*
  * Allocate N individual pages to construct a scatter ABD.  This function
  * makes no attempt to request contiguous pages and requires the minimal
  * number of kernel interfaces.  It's designed for maximum compatibility.
  */
 void
 abd_alloc_chunks(abd_t *abd, size_t size)
 {
 	struct scatterlist *sg = NULL;
 	struct sg_table table;
 	struct page *page;
 	gfp_t gfp = __GFP_RECLAIMABLE | __GFP_NOWARN | GFP_NOIO;
 	int nr_pages = abd_chunkcnt_for_bytes(size);
 	int i = 0;
 
 	while (sg_alloc_table(&table, nr_pages, gfp)) {
 		ABDSTAT_BUMP(abdstat_scatter_sg_table_retry);
 		schedule_timeout_interruptible(1);
 	}
 
 	ASSERT3U(table.nents, ==, nr_pages);
 	ABD_SCATTER(abd).abd_sgl = table.sgl;
 	ABD_SCATTER(abd).abd_nents = nr_pages;
 
 	abd_for_each_sg(abd, sg, nr_pages, i) {
 		while ((page = __page_cache_alloc(gfp)) == NULL) {
 			ABDSTAT_BUMP(abdstat_scatter_page_alloc_retry);
 			schedule_timeout_interruptible(1);
 		}
 
 		ABDSTAT_BUMP(abdstat_scatter_orders[0]);
 		sg_set_page(sg, page, PAGESIZE, 0);
 		abd_mark_zfs_page(page);
 	}
 
 	if (nr_pages > 1) {
 		ABDSTAT_BUMP(abdstat_scatter_page_multi_chunk);
 		abd->abd_flags |= ABD_FLAG_MULTI_CHUNK;
 	}
 }
 #endif /* !CONFIG_HIGHMEM */
 
 /*
  * This must be called if any of the sg_table allocation functions
  * are called.
  */
 static void
 abd_free_sg_table(abd_t *abd)
 {
 	struct sg_table table;
 
 	table.sgl = ABD_SCATTER(abd).abd_sgl;
 	table.nents = table.orig_nents = ABD_SCATTER(abd).abd_nents;
 	sg_free_table(&table);
 }
 
 void
 abd_free_chunks(abd_t *abd)
 {
 	struct scatterlist *sg = NULL;
 	struct page *page;
 	int nr_pages = ABD_SCATTER(abd).abd_nents;
 	int order, i = 0;
 
 	if (abd->abd_flags & ABD_FLAG_MULTI_ZONE)
 		ABDSTAT_BUMPDOWN(abdstat_scatter_page_multi_zone);
 
 	if (abd->abd_flags & ABD_FLAG_MULTI_CHUNK)
 		ABDSTAT_BUMPDOWN(abdstat_scatter_page_multi_chunk);
 
 	/*
 	 * Scatter ABDs may be constructed by abd_alloc_from_pages() from
 	 * an array of pages. In which case they should not be freed.
 	 */
 	if (!abd_is_from_pages(abd)) {
 		abd_for_each_sg(abd, sg, nr_pages, i) {
 			page = sg_page(sg);
 			abd_unmark_zfs_page(page);
 			order = compound_order(page);
 			__free_pages(page, order);
 			ASSERT3U(sg->length, <=, PAGE_SIZE << order);
 			ABDSTAT_BUMPDOWN(abdstat_scatter_orders[order]);
 		}
 	}
 
 	abd_free_sg_table(abd);
 }
 
 /*
  * Allocate scatter ABD of size SPA_MAXBLOCKSIZE, where each page in
  * the scatterlist will be set to the zero'd out buffer abd_zero_page.
  */
 static void
 abd_alloc_zero_scatter(void)
 {
 	struct scatterlist *sg = NULL;
 	struct sg_table table;
 	gfp_t gfp = __GFP_NOWARN | GFP_NOIO;
 	int nr_pages = abd_chunkcnt_for_bytes(SPA_MAXBLOCKSIZE);
 	int i = 0;
 
 #if defined(HAVE_ZERO_PAGE_GPL_ONLY)
 	gfp_t gfp_zero_page = gfp | __GFP_ZERO;
 	while ((abd_zero_page = __page_cache_alloc(gfp_zero_page)) == NULL) {
 		ABDSTAT_BUMP(abdstat_scatter_page_alloc_retry);
 		schedule_timeout_interruptible(1);
 	}
 	abd_mark_zfs_page(abd_zero_page);
 #else
 	abd_zero_page = ZERO_PAGE(0);
 #endif /* HAVE_ZERO_PAGE_GPL_ONLY */
 
 	while (sg_alloc_table(&table, nr_pages, gfp)) {
 		ABDSTAT_BUMP(abdstat_scatter_sg_table_retry);
 		schedule_timeout_interruptible(1);
 	}
 	ASSERT3U(table.nents, ==, nr_pages);
 
 	abd_zero_scatter = abd_alloc_struct(SPA_MAXBLOCKSIZE);
 	abd_zero_scatter->abd_flags |= ABD_FLAG_OWNER;
 	ABD_SCATTER(abd_zero_scatter).abd_offset = 0;
 	ABD_SCATTER(abd_zero_scatter).abd_sgl = table.sgl;
 	ABD_SCATTER(abd_zero_scatter).abd_nents = nr_pages;
 	abd_zero_scatter->abd_size = SPA_MAXBLOCKSIZE;
 	abd_zero_scatter->abd_flags |= ABD_FLAG_MULTI_CHUNK;
 
 	abd_for_each_sg(abd_zero_scatter, sg, nr_pages, i) {
 		sg_set_page(sg, abd_zero_page, PAGESIZE, 0);
 	}
 
 	ABDSTAT_BUMP(abdstat_scatter_cnt);
 	ABDSTAT_INCR(abdstat_scatter_data_size, PAGESIZE);
 	ABDSTAT_BUMP(abdstat_scatter_page_multi_chunk);
 }
 
 boolean_t
 abd_size_alloc_linear(size_t size)
 {
 	return (!zfs_abd_scatter_enabled || size < zfs_abd_scatter_min_size);
 }
 
 void
 abd_update_scatter_stats(abd_t *abd, abd_stats_op_t op)
 {
 	ASSERT(op == ABDSTAT_INCR || op == ABDSTAT_DECR);
 	int waste = P2ROUNDUP(abd->abd_size, PAGESIZE) - abd->abd_size;
 	if (op == ABDSTAT_INCR) {
 		ABDSTAT_BUMP(abdstat_scatter_cnt);
 		ABDSTAT_INCR(abdstat_scatter_data_size, abd->abd_size);
 		ABDSTAT_INCR(abdstat_scatter_chunk_waste, waste);
 		arc_space_consume(waste, ARC_SPACE_ABD_CHUNK_WASTE);
 	} else {
 		ABDSTAT_BUMPDOWN(abdstat_scatter_cnt);
 		ABDSTAT_INCR(abdstat_scatter_data_size, -(int)abd->abd_size);
 		ABDSTAT_INCR(abdstat_scatter_chunk_waste, -waste);
 		arc_space_return(waste, ARC_SPACE_ABD_CHUNK_WASTE);
 	}
 }
 
 void
 abd_update_linear_stats(abd_t *abd, abd_stats_op_t op)
 {
 	ASSERT(op == ABDSTAT_INCR || op == ABDSTAT_DECR);
 	if (op == ABDSTAT_INCR) {
 		ABDSTAT_BUMP(abdstat_linear_cnt);
 		ABDSTAT_INCR(abdstat_linear_data_size, abd->abd_size);
 	} else {
 		ABDSTAT_BUMPDOWN(abdstat_linear_cnt);
 		ABDSTAT_INCR(abdstat_linear_data_size, -(int)abd->abd_size);
 	}
 }
 
 void
 abd_verify_scatter(abd_t *abd)
 {
 	ASSERT3U(ABD_SCATTER(abd).abd_nents, >, 0);
 	ASSERT3U(ABD_SCATTER(abd).abd_offset, <,
 	    ABD_SCATTER(abd).abd_sgl->length);
 
 #ifdef ZFS_DEBUG
 	struct scatterlist *sg = NULL;
 	size_t n = ABD_SCATTER(abd).abd_nents;
 	int i = 0;
 
 	abd_for_each_sg(abd, sg, n, i) {
 		ASSERT3P(sg_page(sg), !=, NULL);
 	}
 #endif
 }
 
 static void
 abd_free_zero_scatter(void)
 {
 	ABDSTAT_BUMPDOWN(abdstat_scatter_cnt);
 	ABDSTAT_INCR(abdstat_scatter_data_size, -(int)PAGESIZE);
 	ABDSTAT_BUMPDOWN(abdstat_scatter_page_multi_chunk);
 
 	abd_free_sg_table(abd_zero_scatter);
 	abd_free_struct(abd_zero_scatter);
 	abd_zero_scatter = NULL;
 	ASSERT3P(abd_zero_page, !=, NULL);
 #if defined(HAVE_ZERO_PAGE_GPL_ONLY)
 	abd_unmark_zfs_page(abd_zero_page);
 	__free_page(abd_zero_page);
 #endif /* HAVE_ZERO_PAGE_GPL_ONLY */
 }
 
 static int
 abd_kstats_update(kstat_t *ksp, int rw)
 {
 	abd_stats_t *as = ksp->ks_data;
 
 	if (rw == KSTAT_WRITE)
 		return (EACCES);
 	as->abdstat_struct_size.value.ui64 =
 	    wmsum_value(&abd_sums.abdstat_struct_size);
 	as->abdstat_linear_cnt.value.ui64 =
 	    wmsum_value(&abd_sums.abdstat_linear_cnt);
 	as->abdstat_linear_data_size.value.ui64 =
 	    wmsum_value(&abd_sums.abdstat_linear_data_size);
 	as->abdstat_scatter_cnt.value.ui64 =
 	    wmsum_value(&abd_sums.abdstat_scatter_cnt);
 	as->abdstat_scatter_data_size.value.ui64 =
 	    wmsum_value(&abd_sums.abdstat_scatter_data_size);
 	as->abdstat_scatter_chunk_waste.value.ui64 =
 	    wmsum_value(&abd_sums.abdstat_scatter_chunk_waste);
 	for (int i = 0; i < ABD_MAX_ORDER; i++) {
 		as->abdstat_scatter_orders[i].value.ui64 =
 		    wmsum_value(&abd_sums.abdstat_scatter_orders[i]);
 	}
 	as->abdstat_scatter_page_multi_chunk.value.ui64 =
 	    wmsum_value(&abd_sums.abdstat_scatter_page_multi_chunk);
 	as->abdstat_scatter_page_multi_zone.value.ui64 =
 	    wmsum_value(&abd_sums.abdstat_scatter_page_multi_zone);
 	as->abdstat_scatter_page_alloc_retry.value.ui64 =
 	    wmsum_value(&abd_sums.abdstat_scatter_page_alloc_retry);
 	as->abdstat_scatter_sg_table_retry.value.ui64 =
 	    wmsum_value(&abd_sums.abdstat_scatter_sg_table_retry);
 	return (0);
 }
 
 void
 abd_init(void)
 {
 	int i;
 
 	abd_cache = kmem_cache_create("abd_t", sizeof (abd_t),
 	    0, NULL, NULL, NULL, NULL, NULL, KMC_RECLAIMABLE);
 
 	wmsum_init(&abd_sums.abdstat_struct_size, 0);
 	wmsum_init(&abd_sums.abdstat_linear_cnt, 0);
 	wmsum_init(&abd_sums.abdstat_linear_data_size, 0);
 	wmsum_init(&abd_sums.abdstat_scatter_cnt, 0);
 	wmsum_init(&abd_sums.abdstat_scatter_data_size, 0);
 	wmsum_init(&abd_sums.abdstat_scatter_chunk_waste, 0);
 	for (i = 0; i < ABD_MAX_ORDER; i++)
 		wmsum_init(&abd_sums.abdstat_scatter_orders[i], 0);
 	wmsum_init(&abd_sums.abdstat_scatter_page_multi_chunk, 0);
 	wmsum_init(&abd_sums.abdstat_scatter_page_multi_zone, 0);
 	wmsum_init(&abd_sums.abdstat_scatter_page_alloc_retry, 0);
 	wmsum_init(&abd_sums.abdstat_scatter_sg_table_retry, 0);
 
 	abd_ksp = kstat_create("zfs", 0, "abdstats", "misc", KSTAT_TYPE_NAMED,
 	    sizeof (abd_stats) / sizeof (kstat_named_t), KSTAT_FLAG_VIRTUAL);
 	if (abd_ksp != NULL) {
 		for (i = 0; i < ABD_MAX_ORDER; i++) {
 			snprintf(abd_stats.abdstat_scatter_orders[i].name,
 			    KSTAT_STRLEN, "scatter_order_%d", i);
 			abd_stats.abdstat_scatter_orders[i].data_type =
 			    KSTAT_DATA_UINT64;
 		}
 		abd_ksp->ks_data = &abd_stats;
 		abd_ksp->ks_update = abd_kstats_update;
 		kstat_install(abd_ksp);
 	}
 
 	abd_alloc_zero_scatter();
 }
 
 void
 abd_fini(void)
 {
 	abd_free_zero_scatter();
 
 	if (abd_ksp != NULL) {
 		kstat_delete(abd_ksp);
 		abd_ksp = NULL;
 	}
 
 	wmsum_fini(&abd_sums.abdstat_struct_size);
 	wmsum_fini(&abd_sums.abdstat_linear_cnt);
 	wmsum_fini(&abd_sums.abdstat_linear_data_size);
 	wmsum_fini(&abd_sums.abdstat_scatter_cnt);
 	wmsum_fini(&abd_sums.abdstat_scatter_data_size);
 	wmsum_fini(&abd_sums.abdstat_scatter_chunk_waste);
 	for (int i = 0; i < ABD_MAX_ORDER; i++)
 		wmsum_fini(&abd_sums.abdstat_scatter_orders[i]);
 	wmsum_fini(&abd_sums.abdstat_scatter_page_multi_chunk);
 	wmsum_fini(&abd_sums.abdstat_scatter_page_multi_zone);
 	wmsum_fini(&abd_sums.abdstat_scatter_page_alloc_retry);
 	wmsum_fini(&abd_sums.abdstat_scatter_sg_table_retry);
 
 	if (abd_cache) {
 		kmem_cache_destroy(abd_cache);
 		abd_cache = NULL;
 	}
 }
 
 void
 abd_free_linear_page(abd_t *abd)
 {
 	/* Transform it back into a scatter ABD for freeing */
 	struct scatterlist *sg = abd->abd_u.abd_linear.abd_sgl;
 
 	/* When backed by user page unmap it */
 	if (abd_is_from_pages(abd))
 		zfs_kunmap(sg_page(sg));
 
 	abd->abd_flags &= ~ABD_FLAG_LINEAR;
 	abd->abd_flags &= ~ABD_FLAG_LINEAR_PAGE;
 	ABD_SCATTER(abd).abd_nents = 1;
 	ABD_SCATTER(abd).abd_offset = 0;
 	ABD_SCATTER(abd).abd_sgl = sg;
 	abd_free_chunks(abd);
 }
 
 /*
  * Allocate a scatter ABD structure from user pages. The pages must be
  * pinned with get_user_pages, or similiar, but need not be mapped via
  * the kmap interfaces.
  */
 abd_t *
 abd_alloc_from_pages(struct page **pages, unsigned long offset, uint64_t size)
 {
 	uint_t npages = DIV_ROUND_UP(size, PAGE_SIZE);
 	struct sg_table table;
 
 	VERIFY3U(size, <=, DMU_MAX_ACCESS);
 	ASSERT3U(offset, <, PAGE_SIZE);
 	ASSERT3P(pages, !=, NULL);
 
 	/*
 	 * Even if this buf is filesystem metadata, we only track that we
 	 * own the underlying data buffer, which is not true in this case.
 	 * Therefore, we don't ever use ABD_FLAG_META here.
 	 */
 	abd_t *abd = abd_alloc_struct(0);
 	abd->abd_flags |= ABD_FLAG_FROM_PAGES | ABD_FLAG_OWNER;
 	abd->abd_size = size;
 
 	while (sg_alloc_table_from_pages(&table, pages, npages, offset,
 	    size, __GFP_NOWARN | GFP_NOIO) != 0) {
 		ABDSTAT_BUMP(abdstat_scatter_sg_table_retry);
 		schedule_timeout_interruptible(1);
 	}
 
 	if ((offset + size) <= PAGE_SIZE) {
 		/*
 		 * Since there is only one entry, this ABD can be represented
 		 * as a linear buffer. All single-page (4K) ABD's constructed
 		 * from a user page can be represented this way as long as the
 		 * page is mapped to a virtual address. This allows us to
 		 * apply an offset in to the mapped page.
 		 *
 		 * Note that kmap() must be used, not kmap_atomic(), because
 		 * the mapping needs to bet set up on all CPUs. Using kmap()
 		 * also enables the user of highmem pages when required.
 		 */
 		abd->abd_flags |= ABD_FLAG_LINEAR | ABD_FLAG_LINEAR_PAGE;
 		abd->abd_u.abd_linear.abd_sgl = table.sgl;
 		zfs_kmap(sg_page(table.sgl));
 		ABD_LINEAR_BUF(abd) = sg_virt(table.sgl);
 	} else {
 		ABDSTAT_BUMP(abdstat_scatter_page_multi_chunk);
 		abd->abd_flags |= ABD_FLAG_MULTI_CHUNK;
 
 		ABD_SCATTER(abd).abd_offset = offset;
 		ABD_SCATTER(abd).abd_sgl = table.sgl;
 		ABD_SCATTER(abd).abd_nents = table.nents;
 
 		ASSERT0(ABD_SCATTER(abd).abd_offset);
 	}
 
 	return (abd);
 }
 
 /*
  * If we're going to use this ABD for doing I/O using the block layer, the
  * consumer of the ABD data doesn't care if it's scattered or not, and we don't
  * plan to store this ABD in memory for a long period of time, we should
  * allocate the ABD type that requires the least data copying to do the I/O.
  *
  * On Linux the optimal thing to do would be to use abd_get_offset() and
  * construct a new ABD which shares the original pages thereby eliminating
  * the copy.  But for the moment a new linear ABD is allocated until this
  * performance optimization can be implemented.
  */
 abd_t *
 abd_alloc_for_io(size_t size, boolean_t is_metadata)
 {
 	return (abd_alloc(size, is_metadata));
 }
 
 abd_t *
 abd_get_offset_scatter(abd_t *abd, abd_t *sabd, size_t off,
     size_t size)
 {
 	(void) size;
 	int i = 0;
 	struct scatterlist *sg = NULL;
 
 	abd_verify(sabd);
 	ASSERT3U(off, <=, sabd->abd_size);
 
 	size_t new_offset = ABD_SCATTER(sabd).abd_offset + off;
 
 	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_for_each_sg(sabd, sg, ABD_SCATTER(sabd).abd_nents, i) {
 		if (new_offset < sg->length)
 			break;
 		new_offset -= sg->length;
 	}
 
 	ABD_SCATTER(abd).abd_sgl = sg;
 	ABD_SCATTER(abd).abd_offset = new_offset;
 	ABD_SCATTER(abd).abd_nents = ABD_SCATTER(sabd).abd_nents - i;
 
 	if (abd_is_from_pages(sabd))
 		abd->abd_flags |= ABD_FLAG_FROM_PAGES;
 
 	return (abd);
 }
 
 /*
  * Initialize the abd_iter.
  */
 void
 abd_iter_init(struct abd_iter *aiter, abd_t *abd)
 {
 	ASSERT(!abd_is_gang(abd));
 	abd_verify(abd);
 	memset(aiter, 0, sizeof (struct abd_iter));
 	aiter->iter_abd = abd;
 	if (!abd_is_linear(abd)) {
 		aiter->iter_offset = ABD_SCATTER(abd).abd_offset;
 		aiter->iter_sg = ABD_SCATTER(abd).abd_sgl;
 	}
 }
 
 /*
  * This is just a helper function to see if we have exhausted the
  * abd_iter and reached the end.
  */
 boolean_t
 abd_iter_at_end(struct abd_iter *aiter)
 {
 	ASSERT3U(aiter->iter_pos, <=, aiter->iter_abd->abd_size);
 	return (aiter->iter_pos == aiter->iter_abd->abd_size);
 }
 
 /*
  * Advance the iterator by a certain amount. Cannot be called when a chunk is
  * in use. This can be safely called when the aiter has already exhausted, in
  * which case this does nothing.
  */
 void
 abd_iter_advance(struct abd_iter *aiter, size_t amount)
 {
 	/*
 	 * Ensure that last chunk is not in use. abd_iterate_*() must clear
 	 * this state (directly or abd_iter_unmap()) before advancing.
 	 */
 	ASSERT3P(aiter->iter_mapaddr, ==, NULL);
 	ASSERT0(aiter->iter_mapsize);
 	ASSERT3P(aiter->iter_page, ==, NULL);
 	ASSERT0(aiter->iter_page_doff);
 	ASSERT0(aiter->iter_page_dsize);
 
 	/* There's nothing left to advance to, so do nothing */
 	if (abd_iter_at_end(aiter))
 		return;
 
 	aiter->iter_pos += amount;
 	aiter->iter_offset += amount;
 	if (!abd_is_linear(aiter->iter_abd)) {
 		while (aiter->iter_offset >= aiter->iter_sg->length) {
 			aiter->iter_offset -= aiter->iter_sg->length;
 			aiter->iter_sg = sg_next(aiter->iter_sg);
 			if (aiter->iter_sg == NULL) {
 				ASSERT0(aiter->iter_offset);
 				break;
 			}
 		}
 	}
 }
 
 /*
  * Map the current chunk into aiter. This can be safely called when the aiter
  * has already exhausted, in which case this does nothing.
  */
 void
 abd_iter_map(struct abd_iter *aiter)
 {
 	void *paddr;
 	size_t offset = 0;
 
 	ASSERT3P(aiter->iter_mapaddr, ==, NULL);
 	ASSERT0(aiter->iter_mapsize);
 
 	/* There's nothing left to iterate over, so do nothing */
 	if (abd_iter_at_end(aiter))
 		return;
 
 	if (abd_is_linear(aiter->iter_abd)) {
 		ASSERT3U(aiter->iter_pos, ==, aiter->iter_offset);
 		offset = aiter->iter_offset;
 		aiter->iter_mapsize = aiter->iter_abd->abd_size - offset;
 		paddr = ABD_LINEAR_BUF(aiter->iter_abd);
 	} else {
 		offset = aiter->iter_offset;
 		aiter->iter_mapsize = MIN(aiter->iter_sg->length - offset,
 		    aiter->iter_abd->abd_size - aiter->iter_pos);
 
 		paddr = zfs_kmap_local(sg_page(aiter->iter_sg));
 	}
 
 	aiter->iter_mapaddr = (char *)paddr + offset;
 }
 
 /*
  * Unmap the current chunk from aiter. This can be safely called when the aiter
  * has already exhausted, in which case this does nothing.
  */
 void
 abd_iter_unmap(struct abd_iter *aiter)
 {
 	/* There's nothing left to unmap, so do nothing */
 	if (abd_iter_at_end(aiter))
 		return;
 
 	if (!abd_is_linear(aiter->iter_abd)) {
 		/* LINTED E_FUNC_SET_NOT_USED */
 		zfs_kunmap_local(aiter->iter_mapaddr - aiter->iter_offset);
 	}
 
 	ASSERT3P(aiter->iter_mapaddr, !=, NULL);
 	ASSERT3U(aiter->iter_mapsize, >, 0);
 
 	aiter->iter_mapaddr = NULL;
 	aiter->iter_mapsize = 0;
 }
 
 void
 abd_cache_reap_now(void)
 {
 }
 
 /*
  * 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, >=, 0);
 	/*
 	 * In the event the ABD is composed of a single user page from Direct
 	 * I/O we can not direclty return the raw buffer. This is a consequence
 	 * of not being able to write protect the page and the contents of the
 	 * page can be changed at any time by the user.
 	 */
 	if (abd_is_from_pages(abd)) {
 		buf = zio_buf_alloc(n);
 	} else 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);
 
 	/*
 	 * In the event the ABD is composed of a single user page from Direct
 	 * I/O we must make sure copy the data over into the newly allocated
 	 * buffer. This is a consequence of the fact that we can not write
 	 * protect the user page and there is a risk the contents of the page
 	 * could be changed by the user at any moment.
 	 */
 	if (!abd_is_linear(abd) || abd_is_from_pages(abd)) {
 		abd_copy_to_buf(buf, abd, n);
 	}
 	return (buf);
 }
 
 /*
  * Return a borrowed raw buffer to an ABD. If the ABD is scatterd, this will
  * not change the contents of the ABD. If you want any changes you made to
  * buf to be copied back to abd, use abd_return_buf_copy() instead. If the
  * ABD is not constructed from user pages for Direct I/O then an ASSERT
  * checks to make sure the contents of buffer have not changed since it was
  * borrowed. We can not ASSERT that the contents of the buffer have not changed
  * if it is composed of user pages because the pages can not be placed under
  * write protection and the user could have possibly changed the contents in
- * the pages at any time.
+ * the pages at any time. This is also an issue for Direct I/O reads. Checksum
+ * verifications in the ZIO pipeline check for this issue and handle it by
+ * returning an error on checksum verification failure.
  */
 void
 abd_return_buf(abd_t *abd, void *buf, size_t n)
 {
 	abd_verify(abd);
 	ASSERT3U(abd->abd_size, >=, n);
 #ifdef ZFS_DEBUG
 	(void) zfs_refcount_remove_many(&abd->abd_children, n, buf);
 #endif
 	if (abd_is_from_pages(abd)) {
 		zio_buf_free(buf, n);
 	} else if (abd_is_linear(abd)) {
 		ASSERT3P(buf, ==, abd_to_buf(abd));
 	} else if (abd_is_gang(abd)) {
 #ifdef ZFS_DEBUG
 		/*
 		 * We have to be careful with gang ABD's that we do not ASSERT0
 		 * for any ABD's that contain user pages from Direct I/O. In
 		 * order to handle this, we just iterate through the gang ABD
 		 * and only verify ABDs that are not from user pages.
 		 */
 		void *cmp_buf = buf;
 
 		for (abd_t *cabd = list_head(&ABD_GANG(abd).abd_gang_chain);
 		    cabd != NULL;
 		    cabd = list_next(&ABD_GANG(abd).abd_gang_chain, cabd)) {
 			if (!abd_is_from_pages(cabd)) {
 				ASSERT0(abd_cmp_buf(cabd, cmp_buf,
 				    cabd->abd_size));
 			}
 			cmp_buf = (char *)cmp_buf + cabd->abd_size;
 		}
 #endif
 		zio_buf_free(buf, n);
 	} else {
 		ASSERT0(abd_cmp_buf(abd, buf, n));
 		zio_buf_free(buf, n);
 	}
 }
 
 void
 abd_return_buf_copy(abd_t *abd, void *buf, size_t n)
 {
 	if (!abd_is_linear(abd) || abd_is_from_pages(abd)) {
 		abd_copy_from_buf(abd, buf, n);
 	}
 	abd_return_buf(abd, buf, n);
 }
 
 /*
  * This is abd_iter_page(), the function underneath abd_iterate_page_func().
  * It yields the next page struct and data offset and size within it, without
  * mapping it into the address space.
  */
 
 /*
  * "Compound pages" are a group of pages that can be referenced from a single
  * struct page *. Its organised as a "head" page, followed by a series of
  * "tail" pages.
  *
  * In OpenZFS, compound pages are allocated using the __GFP_COMP flag, which we
  * get from scatter ABDs and SPL vmalloc slabs (ie >16K allocations). So a
  * great many of the IO buffers we get are going to be of this type.
  *
  * The tail pages are just regular PAGESIZE pages, and can be safely used
  * as-is. However, the head page has length covering itself and all the tail
  * pages. If the ABD chunk spans multiple pages, then we can use the head page
  * and a >PAGESIZE length, which is far more efficient.
  *
  * Before kernel 4.5 however, compound page heads were refcounted separately
  * from tail pages, such that moving back to the head page would require us to
  * take a reference to it and releasing it once we're completely finished with
  * it. In practice, that meant when our caller is done with the ABD, which we
  * have no insight into from here. Rather than contort this API to track head
  * page references on such ancient kernels, we disabled this special compound
  * page handling on kernels before 4.5, instead just using treating each page
  * within it as a regular PAGESIZE page (which it is). This is slightly less
  * efficient, but makes everything far simpler.
  *
  * We no longer support kernels before 4.5, so in theory none of this is
  * necessary. However, this code is still relatively new in the grand scheme of
  * things, so I'm leaving the ability to compile this out for the moment.
  *
  * Setting/clearing ABD_ITER_COMPOUND_PAGES below enables/disables the special
  * handling, by defining the ABD_ITER_PAGE_SIZE(page) macro to understand
  * compound pages, or not, and compiling in/out the support to detect compound
  * tail pages and move back to the start.
  */
 
 /* On by default */
 #define	ABD_ITER_COMPOUND_PAGES
 
 #ifdef ABD_ITER_COMPOUND_PAGES
 #define	ABD_ITER_PAGE_SIZE(page)	\
 	(PageCompound(page) ? page_size(page) : PAGESIZE)
 #else
 #define	ABD_ITER_PAGE_SIZE(page)	(PAGESIZE)
 #endif
 
 void
 abd_iter_page(struct abd_iter *aiter)
 {
 	if (abd_iter_at_end(aiter)) {
 		aiter->iter_page = NULL;
 		aiter->iter_page_doff = 0;
 		aiter->iter_page_dsize = 0;
 		return;
 	}
 
 	struct page *page;
 	size_t doff, dsize;
 
 	/*
 	 * Find the page, and the start of the data within it. This is computed
 	 * differently for linear and scatter ABDs; linear is referenced by
 	 * virtual memory location, while scatter is referenced by page
 	 * pointer.
 	 */
 	if (abd_is_linear(aiter->iter_abd)) {
 		ASSERT3U(aiter->iter_pos, ==, aiter->iter_offset);
 
 		/* memory address at iter_pos */
 		void *paddr = ABD_LINEAR_BUF(aiter->iter_abd) + aiter->iter_pos;
 
 		/* struct page for address */
 		page = is_vmalloc_addr(paddr) ?
 		    vmalloc_to_page(paddr) : virt_to_page(paddr);
 
 		/* offset of address within the page */
 		doff = offset_in_page(paddr);
 	} else {
 		ASSERT(!abd_is_gang(aiter->iter_abd));
 
 		/* current scatter page */
 		page = nth_page(sg_page(aiter->iter_sg),
 		    aiter->iter_offset >> PAGE_SHIFT);
 
 		/* position within page */
 		doff = aiter->iter_offset & (PAGESIZE - 1);
 	}
 
 #ifdef ABD_ITER_COMPOUND_PAGES
 	if (PageTail(page)) {
 		/*
 		 * If this is a compound tail page, move back to the head, and
 		 * adjust the offset to match. This may let us yield a much
 		 * larger amount of data from a single logical page, and so
 		 * leave our caller with fewer pages to process.
 		 */
 		struct page *head = compound_head(page);
 		doff += ((page - head) * PAGESIZE);
 		page = head;
 	}
 #endif
 
 	ASSERT(page);
 
 	/*
 	 * Compute the maximum amount of data we can take from this page. This
 	 * is the smaller of:
 	 * - the remaining space in the page
 	 * - the remaining space in this scatterlist entry (which may not cover
 	 *   the entire page)
 	 * - the remaining space in the abd (which may not cover the entire
 	 *   scatterlist entry)
 	 */
 	dsize = MIN(ABD_ITER_PAGE_SIZE(page) - doff,
 	    aiter->iter_abd->abd_size - aiter->iter_pos);
 	if (!abd_is_linear(aiter->iter_abd))
 		dsize = MIN(dsize, aiter->iter_sg->length - aiter->iter_offset);
 	ASSERT3U(dsize, >, 0);
 
 	/* final iterator outputs */
 	aiter->iter_page = page;
 	aiter->iter_page_doff = doff;
 	aiter->iter_page_dsize = dsize;
 }
 
 /*
  * Note: ABD BIO functions only needed to support vdev_classic. See comments in
  * vdev_disk.c.
  */
 
 /*
  * bio_nr_pages for ABD.
  * @off is the offset in @abd
  */
 unsigned long
 abd_nr_pages_off(abd_t *abd, unsigned int size, size_t off)
 {
 	unsigned long pos;
 
 	if (abd_is_gang(abd)) {
 		unsigned long count = 0;
 
 		for (abd_t *cabd = abd_gang_get_offset(abd, &off);
 		    cabd != NULL && size != 0;
 		    cabd = list_next(&ABD_GANG(abd).abd_gang_chain, cabd)) {
 			ASSERT3U(off, <, cabd->abd_size);
 			int mysize = MIN(size, cabd->abd_size - off);
 			count += abd_nr_pages_off(cabd, mysize, off);
 			size -= mysize;
 			off = 0;
 		}
 		return (count);
 	}
 
 	if (abd_is_linear(abd))
 		pos = (unsigned long)abd_to_buf(abd) + off;
 	else
 		pos = ABD_SCATTER(abd).abd_offset + off;
 
 	return (((pos + size + PAGESIZE - 1) >> PAGE_SHIFT) -
 	    (pos >> PAGE_SHIFT));
 }
 
 static unsigned int
 bio_map(struct bio *bio, void *buf_ptr, unsigned int bio_size)
 {
 	unsigned int offset, size, i;
 	struct page *page;
 
 	offset = offset_in_page(buf_ptr);
 	for (i = 0; i < bio->bi_max_vecs; i++) {
 		size = PAGE_SIZE - offset;
 
 		if (bio_size <= 0)
 			break;
 
 		if (size > bio_size)
 			size = bio_size;
 
 		if (is_vmalloc_addr(buf_ptr))
 			page = vmalloc_to_page(buf_ptr);
 		else
 			page = virt_to_page(buf_ptr);
 
 		/*
 		 * Some network related block device uses tcp_sendpage, which
 		 * doesn't behave well when using 0-count page, this is a
 		 * safety net to catch them.
 		 */
 		ASSERT3S(page_count(page), >, 0);
 
 		if (bio_add_page(bio, page, size, offset) != size)
 			break;
 
 		buf_ptr += size;
 		bio_size -= size;
 		offset = 0;
 	}
 
 	return (bio_size);
 }
 
 /*
  * bio_map for gang ABD.
  */
 static unsigned int
 abd_gang_bio_map_off(struct bio *bio, abd_t *abd,
     unsigned int io_size, size_t off)
 {
 	ASSERT(abd_is_gang(abd));
 
 	for (abd_t *cabd = abd_gang_get_offset(abd, &off);
 	    cabd != NULL;
 	    cabd = list_next(&ABD_GANG(abd).abd_gang_chain, cabd)) {
 		ASSERT3U(off, <, cabd->abd_size);
 		int size = MIN(io_size, cabd->abd_size - off);
 		int remainder = abd_bio_map_off(bio, cabd, size, off);
 		io_size -= (size - remainder);
 		if (io_size == 0 || remainder > 0)
 			return (io_size);
 		off = 0;
 	}
 	ASSERT0(io_size);
 	return (io_size);
 }
 
 /*
  * bio_map for ABD.
  * @off is the offset in @abd
  * Remaining IO size is returned
  */
 unsigned int
 abd_bio_map_off(struct bio *bio, abd_t *abd,
     unsigned int io_size, size_t off)
 {
 	struct abd_iter aiter;
 
 	ASSERT3U(io_size, <=, abd->abd_size - off);
 	if (abd_is_linear(abd))
 		return (bio_map(bio, ((char *)abd_to_buf(abd)) + off, io_size));
 
 	ASSERT(!abd_is_linear(abd));
 	if (abd_is_gang(abd))
 		return (abd_gang_bio_map_off(bio, abd, io_size, off));
 
 	abd_iter_init(&aiter, abd);
 	abd_iter_advance(&aiter, off);
 
 	for (int i = 0; i < bio->bi_max_vecs; i++) {
 		struct page *pg;
 		size_t len, sgoff, pgoff;
 		struct scatterlist *sg;
 
 		if (io_size <= 0)
 			break;
 
 		sg = aiter.iter_sg;
 		sgoff = aiter.iter_offset;
 		pgoff = sgoff & (PAGESIZE - 1);
 		len = MIN(io_size, PAGESIZE - pgoff);
 		ASSERT(len > 0);
 
 		pg = nth_page(sg_page(sg), sgoff >> PAGE_SHIFT);
 		if (bio_add_page(bio, pg, len, pgoff) != len)
 			break;
 
 		io_size -= len;
 		abd_iter_advance(&aiter, len);
 	}
 
 	return (io_size);
 }
 
 /* Tunable Parameters */
 module_param(zfs_abd_scatter_enabled, int, 0644);
 MODULE_PARM_DESC(zfs_abd_scatter_enabled,
 	"Toggle whether ABD allocations must be linear.");
 module_param(zfs_abd_scatter_min_size, int, 0644);
 MODULE_PARM_DESC(zfs_abd_scatter_min_size,
 	"Minimum size of scatter allocations.");
 /* CSTYLED */
 module_param(zfs_abd_scatter_max_order, uint, 0644);
 MODULE_PARM_DESC(zfs_abd_scatter_max_order,
 	"Maximum order allocation used for a scatter ABD.");
diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zfs_ctldir.c b/sys/contrib/openzfs/module/os/linux/zfs/zfs_ctldir.c
index 8a42a075cd25..f60d6ae91e0b 100644
--- a/sys/contrib/openzfs/module/os/linux/zfs/zfs_ctldir.c
+++ b/sys/contrib/openzfs/module/os/linux/zfs/zfs_ctldir.c
@@ -1,1326 +1,1425 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 /*
  *
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * Copyright (C) 2011 Lawrence Livermore National Security, LLC.
  * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
  * LLNL-CODE-403049.
  * Rewritten for Linux by:
  *   Rohan Puri <rohan.puri15@gmail.com>
  *   Brian Behlendorf <behlendorf1@llnl.gov>
  * Copyright (c) 2013 by Delphix. All rights reserved.
  * Copyright 2015, OmniTI Computer Consulting, Inc. All rights reserved.
  * Copyright (c) 2018 George Melikov. All Rights Reserved.
  * Copyright (c) 2019 Datto, Inc. All rights reserved.
  * Copyright (c) 2020 The MathWorks, 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' and 'shares' directory, but this may
  * expand in the future.  The elements are built dynamically, 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 inode.
  *
  * All mounts are handled automatically by an user mode helper which invokes
  * the mount procedure.  Unmounts are handled by allowing the mount
  * point to expire so the kernel may automatically unmount it.
  *
  * The '.zfs', '.zfs/snapshot', and all directories created under
  * '.zfs/snapshot' (ie: '.zfs/snapshot/<snapname>') all share the same
  * zfsvfs_t as the head filesystem (what '.zfs' lives under).
  *
  * File systems mounted on top of the '.zfs/snapshot/<snapname>' paths
  * (ie: snapshots) are complete ZFS filesystems and have their own unique
  * zfsvfs_t.  However, the fsid reported by these mounts will be the same
  * as that used by the parent zfsvfs_t to make NFS happy.
  */
 
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/time.h>
 #include <sys/sysmacros.h>
 #include <sys/pathname.h>
 #include <sys/vfs.h>
 #include <sys/zfs_ctldir.h>
 #include <sys/zfs_ioctl.h>
 #include <sys/zfs_vfsops.h>
 #include <sys/zfs_vnops.h>
 #include <sys/stat.h>
 #include <sys/dmu.h>
 #include <sys/dmu_objset.h>
 #include <sys/dsl_destroy.h>
 #include <sys/dsl_deleg.h>
 #include <sys/zpl.h>
 #include <sys/mntent.h>
 #include "zfs_namecheck.h"
 
 /*
  * Two AVL trees are maintained which contain all currently automounted
  * snapshots.  Every automounted snapshots maps to a single zfs_snapentry_t
  * entry which MUST:
  *
  *   - be attached to both trees, and
  *   - be unique, no duplicate entries are allowed.
  *
  * The zfs_snapshots_by_name tree is indexed by the full dataset name
  * while the zfs_snapshots_by_objsetid tree is indexed by the unique
  * objsetid.  This allows for fast lookups either by name or objsetid.
  */
 static avl_tree_t zfs_snapshots_by_name;
 static avl_tree_t zfs_snapshots_by_objsetid;
 static krwlock_t zfs_snapshot_lock;
 
 /*
  * Control Directory Tunables (.zfs)
  */
 int zfs_expire_snapshot = ZFSCTL_EXPIRE_SNAPSHOT;
 static int zfs_admin_snapshot = 0;
 static int zfs_snapshot_no_setuid = 0;
 
 typedef struct {
 	char		*se_name;	/* full snapshot name */
 	char		*se_path;	/* full mount path */
 	spa_t		*se_spa;	/* pool spa */
 	uint64_t	se_objsetid;	/* snapshot objset id */
 	struct dentry   *se_root_dentry; /* snapshot root dentry */
 	krwlock_t	se_taskqid_lock;  /* scheduled unmount taskqid lock */
 	taskqid_t	se_taskqid;	/* scheduled unmount taskqid */
 	avl_node_t	se_node_name;	/* zfs_snapshots_by_name link */
 	avl_node_t	se_node_objsetid; /* zfs_snapshots_by_objsetid link */
 	zfs_refcount_t	se_refcount;	/* reference count */
 } zfs_snapentry_t;
 
 static void zfsctl_snapshot_unmount_delay_impl(zfs_snapentry_t *se, int delay);
 
 /*
  * Allocate a new zfs_snapentry_t being careful to make a copy of the
  * the snapshot name and provided mount point.  No reference is taken.
  */
 static zfs_snapentry_t *
 zfsctl_snapshot_alloc(const char *full_name, const char *full_path, spa_t *spa,
     uint64_t objsetid, struct dentry *root_dentry)
 {
 	zfs_snapentry_t *se;
 
 	se = kmem_zalloc(sizeof (zfs_snapentry_t), KM_SLEEP);
 
 	se->se_name = kmem_strdup(full_name);
 	se->se_path = kmem_strdup(full_path);
 	se->se_spa = spa;
 	se->se_objsetid = objsetid;
 	se->se_root_dentry = root_dentry;
 	se->se_taskqid = TASKQID_INVALID;
 	rw_init(&se->se_taskqid_lock, NULL, RW_DEFAULT, NULL);
 
 	zfs_refcount_create(&se->se_refcount);
 
 	return (se);
 }
 
 /*
  * Free a zfs_snapentry_t the caller must ensure there are no active
  * references.
  */
 static void
 zfsctl_snapshot_free(zfs_snapentry_t *se)
 {
 	zfs_refcount_destroy(&se->se_refcount);
 	kmem_strfree(se->se_name);
 	kmem_strfree(se->se_path);
 	rw_destroy(&se->se_taskqid_lock);
 
 	kmem_free(se, sizeof (zfs_snapentry_t));
 }
 
 /*
  * Hold a reference on the zfs_snapentry_t.
  */
 static void
 zfsctl_snapshot_hold(zfs_snapentry_t *se)
 {
 	zfs_refcount_add(&se->se_refcount, NULL);
 }
 
 /*
  * Release a reference on the zfs_snapentry_t.  When the number of
  * references drops to zero the structure will be freed.
  */
 static void
 zfsctl_snapshot_rele(zfs_snapentry_t *se)
 {
 	if (zfs_refcount_remove(&se->se_refcount, NULL) == 0)
 		zfsctl_snapshot_free(se);
 }
 
 /*
  * Add a zfs_snapentry_t to both the zfs_snapshots_by_name and
  * zfs_snapshots_by_objsetid trees.  While the zfs_snapentry_t is part
  * of the trees a reference is held.
  */
 static void
 zfsctl_snapshot_add(zfs_snapentry_t *se)
 {
 	ASSERT(RW_WRITE_HELD(&zfs_snapshot_lock));
 	zfsctl_snapshot_hold(se);
 	avl_add(&zfs_snapshots_by_name, se);
 	avl_add(&zfs_snapshots_by_objsetid, se);
 }
 
 /*
  * Remove a zfs_snapentry_t from both the zfs_snapshots_by_name and
  * zfs_snapshots_by_objsetid trees.  Upon removal a reference is dropped,
  * this can result in the structure being freed if that was the last
  * remaining reference.
  */
 static void
 zfsctl_snapshot_remove(zfs_snapentry_t *se)
 {
 	ASSERT(RW_WRITE_HELD(&zfs_snapshot_lock));
 	avl_remove(&zfs_snapshots_by_name, se);
 	avl_remove(&zfs_snapshots_by_objsetid, se);
 	zfsctl_snapshot_rele(se);
 }
 
 /*
  * Snapshot name comparison function for the zfs_snapshots_by_name.
  */
 static int
 snapentry_compare_by_name(const void *a, const void *b)
 {
 	const zfs_snapentry_t *se_a = a;
 	const zfs_snapentry_t *se_b = b;
 	int ret;
 
 	ret = strcmp(se_a->se_name, se_b->se_name);
 
 	if (ret < 0)
 		return (-1);
 	else if (ret > 0)
 		return (1);
 	else
 		return (0);
 }
 
 /*
  * Snapshot name comparison function for the zfs_snapshots_by_objsetid.
  */
 static int
 snapentry_compare_by_objsetid(const void *a, const void *b)
 {
 	const zfs_snapentry_t *se_a = a;
 	const zfs_snapentry_t *se_b = b;
 
 	if (se_a->se_spa != se_b->se_spa)
 		return ((ulong_t)se_a->se_spa < (ulong_t)se_b->se_spa ? -1 : 1);
 
 	if (se_a->se_objsetid < se_b->se_objsetid)
 		return (-1);
 	else if (se_a->se_objsetid > se_b->se_objsetid)
 		return (1);
 	else
 		return (0);
 }
 
 /*
  * Find a zfs_snapentry_t in zfs_snapshots_by_name.  If the snapname
  * is found a pointer to the zfs_snapentry_t is returned and a reference
  * taken on the structure.  The caller is responsible for dropping the
  * reference with zfsctl_snapshot_rele().  If the snapname is not found
  * NULL will be returned.
  */
 static zfs_snapentry_t *
 zfsctl_snapshot_find_by_name(const char *snapname)
 {
 	zfs_snapentry_t *se, search;
 
 	ASSERT(RW_LOCK_HELD(&zfs_snapshot_lock));
 
 	search.se_name = (char *)snapname;
 	se = avl_find(&zfs_snapshots_by_name, &search, NULL);
 	if (se)
 		zfsctl_snapshot_hold(se);
 
 	return (se);
 }
 
 /*
  * Find a zfs_snapentry_t in zfs_snapshots_by_objsetid given the objset id
  * rather than the snapname.  In all other respects it behaves the same
  * as zfsctl_snapshot_find_by_name().
  */
 static zfs_snapentry_t *
 zfsctl_snapshot_find_by_objsetid(spa_t *spa, uint64_t objsetid)
 {
 	zfs_snapentry_t *se, search;
 
 	ASSERT(RW_LOCK_HELD(&zfs_snapshot_lock));
 
 	search.se_spa = spa;
 	search.se_objsetid = objsetid;
 	se = avl_find(&zfs_snapshots_by_objsetid, &search, NULL);
 	if (se)
 		zfsctl_snapshot_hold(se);
 
 	return (se);
 }
 
 /*
  * Rename a zfs_snapentry_t in the zfs_snapshots_by_name.  The structure is
  * removed, renamed, and added back to the new correct location in the tree.
  */
 static int
 zfsctl_snapshot_rename(const char *old_snapname, const char *new_snapname)
 {
 	zfs_snapentry_t *se;
 
 	ASSERT(RW_WRITE_HELD(&zfs_snapshot_lock));
 
 	se = zfsctl_snapshot_find_by_name(old_snapname);
 	if (se == NULL)
 		return (SET_ERROR(ENOENT));
 
 	zfsctl_snapshot_remove(se);
 	kmem_strfree(se->se_name);
 	se->se_name = kmem_strdup(new_snapname);
 	zfsctl_snapshot_add(se);
 	zfsctl_snapshot_rele(se);
 
 	return (0);
 }
 
 /*
  * Delayed task responsible for unmounting an expired automounted snapshot.
  */
 static void
 snapentry_expire(void *data)
 {
 	zfs_snapentry_t *se = (zfs_snapentry_t *)data;
 	spa_t *spa = se->se_spa;
 	uint64_t objsetid = se->se_objsetid;
 
 	if (zfs_expire_snapshot <= 0) {
 		zfsctl_snapshot_rele(se);
 		return;
 	}
 
 	rw_enter(&se->se_taskqid_lock, RW_WRITER);
 	se->se_taskqid = TASKQID_INVALID;
 	rw_exit(&se->se_taskqid_lock);
 	(void) zfsctl_snapshot_unmount(se->se_name, MNT_EXPIRE);
 	zfsctl_snapshot_rele(se);
 
 	/*
 	 * Reschedule the unmount if the zfs_snapentry_t wasn't removed.
 	 * This can occur when the snapshot is busy.
 	 */
 	rw_enter(&zfs_snapshot_lock, RW_READER);
 	if ((se = zfsctl_snapshot_find_by_objsetid(spa, objsetid)) != NULL) {
 		zfsctl_snapshot_unmount_delay_impl(se, zfs_expire_snapshot);
 		zfsctl_snapshot_rele(se);
 	}
 	rw_exit(&zfs_snapshot_lock);
 }
 
 /*
  * Cancel an automatic unmount of a snapname.  This callback is responsible
  * for dropping the reference on the zfs_snapentry_t which was taken when
  * during dispatch.
  */
 static void
 zfsctl_snapshot_unmount_cancel(zfs_snapentry_t *se)
 {
 	int err = 0;
 	rw_enter(&se->se_taskqid_lock, RW_WRITER);
 	err = taskq_cancel_id(system_delay_taskq, se->se_taskqid);
 	/*
 	 * if we get ENOENT, the taskq couldn't be found to be
 	 * canceled, so we can just mark it as invalid because
 	 * it's already gone. If we got EBUSY, then we already
 	 * blocked until it was gone _anyway_, so we don't care.
 	 */
 	se->se_taskqid = TASKQID_INVALID;
 	rw_exit(&se->se_taskqid_lock);
 	if (err == 0) {
 		zfsctl_snapshot_rele(se);
 	}
 }
 
 /*
  * Dispatch the unmount task for delayed handling with a hold protecting it.
  */
 static void
 zfsctl_snapshot_unmount_delay_impl(zfs_snapentry_t *se, int delay)
 {
 
 	if (delay <= 0)
 		return;
 
 	zfsctl_snapshot_hold(se);
 	rw_enter(&se->se_taskqid_lock, RW_WRITER);
 	/*
 	 * If this condition happens, we managed to:
 	 * - dispatch once
 	 * - want to dispatch _again_ before it returned
 	 *
 	 * So let's just return - if that task fails at unmounting,
 	 * we'll eventually dispatch again, and if it succeeds,
 	 * no problem.
 	 */
 	if (se->se_taskqid != TASKQID_INVALID) {
 		rw_exit(&se->se_taskqid_lock);
 		zfsctl_snapshot_rele(se);
 		return;
 	}
 	se->se_taskqid = taskq_dispatch_delay(system_delay_taskq,
 	    snapentry_expire, se, TQ_SLEEP, ddi_get_lbolt() + delay * HZ);
 	rw_exit(&se->se_taskqid_lock);
 }
 
 /*
  * Schedule an automatic unmount of objset id to occur in delay seconds from
  * now.  Any previous delayed unmount will be cancelled in favor of the
  * updated deadline.  A reference is taken by zfsctl_snapshot_find_by_name()
  * and held until the outstanding task is handled or cancelled.
  */
 int
 zfsctl_snapshot_unmount_delay(spa_t *spa, uint64_t objsetid, int delay)
 {
 	zfs_snapentry_t *se;
 	int error = ENOENT;
 
 	rw_enter(&zfs_snapshot_lock, RW_READER);
 	if ((se = zfsctl_snapshot_find_by_objsetid(spa, objsetid)) != NULL) {
 		zfsctl_snapshot_unmount_cancel(se);
 		zfsctl_snapshot_unmount_delay_impl(se, delay);
 		zfsctl_snapshot_rele(se);
 		error = 0;
 	}
 	rw_exit(&zfs_snapshot_lock);
 
 	return (error);
 }
 
 /*
  * Check if snapname is currently mounted.  Returned non-zero when mounted
  * and zero when unmounted.
  */
 static boolean_t
 zfsctl_snapshot_ismounted(const char *snapname)
 {
 	zfs_snapentry_t *se;
 	boolean_t ismounted = B_FALSE;
 
 	rw_enter(&zfs_snapshot_lock, RW_READER);
 	if ((se = zfsctl_snapshot_find_by_name(snapname)) != NULL) {
 		zfsctl_snapshot_rele(se);
 		ismounted = B_TRUE;
 	}
 	rw_exit(&zfs_snapshot_lock);
 
 	return (ismounted);
 }
 
 /*
  * Check if the given inode is a part of the virtual .zfs directory.
  */
 boolean_t
 zfsctl_is_node(struct inode *ip)
 {
 	return (ITOZ(ip)->z_is_ctldir);
 }
 
 /*
  * Check if the given inode is a .zfs/snapshots/snapname directory.
  */
 boolean_t
 zfsctl_is_snapdir(struct inode *ip)
 {
 	return (zfsctl_is_node(ip) && (ip->i_ino <= ZFSCTL_INO_SNAPDIRS));
 }
 
 /*
  * Allocate a new inode with the passed id and ops.
  */
 static struct inode *
 zfsctl_inode_alloc(zfsvfs_t *zfsvfs, uint64_t id,
     const struct file_operations *fops, const struct inode_operations *ops,
     uint64_t creation)
 {
 	struct inode *ip;
 	znode_t *zp;
 	inode_timespec_t now = {.tv_sec = creation};
 
 	ip = new_inode(zfsvfs->z_sb);
 	if (ip == NULL)
 		return (NULL);
 
 	if (!creation)
 		now = current_time(ip);
 	zp = ITOZ(ip);
 	ASSERT3P(zp->z_dirlocks, ==, NULL);
 	ASSERT3P(zp->z_acl_cached, ==, NULL);
 	ASSERT3P(zp->z_xattr_cached, ==, NULL);
 	zp->z_id = id;
 	zp->z_unlinked = B_FALSE;
 	zp->z_atime_dirty = B_FALSE;
 	zp->z_zn_prefetch = B_FALSE;
 	zp->z_is_sa = B_FALSE;
 	zp->z_is_ctldir = B_TRUE;
 	zp->z_sa_hdl = NULL;
 	zp->z_blksz = 0;
 	zp->z_seq = 0;
 	zp->z_mapcnt = 0;
 	zp->z_size = 0;
 	zp->z_pflags = 0;
 	zp->z_mode = 0;
 	zp->z_sync_cnt = 0;
 	zp->z_sync_writes_cnt = 0;
 	zp->z_async_writes_cnt = 0;
 	ip->i_generation = 0;
 	ip->i_ino = id;
 	ip->i_mode = (S_IFDIR | S_IRWXUGO);
 	ip->i_uid = SUID_TO_KUID(0);
 	ip->i_gid = SGID_TO_KGID(0);
 	ip->i_blkbits = SPA_MINBLOCKSHIFT;
 	zpl_inode_set_atime_to_ts(ip, now);
 	zpl_inode_set_mtime_to_ts(ip, now);
 	zpl_inode_set_ctime_to_ts(ip, now);
 	ip->i_fop = fops;
 	ip->i_op = ops;
 #if defined(IOP_XATTR)
 	ip->i_opflags &= ~IOP_XATTR;
 #endif
 
 	if (insert_inode_locked(ip)) {
 		unlock_new_inode(ip);
 		iput(ip);
 		return (NULL);
 	}
 
 	mutex_enter(&zfsvfs->z_znodes_lock);
 	list_insert_tail(&zfsvfs->z_all_znodes, zp);
 	membar_producer();
 	mutex_exit(&zfsvfs->z_znodes_lock);
 
 	unlock_new_inode(ip);
 
 	return (ip);
 }
 
 /*
  * Lookup the inode with given id, it will be allocated if needed.
  */
 static struct inode *
 zfsctl_inode_lookup(zfsvfs_t *zfsvfs, uint64_t id,
     const struct file_operations *fops, const struct inode_operations *ops)
 {
 	struct inode *ip = NULL;
 	uint64_t creation = 0;
 	dsl_dataset_t *snap_ds;
 	dsl_pool_t *pool;
 
 	while (ip == NULL) {
 		ip = ilookup(zfsvfs->z_sb, (unsigned long)id);
 		if (ip)
 			break;
 
 		if (id <= ZFSCTL_INO_SNAPDIRS && !creation) {
 			pool = dmu_objset_pool(zfsvfs->z_os);
 			dsl_pool_config_enter(pool, FTAG);
 			if (!dsl_dataset_hold_obj(pool,
 			    ZFSCTL_INO_SNAPDIRS - id, FTAG, &snap_ds)) {
 				creation = dsl_get_creation(snap_ds);
 				dsl_dataset_rele(snap_ds, FTAG);
 			}
 			dsl_pool_config_exit(pool, FTAG);
 		}
 
 		/* May fail due to concurrent zfsctl_inode_alloc() */
 		ip = zfsctl_inode_alloc(zfsvfs, id, fops, ops, creation);
 	}
 
 	return (ip);
 }
 
 /*
  * Create the '.zfs' directory.  This directory is cached as part of the VFS
  * structure.  This results in a hold on the zfsvfs_t.  The code in zfs_umount()
  * therefore checks against a vfs_count of 2 instead of 1.  This reference
  * is removed when the ctldir is destroyed in the unmount.  All other entities
  * under the '.zfs' directory are created dynamically as needed.
  *
  * Because the dynamically created '.zfs' directory entries assume the use
  * of 64-bit inode numbers this support must be disabled on 32-bit systems.
  */
 int
 zfsctl_create(zfsvfs_t *zfsvfs)
 {
 	ASSERT(zfsvfs->z_ctldir == NULL);
 
 	zfsvfs->z_ctldir = zfsctl_inode_alloc(zfsvfs, ZFSCTL_INO_ROOT,
 	    &zpl_fops_root, &zpl_ops_root, 0);
 	if (zfsvfs->z_ctldir == NULL)
 		return (SET_ERROR(ENOENT));
 
 	return (0);
 }
 
 /*
  * Destroy the '.zfs' directory or remove a snapshot from zfs_snapshots_by_name.
  * Only called when the filesystem is unmounted.
  */
 void
 zfsctl_destroy(zfsvfs_t *zfsvfs)
 {
 	if (zfsvfs->z_issnap) {
 		zfs_snapentry_t *se;
 		spa_t *spa = zfsvfs->z_os->os_spa;
 		uint64_t objsetid = dmu_objset_id(zfsvfs->z_os);
 
 		rw_enter(&zfs_snapshot_lock, RW_WRITER);
 		se = zfsctl_snapshot_find_by_objsetid(spa, objsetid);
 		if (se != NULL)
 			zfsctl_snapshot_remove(se);
 		rw_exit(&zfs_snapshot_lock);
 		if (se != NULL) {
 			zfsctl_snapshot_unmount_cancel(se);
 			zfsctl_snapshot_rele(se);
 		}
 	} else if (zfsvfs->z_ctldir) {
 		iput(zfsvfs->z_ctldir);
 		zfsvfs->z_ctldir = NULL;
 	}
 }
 
 /*
  * Given a root znode, retrieve the associated .zfs directory.
  * Add a hold to the vnode and return it.
  */
 struct inode *
 zfsctl_root(znode_t *zp)
 {
 	ASSERT(zfs_has_ctldir(zp));
 	/* Must have an existing ref, so igrab() cannot return NULL */
 	VERIFY3P(igrab(ZTOZSB(zp)->z_ctldir), !=, NULL);
 	return (ZTOZSB(zp)->z_ctldir);
 }
 
 /*
  * Generate a long fid to indicate a snapdir. We encode whether snapdir is
  * already mounted in gen field. We do this because nfsd lookup will not
  * trigger automount. Next time the nfsd does fh_to_dentry, we will notice
  * this and do automount and return ESTALE to force nfsd revalidate and follow
  * mount.
  */
 static int
 zfsctl_snapdir_fid(struct inode *ip, fid_t *fidp)
 {
 	zfid_short_t *zfid = (zfid_short_t *)fidp;
 	zfid_long_t *zlfid = (zfid_long_t *)fidp;
 	uint32_t gen = 0;
 	uint64_t object;
 	uint64_t objsetid;
 	int i;
 	struct dentry *dentry;
 
 	if (fidp->fid_len < LONG_FID_LEN) {
 		fidp->fid_len = LONG_FID_LEN;
 		return (SET_ERROR(ENOSPC));
 	}
 
 	object = ip->i_ino;
 	objsetid = ZFSCTL_INO_SNAPDIRS - ip->i_ino;
 	zfid->zf_len = LONG_FID_LEN;
 
 	dentry = d_obtain_alias(igrab(ip));
 	if (!IS_ERR(dentry)) {
 		gen = !!d_mountpoint(dentry);
 		dput(dentry);
 	}
 
 	for (i = 0; i < sizeof (zfid->zf_object); i++)
 		zfid->zf_object[i] = (uint8_t)(object >> (8 * i));
 
 	for (i = 0; i < sizeof (zfid->zf_gen); i++)
 		zfid->zf_gen[i] = (uint8_t)(gen >> (8 * i));
 
 	for (i = 0; i < sizeof (zlfid->zf_setid); i++)
 		zlfid->zf_setid[i] = (uint8_t)(objsetid >> (8 * i));
 
 	for (i = 0; i < sizeof (zlfid->zf_setgen); i++)
 		zlfid->zf_setgen[i] = 0;
 
 	return (0);
 }
 
 /*
  * Generate an appropriate fid for an entry in the .zfs directory.
  */
 int
 zfsctl_fid(struct inode *ip, fid_t *fidp)
 {
 	znode_t		*zp = ITOZ(ip);
 	zfsvfs_t	*zfsvfs = ITOZSB(ip);
 	uint64_t	object = zp->z_id;
 	zfid_short_t	*zfid;
 	int		i;
 	int		error;
 
 	if ((error = zfs_enter(zfsvfs, FTAG)) != 0)
 		return (error);
 
 	if (zfsctl_is_snapdir(ip)) {
 		zfs_exit(zfsvfs, FTAG);
 		return (zfsctl_snapdir_fid(ip, fidp));
 	}
 
 	if (fidp->fid_len < SHORT_FID_LEN) {
 		fidp->fid_len = SHORT_FID_LEN;
 		zfs_exit(zfsvfs, FTAG);
 		return (SET_ERROR(ENOSPC));
 	}
 
 	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 znodes always have a generation number of 0 */
 	for (i = 0; i < sizeof (zfid->zf_gen); i++)
 		zfid->zf_gen[i] = 0;
 
 	zfs_exit(zfsvfs, FTAG);
 	return (0);
 }
 
 /*
  * Construct a full dataset name in full_name: "pool/dataset@snap_name"
  */
 static int
 zfsctl_snapshot_name(zfsvfs_t *zfsvfs, const char *snap_name, int len,
     char *full_name)
 {
 	objset_t *os = zfsvfs->z_os;
 
 	if (zfs_component_namecheck(snap_name, NULL, NULL) != 0)
 		return (SET_ERROR(EILSEQ));
 
 	dmu_objset_name(os, full_name);
 	if ((strlen(full_name) + 1 + strlen(snap_name)) >= len)
 		return (SET_ERROR(ENAMETOOLONG));
 
 	(void) strcat(full_name, "@");
 	(void) strcat(full_name, snap_name);
 
 	return (0);
 }
 
 /*
  * Returns full path in full_path: "/pool/dataset/.zfs/snapshot/snap_name/"
  */
 static int
 zfsctl_snapshot_path_objset(zfsvfs_t *zfsvfs, uint64_t objsetid,
     int path_len, char *full_path)
 {
 	objset_t *os = zfsvfs->z_os;
 	fstrans_cookie_t cookie;
 	char *snapname;
 	boolean_t case_conflict;
 	uint64_t id, pos = 0;
 	int error = 0;
 
-	if (zfsvfs->z_vfs->vfs_mntpoint == NULL)
-		return (SET_ERROR(ENOENT));
-
 	cookie = spl_fstrans_mark();
 	snapname = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
 
 	while (error == 0) {
 		dsl_pool_config_enter(dmu_objset_pool(os), FTAG);
 		error = dmu_snapshot_list_next(zfsvfs->z_os,
 		    ZFS_MAX_DATASET_NAME_LEN, snapname, &id, &pos,
 		    &case_conflict);
 		dsl_pool_config_exit(dmu_objset_pool(os), FTAG);
 		if (error)
 			goto out;
 
 		if (id == objsetid)
 			break;
 	}
 
-	snprintf(full_path, path_len, "%s/.zfs/snapshot/%s",
-	    zfsvfs->z_vfs->vfs_mntpoint, snapname);
+	mutex_enter(&zfsvfs->z_vfs->vfs_mntpt_lock);
+	if (zfsvfs->z_vfs->vfs_mntpoint != NULL) {
+		snprintf(full_path, path_len, "%s/.zfs/snapshot/%s",
+		    zfsvfs->z_vfs->vfs_mntpoint, snapname);
+	} else
+		error = SET_ERROR(ENOENT);
+	mutex_exit(&zfsvfs->z_vfs->vfs_mntpt_lock);
+
 out:
 	kmem_free(snapname, ZFS_MAX_DATASET_NAME_LEN);
 	spl_fstrans_unmark(cookie);
 
 	return (error);
 }
 
 /*
  * Special case the handling of "..".
  */
 int
 zfsctl_root_lookup(struct inode *dip, const char *name, struct inode **ipp,
     int flags, cred_t *cr, int *direntflags, pathname_t *realpnp)
 {
 	zfsvfs_t *zfsvfs = ITOZSB(dip);
 	int error = 0;
 
 	if ((error = zfs_enter(zfsvfs, FTAG)) != 0)
 		return (error);
 
 	if (zfsvfs->z_show_ctldir == ZFS_SNAPDIR_DISABLED) {
 		*ipp = NULL;
 	} else if (strcmp(name, "..") == 0) {
 		*ipp = dip->i_sb->s_root->d_inode;
 	} else if (strcmp(name, ZFS_SNAPDIR_NAME) == 0) {
 		*ipp = zfsctl_inode_lookup(zfsvfs, ZFSCTL_INO_SNAPDIR,
 		    &zpl_fops_snapdir, &zpl_ops_snapdir);
 	} else if (strcmp(name, ZFS_SHAREDIR_NAME) == 0) {
 		*ipp = zfsctl_inode_lookup(zfsvfs, ZFSCTL_INO_SHARES,
 		    &zpl_fops_shares, &zpl_ops_shares);
 	} else {
 		*ipp = NULL;
 	}
 
 	if (*ipp == NULL)
 		error = SET_ERROR(ENOENT);
 
 	zfs_exit(zfsvfs, FTAG);
 
 	return (error);
 }
 
 /*
  * Lookup entry point for the 'snapshot' directory.  Try to open the
  * snapshot if it exist, creating the pseudo filesystem inode as necessary.
  */
 int
 zfsctl_snapdir_lookup(struct inode *dip, const char *name, struct inode **ipp,
     int flags, cred_t *cr, int *direntflags, pathname_t *realpnp)
 {
 	zfsvfs_t *zfsvfs = ITOZSB(dip);
 	uint64_t id;
 	int error;
 
 	if ((error = zfs_enter(zfsvfs, FTAG)) != 0)
 		return (error);
 
 	error = dmu_snapshot_lookup(zfsvfs->z_os, name, &id);
 	if (error) {
 		zfs_exit(zfsvfs, FTAG);
 		return (error);
 	}
 
 	*ipp = zfsctl_inode_lookup(zfsvfs, ZFSCTL_INO_SNAPDIRS - id,
 	    &simple_dir_operations, &simple_dir_inode_operations);
 	if (*ipp == NULL)
 		error = SET_ERROR(ENOENT);
 
 	zfs_exit(zfsvfs, FTAG);
 
 	return (error);
 }
 
 /*
  * Renaming a directory under '.zfs/snapshot' will automatically trigger
  * a rename of the snapshot to the new given name.  The rename is confined
  * to the '.zfs/snapshot' directory snapshots cannot be moved elsewhere.
  */
 int
 zfsctl_snapdir_rename(struct inode *sdip, const char *snm,
     struct inode *tdip, const char *tnm, cred_t *cr, int flags)
 {
 	zfsvfs_t *zfsvfs = ITOZSB(sdip);
 	char *to, *from, *real, *fsname;
 	int error;
 
 	if (!zfs_admin_snapshot)
 		return (SET_ERROR(EACCES));
 
 	if ((error = zfs_enter(zfsvfs, FTAG)) != 0)
 		return (error);
 
 	to = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
 	from = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
 	real = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
 	fsname = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
 
 	if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) {
 		error = dmu_snapshot_realname(zfsvfs->z_os, snm, real,
 		    ZFS_MAX_DATASET_NAME_LEN, NULL);
 		if (error == 0) {
 			snm = real;
 		} else if (error != ENOTSUP) {
 			goto out;
 		}
 	}
 
 	dmu_objset_name(zfsvfs->z_os, fsname);
 
 	error = zfsctl_snapshot_name(ITOZSB(sdip), snm,
 	    ZFS_MAX_DATASET_NAME_LEN, from);
 	if (error == 0)
 		error = zfsctl_snapshot_name(ITOZSB(tdip), tnm,
 		    ZFS_MAX_DATASET_NAME_LEN, to);
 	if (error == 0)
 		error = zfs_secpolicy_rename_perms(from, to, cr);
 	if (error != 0)
 		goto out;
 
 	/*
 	 * Cannot move snapshots out of the snapdir.
 	 */
 	if (sdip != tdip) {
 		error = SET_ERROR(EINVAL);
 		goto out;
 	}
 
 	/*
 	 * No-op when names are identical.
 	 */
 	if (strcmp(snm, tnm) == 0) {
 		error = 0;
 		goto out;
 	}
 
 	rw_enter(&zfs_snapshot_lock, RW_WRITER);
 
 	error = dsl_dataset_rename_snapshot(fsname, snm, tnm, B_FALSE);
 	if (error == 0)
 		(void) zfsctl_snapshot_rename(snm, tnm);
 
 	rw_exit(&zfs_snapshot_lock);
 out:
 	kmem_free(from, ZFS_MAX_DATASET_NAME_LEN);
 	kmem_free(to, ZFS_MAX_DATASET_NAME_LEN);
 	kmem_free(real, ZFS_MAX_DATASET_NAME_LEN);
 	kmem_free(fsname, ZFS_MAX_DATASET_NAME_LEN);
 
 	zfs_exit(zfsvfs, FTAG);
 
 	return (error);
 }
 
 /*
  * Removing a directory under '.zfs/snapshot' will automatically trigger
  * the removal of the snapshot with the given name.
  */
 int
 zfsctl_snapdir_remove(struct inode *dip, const char *name, cred_t *cr,
     int flags)
 {
 	zfsvfs_t *zfsvfs = ITOZSB(dip);
 	char *snapname, *real;
 	int error;
 
 	if (!zfs_admin_snapshot)
 		return (SET_ERROR(EACCES));
 
 	if ((error = zfs_enter(zfsvfs, FTAG)) != 0)
 		return (error);
 
 	snapname = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
 	real = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
 
 	if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) {
 		error = dmu_snapshot_realname(zfsvfs->z_os, name, real,
 		    ZFS_MAX_DATASET_NAME_LEN, NULL);
 		if (error == 0) {
 			name = real;
 		} else if (error != ENOTSUP) {
 			goto out;
 		}
 	}
 
 	error = zfsctl_snapshot_name(ITOZSB(dip), name,
 	    ZFS_MAX_DATASET_NAME_LEN, snapname);
 	if (error == 0)
 		error = zfs_secpolicy_destroy_perms(snapname, cr);
 	if (error != 0)
 		goto out;
 
 	error = zfsctl_snapshot_unmount(snapname, MNT_FORCE);
 	if ((error == 0) || (error == ENOENT))
 		error = dsl_destroy_snapshot(snapname, B_FALSE);
 out:
 	kmem_free(snapname, ZFS_MAX_DATASET_NAME_LEN);
 	kmem_free(real, ZFS_MAX_DATASET_NAME_LEN);
 
 	zfs_exit(zfsvfs, FTAG);
 
 	return (error);
 }
 
 /*
  * Creating a directory under '.zfs/snapshot' will automatically trigger
  * the creation of a new snapshot with the given name.
  */
 int
 zfsctl_snapdir_mkdir(struct inode *dip, const char *dirname, vattr_t *vap,
     struct inode **ipp, cred_t *cr, int flags)
 {
 	zfsvfs_t *zfsvfs = ITOZSB(dip);
 	char *dsname;
 	int error;
 
 	if (!zfs_admin_snapshot)
 		return (SET_ERROR(EACCES));
 
 	dsname = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
 
 	if (zfs_component_namecheck(dirname, NULL, NULL) != 0) {
 		error = SET_ERROR(EILSEQ);
 		goto out;
 	}
 
 	dmu_objset_name(zfsvfs->z_os, dsname);
 
 	error = zfs_secpolicy_snapshot_perms(dsname, cr);
 	if (error != 0)
 		goto out;
 
 	if (error == 0) {
 		error = dmu_objset_snapshot_one(dsname, dirname);
 		if (error != 0)
 			goto out;
 
 		error = zfsctl_snapdir_lookup(dip, dirname, ipp,
 		    0, cr, NULL, NULL);
 	}
 out:
 	kmem_free(dsname, ZFS_MAX_DATASET_NAME_LEN);
 
 	return (error);
 }
 
 /*
  * Flush everything out of the kernel's export table and such.
  * This is needed as once the snapshot is used over NFS, its
  * entries in svc_export and svc_expkey caches hold reference
  * to the snapshot mount point. There is no known way of flushing
  * only the entries related to the snapshot.
  */
 static void
 exportfs_flush(void)
 {
 	char *argv[] = { "/usr/sbin/exportfs", "-f", NULL };
 	char *envp[] = { NULL };
 
 	(void) call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
 }
 
+/*
+ * Returns the path in char format for given struct path. Uses
+ * d_path exported by kernel to convert struct path to char
+ * format. Returns the correct path for mountpoints and chroot
+ * environments.
+ *
+ * If chroot environment has directories that are mounted with
+ * --bind or --rbind flag, d_path returns the complete path inside
+ * chroot environment but does not return the absolute path, i.e.
+ * the path to chroot environment is missing.
+ */
+static int
+get_root_path(struct path *path, char *buff, int len)
+{
+	char *path_buffer, *path_ptr;
+	int error = 0;
+
+	path_get(path);
+	path_buffer = kmem_zalloc(len, KM_SLEEP);
+	path_ptr = d_path(path, path_buffer, len);
+	if (IS_ERR(path_ptr))
+		error = SET_ERROR(-PTR_ERR(path_ptr));
+	else
+		strcpy(buff, path_ptr);
+
+	kmem_free(path_buffer, len);
+	path_put(path);
+	return (error);
+}
+
+/*
+ * Returns if the current process root is chrooted or not. Linux
+ * kernel exposes the task_struct for current process and init.
+ * Since init process root points to actual root filesystem when
+ * Linux runtime is reached, we can compare the current process
+ * root with init process root to determine if root of the current
+ * process is different from init, which can reliably determine if
+ * current process is in chroot context or not.
+ */
+static int
+is_current_chrooted(void)
+{
+	struct task_struct *curr = current, *global = &init_task;
+	struct path cr_root, gl_root;
+
+	task_lock(curr);
+	get_fs_root(curr->fs, &cr_root);
+	task_unlock(curr);
+
+	task_lock(global);
+	get_fs_root(global->fs, &gl_root);
+	task_unlock(global);
+
+	int chrooted = !path_equal(&cr_root, &gl_root);
+	path_put(&gl_root);
+	path_put(&cr_root);
+
+	return (chrooted);
+}
+
 /*
  * Attempt to unmount a snapshot by making a call to user space.
  * There is no assurance that this can or will succeed, is just a
  * best effort.  In the case where it does fail, perhaps because
  * it's in use, the unmount will fail harmlessly.
  */
 int
 zfsctl_snapshot_unmount(const char *snapname, int flags)
 {
 	char *argv[] = { "/usr/bin/env", "umount", "-t", "zfs", "-n", NULL,
 	    NULL };
 	char *envp[] = { NULL };
 	zfs_snapentry_t *se;
 	int error;
 
 	rw_enter(&zfs_snapshot_lock, RW_READER);
 	if ((se = zfsctl_snapshot_find_by_name(snapname)) == NULL) {
 		rw_exit(&zfs_snapshot_lock);
 		return (SET_ERROR(ENOENT));
 	}
 	rw_exit(&zfs_snapshot_lock);
 
 	exportfs_flush();
 
 	if (flags & MNT_FORCE)
 		argv[4] = "-fn";
 	argv[5] = se->se_path;
 	dprintf("unmount; path=%s\n", se->se_path);
 	error = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
 	zfsctl_snapshot_rele(se);
 
 
 	/*
 	 * The umount system utility will return 256 on error.  We must
 	 * assume this error is because the file system is busy so it is
 	 * converted to the more sensible EBUSY.
 	 */
 	if (error)
 		error = SET_ERROR(EBUSY);
 
 	return (error);
 }
 
 int
 zfsctl_snapshot_mount(struct path *path, int flags)
 {
 	struct dentry *dentry = path->dentry;
 	struct inode *ip = dentry->d_inode;
 	zfsvfs_t *zfsvfs;
 	zfsvfs_t *snap_zfsvfs;
 	zfs_snapentry_t *se;
 	char *full_name, *full_path, *options;
 	char *argv[] = { "/usr/bin/env", "mount", "-i", "-t", "zfs", "-n",
 	    "-o", NULL, NULL, NULL, NULL };
 	char *envp[] = { NULL };
 	int error;
 	struct path spath;
 
 	if (ip == NULL)
 		return (SET_ERROR(EISDIR));
 
 	zfsvfs = ITOZSB(ip);
 	if ((error = zfs_enter(zfsvfs, FTAG)) != 0)
 		return (error);
 
 	full_name = kmem_zalloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
 	full_path = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
 	options = kmem_zalloc(7, KM_SLEEP);
 
 	error = zfsctl_snapshot_name(zfsvfs, dname(dentry),
 	    ZFS_MAX_DATASET_NAME_LEN, full_name);
 	if (error)
 		goto error;
 
+	if (is_current_chrooted() == 0) {
+		/*
+		 * Current process is not in chroot context
+		 */
+
+		char *m = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
+		struct path mnt_path;
+		mnt_path.mnt = path->mnt;
+		mnt_path.dentry = path->mnt->mnt_root;
+
+		/*
+		 * Get path to current mountpoint
+		 */
+		error = get_root_path(&mnt_path, m, MAXPATHLEN);
+		if (error != 0) {
+			kmem_free(m, MAXPATHLEN);
+			goto error;
+		}
+		mutex_enter(&zfsvfs->z_vfs->vfs_mntpt_lock);
+		if (zfsvfs->z_vfs->vfs_mntpoint != NULL) {
+			/*
+			 * If current mnountpoint and vfs_mntpoint are not same,
+			 * store current mountpoint in vfs_mntpoint.
+			 */
+			if (strcmp(zfsvfs->z_vfs->vfs_mntpoint, m) != 0) {
+				kmem_strfree(zfsvfs->z_vfs->vfs_mntpoint);
+				zfsvfs->z_vfs->vfs_mntpoint = kmem_strdup(m);
+			}
+		} else
+			zfsvfs->z_vfs->vfs_mntpoint = kmem_strdup(m);
+		mutex_exit(&zfsvfs->z_vfs->vfs_mntpt_lock);
+		kmem_free(m, MAXPATHLEN);
+	}
+
 	/*
 	 * Construct a mount point path from sb of the ctldir inode and dirent
 	 * name, instead of from d_path(), so that chroot'd process doesn't fail
 	 * on mount.zfs(8).
 	 */
+	mutex_enter(&zfsvfs->z_vfs->vfs_mntpt_lock);
 	snprintf(full_path, MAXPATHLEN, "%s/.zfs/snapshot/%s",
 	    zfsvfs->z_vfs->vfs_mntpoint ? zfsvfs->z_vfs->vfs_mntpoint : "",
 	    dname(dentry));
+	mutex_exit(&zfsvfs->z_vfs->vfs_mntpt_lock);
 
 	snprintf(options, 7, "%s",
 	    zfs_snapshot_no_setuid ? "nosuid" : "suid");
 
 	/*
 	 * Multiple concurrent automounts of a snapshot are never allowed.
 	 * The snapshot may be manually mounted as many times as desired.
 	 */
 	if (zfsctl_snapshot_ismounted(full_name)) {
 		error = 0;
 		goto error;
 	}
 
 	/*
 	 * Attempt to mount the snapshot from user space.  Normally this
 	 * would be done using the vfs_kern_mount() function, however that
 	 * function is marked GPL-only and cannot be used.  On error we
 	 * careful to log the real error to the console and return EISDIR
 	 * to safely abort the automount.  This should be very rare.
 	 *
 	 * If the user mode helper happens to return EBUSY, a concurrent
 	 * mount is already in progress in which case the error is ignored.
 	 * Take note that if the program was executed successfully the return
 	 * value from call_usermodehelper() will be (exitcode << 8 + signal).
 	 */
 	dprintf("mount; name=%s path=%s\n", full_name, full_path);
 	argv[7] = options;
 	argv[8] = full_name;
 	argv[9] = full_path;
 	error = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
 	if (error) {
 		if (!(error & MOUNT_BUSY << 8)) {
 			zfs_dbgmsg("Unable to automount %s error=%d",
 			    full_path, error);
 			error = SET_ERROR(EISDIR);
 		} else {
 			/*
 			 * EBUSY, this could mean a concurrent mount, or the
 			 * snapshot has already been mounted at completely
 			 * different place. We return 0 so VFS will retry. For
 			 * the latter case the VFS will retry several times
 			 * and return ELOOP, which is probably not a very good
 			 * behavior.
 			 */
 			error = 0;
 		}
 		goto error;
 	}
 
 	/*
 	 * Follow down in to the mounted snapshot and set MNT_SHRINKABLE
 	 * to identify this as an automounted filesystem.
 	 */
 	spath = *path;
 	path_get(&spath);
 	if (follow_down_one(&spath)) {
 		snap_zfsvfs = ITOZSB(spath.dentry->d_inode);
 		snap_zfsvfs->z_parent = zfsvfs;
 		dentry = spath.dentry;
 		spath.mnt->mnt_flags |= MNT_SHRINKABLE;
 
 		rw_enter(&zfs_snapshot_lock, RW_WRITER);
 		se = zfsctl_snapshot_alloc(full_name, full_path,
 		    snap_zfsvfs->z_os->os_spa, dmu_objset_id(snap_zfsvfs->z_os),
 		    dentry);
 		zfsctl_snapshot_add(se);
 		zfsctl_snapshot_unmount_delay_impl(se, zfs_expire_snapshot);
 		rw_exit(&zfs_snapshot_lock);
 	}
 	path_put(&spath);
 error:
 	kmem_free(full_name, ZFS_MAX_DATASET_NAME_LEN);
 	kmem_free(full_path, MAXPATHLEN);
 
 	zfs_exit(zfsvfs, FTAG);
 
 	return (error);
 }
 
 /*
  * Get the snapdir inode from fid
  */
 int
 zfsctl_snapdir_vget(struct super_block *sb, uint64_t objsetid, int gen,
     struct inode **ipp)
 {
 	int error;
 	struct path path;
 	char *mnt;
 	struct dentry *dentry;
 
 	mnt = kmem_alloc(MAXPATHLEN, KM_SLEEP);
 
 	error = zfsctl_snapshot_path_objset(sb->s_fs_info, objsetid,
 	    MAXPATHLEN, mnt);
 	if (error)
 		goto out;
 
 	/* Trigger automount */
 	error = -kern_path(mnt, LOOKUP_FOLLOW|LOOKUP_DIRECTORY, &path);
 	if (error)
 		goto out;
 
 	path_put(&path);
 	/*
 	 * Get the snapdir inode. Note, we don't want to use the above
 	 * path because it contains the root of the snapshot rather
 	 * than the snapdir.
 	 */
 	*ipp = ilookup(sb, ZFSCTL_INO_SNAPDIRS - objsetid);
 	if (*ipp == NULL) {
 		error = SET_ERROR(ENOENT);
 		goto out;
 	}
 
 	/* check gen, see zfsctl_snapdir_fid */
 	dentry = d_obtain_alias(igrab(*ipp));
 	if (gen != (!IS_ERR(dentry) && d_mountpoint(dentry))) {
 		iput(*ipp);
 		*ipp = NULL;
 		error = SET_ERROR(ENOENT);
 	}
 	if (!IS_ERR(dentry))
 		dput(dentry);
 out:
 	kmem_free(mnt, MAXPATHLEN);
 	return (error);
 }
 
 int
 zfsctl_shares_lookup(struct inode *dip, char *name, struct inode **ipp,
     int flags, cred_t *cr, int *direntflags, pathname_t *realpnp)
 {
 	zfsvfs_t *zfsvfs = ITOZSB(dip);
 	znode_t *zp;
 	znode_t *dzp;
 	int error;
 
 	if ((error = zfs_enter(zfsvfs, FTAG)) != 0)
 		return (error);
 
 	if (zfsvfs->z_shares_dir == 0) {
 		zfs_exit(zfsvfs, FTAG);
 		return (SET_ERROR(ENOTSUP));
 	}
 
 	if ((error = zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &dzp)) == 0) {
 		error = zfs_lookup(dzp, name, &zp, 0, cr, NULL, NULL);
 		zrele(dzp);
 	}
 
 	zfs_exit(zfsvfs, FTAG);
 
 	return (error);
 }
 
 /*
  * Initialize the various pieces we'll need to create and manipulate .zfs
  * directories.  Currently this is unused but available.
  */
 void
 zfsctl_init(void)
 {
 	avl_create(&zfs_snapshots_by_name, snapentry_compare_by_name,
 	    sizeof (zfs_snapentry_t), offsetof(zfs_snapentry_t,
 	    se_node_name));
 	avl_create(&zfs_snapshots_by_objsetid, snapentry_compare_by_objsetid,
 	    sizeof (zfs_snapentry_t), offsetof(zfs_snapentry_t,
 	    se_node_objsetid));
 	rw_init(&zfs_snapshot_lock, NULL, RW_DEFAULT, NULL);
 }
 
 /*
  * Cleanup the various pieces we needed for .zfs directories.  In particular
  * ensure the expiry timer is canceled safely.
  */
 void
 zfsctl_fini(void)
 {
 	avl_destroy(&zfs_snapshots_by_name);
 	avl_destroy(&zfs_snapshots_by_objsetid);
 	rw_destroy(&zfs_snapshot_lock);
 }
 
 module_param(zfs_admin_snapshot, int, 0644);
 MODULE_PARM_DESC(zfs_admin_snapshot, "Enable mkdir/rmdir/mv in .zfs/snapshot");
 
 module_param(zfs_expire_snapshot, int, 0644);
 MODULE_PARM_DESC(zfs_expire_snapshot, "Seconds to expire .zfs/snapshot");
 
 module_param(zfs_snapshot_no_setuid, int, 0644);
 MODULE_PARM_DESC(zfs_snapshot_no_setuid,
 	"Disable setuid/setgid for automounts in .zfs/snapshot");
diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zfs_vfsops.c b/sys/contrib/openzfs/module/os/linux/zfs/zfs_vfsops.c
index de3e8c89cfdd..3c53a8a315c3 100644
--- a/sys/contrib/openzfs/module/os/linux/zfs/zfs_vfsops.c
+++ b/sys/contrib/openzfs/module/os/linux/zfs/zfs_vfsops.c
@@ -1,2072 +1,2074 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
  */
 
 /* Portions Copyright 2010 Robert Milkowski */
 
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/sysmacros.h>
 #include <sys/kmem.h>
 #include <sys/pathname.h>
 #include <sys/vnode.h>
 #include <sys/vfs.h>
 #include <sys/mntent.h>
 #include <sys/cmn_err.h>
 #include <sys/zfs_znode.h>
 #include <sys/zfs_vnops.h>
 #include <sys/zfs_dir.h>
 #include <sys/zil.h>
 #include <sys/fs/zfs.h>
 #include <sys/dmu.h>
 #include <sys/dsl_prop.h>
 #include <sys/dsl_dataset.h>
 #include <sys/dsl_deleg.h>
 #include <sys/spa.h>
 #include <sys/zap.h>
 #include <sys/sa.h>
 #include <sys/sa_impl.h>
 #include <sys/policy.h>
 #include <sys/atomic.h>
 #include <sys/zfs_ioctl.h>
 #include <sys/zfs_ctldir.h>
 #include <sys/zfs_fuid.h>
 #include <sys/zfs_quota.h>
 #include <sys/sunddi.h>
 #include <sys/dmu_objset.h>
 #include <sys/dsl_dir.h>
 #include <sys/objlist.h>
 #include <sys/zfeature.h>
 #include <sys/zpl.h>
 #include <linux/vfs_compat.h>
 #include <linux/fs.h>
 #include "zfs_comutil.h"
 
 enum {
 	TOKEN_RO,
 	TOKEN_RW,
 	TOKEN_SETUID,
 	TOKEN_NOSETUID,
 	TOKEN_EXEC,
 	TOKEN_NOEXEC,
 	TOKEN_DEVICES,
 	TOKEN_NODEVICES,
 	TOKEN_DIRXATTR,
 	TOKEN_SAXATTR,
 	TOKEN_XATTR,
 	TOKEN_NOXATTR,
 	TOKEN_ATIME,
 	TOKEN_NOATIME,
 	TOKEN_RELATIME,
 	TOKEN_NORELATIME,
 	TOKEN_NBMAND,
 	TOKEN_NONBMAND,
 	TOKEN_MNTPOINT,
 	TOKEN_LAST,
 };
 
 static const match_table_t zpl_tokens = {
 	{ TOKEN_RO,		MNTOPT_RO },
 	{ TOKEN_RW,		MNTOPT_RW },
 	{ TOKEN_SETUID,		MNTOPT_SETUID },
 	{ TOKEN_NOSETUID,	MNTOPT_NOSETUID },
 	{ TOKEN_EXEC,		MNTOPT_EXEC },
 	{ TOKEN_NOEXEC,		MNTOPT_NOEXEC },
 	{ TOKEN_DEVICES,	MNTOPT_DEVICES },
 	{ TOKEN_NODEVICES,	MNTOPT_NODEVICES },
 	{ TOKEN_DIRXATTR,	MNTOPT_DIRXATTR },
 	{ TOKEN_SAXATTR,	MNTOPT_SAXATTR },
 	{ TOKEN_XATTR,		MNTOPT_XATTR },
 	{ TOKEN_NOXATTR,	MNTOPT_NOXATTR },
 	{ TOKEN_ATIME,		MNTOPT_ATIME },
 	{ TOKEN_NOATIME,	MNTOPT_NOATIME },
 	{ TOKEN_RELATIME,	MNTOPT_RELATIME },
 	{ TOKEN_NORELATIME,	MNTOPT_NORELATIME },
 	{ TOKEN_NBMAND,		MNTOPT_NBMAND },
 	{ TOKEN_NONBMAND,	MNTOPT_NONBMAND },
 	{ TOKEN_MNTPOINT,	MNTOPT_MNTPOINT "=%s" },
 	{ TOKEN_LAST,		NULL },
 };
 
 static void
 zfsvfs_vfs_free(vfs_t *vfsp)
 {
 	if (vfsp != NULL) {
 		if (vfsp->vfs_mntpoint != NULL)
 			kmem_strfree(vfsp->vfs_mntpoint);
-
+		mutex_destroy(&vfsp->vfs_mntpt_lock);
 		kmem_free(vfsp, sizeof (vfs_t));
 	}
 }
 
 static int
 zfsvfs_parse_option(char *option, int token, substring_t *args, vfs_t *vfsp)
 {
 	switch (token) {
 	case TOKEN_RO:
 		vfsp->vfs_readonly = B_TRUE;
 		vfsp->vfs_do_readonly = B_TRUE;
 		break;
 	case TOKEN_RW:
 		vfsp->vfs_readonly = B_FALSE;
 		vfsp->vfs_do_readonly = B_TRUE;
 		break;
 	case TOKEN_SETUID:
 		vfsp->vfs_setuid = B_TRUE;
 		vfsp->vfs_do_setuid = B_TRUE;
 		break;
 	case TOKEN_NOSETUID:
 		vfsp->vfs_setuid = B_FALSE;
 		vfsp->vfs_do_setuid = B_TRUE;
 		break;
 	case TOKEN_EXEC:
 		vfsp->vfs_exec = B_TRUE;
 		vfsp->vfs_do_exec = B_TRUE;
 		break;
 	case TOKEN_NOEXEC:
 		vfsp->vfs_exec = B_FALSE;
 		vfsp->vfs_do_exec = B_TRUE;
 		break;
 	case TOKEN_DEVICES:
 		vfsp->vfs_devices = B_TRUE;
 		vfsp->vfs_do_devices = B_TRUE;
 		break;
 	case TOKEN_NODEVICES:
 		vfsp->vfs_devices = B_FALSE;
 		vfsp->vfs_do_devices = B_TRUE;
 		break;
 	case TOKEN_DIRXATTR:
 		vfsp->vfs_xattr = ZFS_XATTR_DIR;
 		vfsp->vfs_do_xattr = B_TRUE;
 		break;
 	case TOKEN_SAXATTR:
 		vfsp->vfs_xattr = ZFS_XATTR_SA;
 		vfsp->vfs_do_xattr = B_TRUE;
 		break;
 	case TOKEN_XATTR:
 		vfsp->vfs_xattr = ZFS_XATTR_SA;
 		vfsp->vfs_do_xattr = B_TRUE;
 		break;
 	case TOKEN_NOXATTR:
 		vfsp->vfs_xattr = ZFS_XATTR_OFF;
 		vfsp->vfs_do_xattr = B_TRUE;
 		break;
 	case TOKEN_ATIME:
 		vfsp->vfs_atime = B_TRUE;
 		vfsp->vfs_do_atime = B_TRUE;
 		break;
 	case TOKEN_NOATIME:
 		vfsp->vfs_atime = B_FALSE;
 		vfsp->vfs_do_atime = B_TRUE;
 		break;
 	case TOKEN_RELATIME:
 		vfsp->vfs_relatime = B_TRUE;
 		vfsp->vfs_do_relatime = B_TRUE;
 		break;
 	case TOKEN_NORELATIME:
 		vfsp->vfs_relatime = B_FALSE;
 		vfsp->vfs_do_relatime = B_TRUE;
 		break;
 	case TOKEN_NBMAND:
 		vfsp->vfs_nbmand = B_TRUE;
 		vfsp->vfs_do_nbmand = B_TRUE;
 		break;
 	case TOKEN_NONBMAND:
 		vfsp->vfs_nbmand = B_FALSE;
 		vfsp->vfs_do_nbmand = B_TRUE;
 		break;
 	case TOKEN_MNTPOINT:
+		if (vfsp->vfs_mntpoint != NULL)
+			kmem_strfree(vfsp->vfs_mntpoint);
 		vfsp->vfs_mntpoint = match_strdup(&args[0]);
 		if (vfsp->vfs_mntpoint == NULL)
 			return (SET_ERROR(ENOMEM));
-
 		break;
 	default:
 		break;
 	}
 
 	return (0);
 }
 
 /*
  * Parse the raw mntopts and return a vfs_t describing the options.
  */
 static int
 zfsvfs_parse_options(char *mntopts, vfs_t **vfsp)
 {
 	vfs_t *tmp_vfsp;
 	int error;
 
 	tmp_vfsp = kmem_zalloc(sizeof (vfs_t), KM_SLEEP);
+	mutex_init(&tmp_vfsp->vfs_mntpt_lock, NULL, MUTEX_DEFAULT, NULL);
 
 	if (mntopts != NULL) {
 		substring_t args[MAX_OPT_ARGS];
 		char *tmp_mntopts, *p, *t;
 		int token;
 
 		tmp_mntopts = t = kmem_strdup(mntopts);
 		if (tmp_mntopts == NULL)
 			return (SET_ERROR(ENOMEM));
 
 		while ((p = strsep(&t, ",")) != NULL) {
 			if (!*p)
 				continue;
 
 			args[0].to = args[0].from = NULL;
 			token = match_token(p, zpl_tokens, args);
 			error = zfsvfs_parse_option(p, token, args, tmp_vfsp);
 			if (error) {
 				kmem_strfree(tmp_mntopts);
 				zfsvfs_vfs_free(tmp_vfsp);
 				return (error);
 			}
 		}
 
 		kmem_strfree(tmp_mntopts);
 	}
 
 	*vfsp = tmp_vfsp;
 
 	return (0);
 }
 
 boolean_t
 zfs_is_readonly(zfsvfs_t *zfsvfs)
 {
 	return (!!(zfsvfs->z_sb->s_flags & SB_RDONLY));
 }
 
 int
 zfs_sync(struct super_block *sb, int wait, cred_t *cr)
 {
 	(void) cr;
 	zfsvfs_t *zfsvfs = sb->s_fs_info;
 
 	/*
 	 * Semantically, the only requirement is that the sync be initiated.
 	 * The DMU syncs out txgs frequently, so there's nothing to do.
 	 */
 	if (!wait)
 		return (0);
 
 	if (zfsvfs != NULL) {
 		/*
 		 * Sync a specific filesystem.
 		 */
 		dsl_pool_t *dp;
 		int error;
 
 		if ((error = zfs_enter(zfsvfs, FTAG)) != 0)
 			return (error);
 		dp = dmu_objset_pool(zfsvfs->z_os);
 
 		/*
 		 * If the system is shutting down, then skip any
 		 * filesystems which may exist on a suspended pool.
 		 */
 		if (spa_suspended(dp->dp_spa)) {
 			zfs_exit(zfsvfs, FTAG);
 			return (0);
 		}
 
 		if (zfsvfs->z_log != NULL)
 			zil_commit(zfsvfs->z_log, 0);
 
 		zfs_exit(zfsvfs, FTAG);
 	} else {
 		/*
 		 * Sync all ZFS filesystems.  This is what happens when you
 		 * run sync(1).  Unlike other filesystems, ZFS honors the
 		 * request by waiting for all pools to commit all dirty data.
 		 */
 		spa_sync_allpools();
 	}
 
 	return (0);
 }
 
 static void
 atime_changed_cb(void *arg, uint64_t newval)
 {
 	zfsvfs_t *zfsvfs = arg;
 	struct super_block *sb = zfsvfs->z_sb;
 
 	if (sb == NULL)
 		return;
 	/*
 	 * Update SB_NOATIME bit in VFS super block.  Since atime update is
 	 * determined by atime_needs_update(), atime_needs_update() needs to
 	 * return false if atime is turned off, and not unconditionally return
 	 * false if atime is turned on.
 	 */
 	if (newval)
 		sb->s_flags &= ~SB_NOATIME;
 	else
 		sb->s_flags |= SB_NOATIME;
 }
 
 static void
 relatime_changed_cb(void *arg, uint64_t newval)
 {
 	((zfsvfs_t *)arg)->z_relatime = newval;
 }
 
 static void
 xattr_changed_cb(void *arg, uint64_t newval)
 {
 	zfsvfs_t *zfsvfs = arg;
 
 	if (newval == ZFS_XATTR_OFF) {
 		zfsvfs->z_flags &= ~ZSB_XATTR;
 	} else {
 		zfsvfs->z_flags |= ZSB_XATTR;
 
 		if (newval == ZFS_XATTR_SA)
 			zfsvfs->z_xattr_sa = B_TRUE;
 		else
 			zfsvfs->z_xattr_sa = B_FALSE;
 	}
 }
 
 static void
 acltype_changed_cb(void *arg, uint64_t newval)
 {
 	zfsvfs_t *zfsvfs = arg;
 
 	switch (newval) {
 	case ZFS_ACLTYPE_NFSV4:
 	case ZFS_ACLTYPE_OFF:
 		zfsvfs->z_acl_type = ZFS_ACLTYPE_OFF;
 		zfsvfs->z_sb->s_flags &= ~SB_POSIXACL;
 		break;
 	case ZFS_ACLTYPE_POSIX:
 #ifdef CONFIG_FS_POSIX_ACL
 		zfsvfs->z_acl_type = ZFS_ACLTYPE_POSIX;
 		zfsvfs->z_sb->s_flags |= SB_POSIXACL;
 #else
 		zfsvfs->z_acl_type = ZFS_ACLTYPE_OFF;
 		zfsvfs->z_sb->s_flags &= ~SB_POSIXACL;
 #endif /* CONFIG_FS_POSIX_ACL */
 		break;
 	default:
 		break;
 	}
 }
 
 static void
 blksz_changed_cb(void *arg, uint64_t newval)
 {
 	zfsvfs_t *zfsvfs = arg;
 	ASSERT3U(newval, <=, spa_maxblocksize(dmu_objset_spa(zfsvfs->z_os)));
 	ASSERT3U(newval, >=, SPA_MINBLOCKSIZE);
 	ASSERT(ISP2(newval));
 
 	zfsvfs->z_max_blksz = newval;
 }
 
 static void
 readonly_changed_cb(void *arg, uint64_t newval)
 {
 	zfsvfs_t *zfsvfs = arg;
 	struct super_block *sb = zfsvfs->z_sb;
 
 	if (sb == NULL)
 		return;
 
 	if (newval)
 		sb->s_flags |= SB_RDONLY;
 	else
 		sb->s_flags &= ~SB_RDONLY;
 }
 
 static void
 devices_changed_cb(void *arg, uint64_t newval)
 {
 }
 
 static void
 setuid_changed_cb(void *arg, uint64_t newval)
 {
 }
 
 static void
 exec_changed_cb(void *arg, uint64_t newval)
 {
 }
 
 static void
 nbmand_changed_cb(void *arg, uint64_t newval)
 {
 	zfsvfs_t *zfsvfs = arg;
 	struct super_block *sb = zfsvfs->z_sb;
 
 	if (sb == NULL)
 		return;
 
 	if (newval == TRUE)
 		sb->s_flags |= SB_MANDLOCK;
 	else
 		sb->s_flags &= ~SB_MANDLOCK;
 }
 
 static void
 snapdir_changed_cb(void *arg, uint64_t newval)
 {
 	((zfsvfs_t *)arg)->z_show_ctldir = newval;
 }
 
 static void
 acl_mode_changed_cb(void *arg, uint64_t newval)
 {
 	zfsvfs_t *zfsvfs = arg;
 
 	zfsvfs->z_acl_mode = newval;
 }
 
 static void
 acl_inherit_changed_cb(void *arg, uint64_t newval)
 {
 	((zfsvfs_t *)arg)->z_acl_inherit = newval;
 }
 
 static void
 longname_changed_cb(void *arg, uint64_t newval)
 {
 	((zfsvfs_t *)arg)->z_longname = newval;
 }
 
 static int
 zfs_register_callbacks(vfs_t *vfsp)
 {
 	struct dsl_dataset *ds = NULL;
 	objset_t *os = NULL;
 	zfsvfs_t *zfsvfs = NULL;
 	int error = 0;
 
 	ASSERT(vfsp);
 	zfsvfs = vfsp->vfs_data;
 	ASSERT(zfsvfs);
 	os = zfsvfs->z_os;
 
 	/*
 	 * The act of registering our callbacks will destroy any mount
 	 * options we may have.  In order to enable temporary overrides
 	 * of mount options, we stash away the current values and
 	 * restore them after we register the callbacks.
 	 */
 	if (zfs_is_readonly(zfsvfs) || !spa_writeable(dmu_objset_spa(os))) {
 		vfsp->vfs_do_readonly = B_TRUE;
 		vfsp->vfs_readonly = B_TRUE;
 	}
 
 	/*
 	 * Register property callbacks.
 	 *
 	 * It would probably be fine to just check for i/o error from
 	 * the first prop_register(), but I guess I like to go
 	 * overboard...
 	 */
 	ds = dmu_objset_ds(os);
 	dsl_pool_config_enter(dmu_objset_pool(os), FTAG);
 	error = dsl_prop_register(ds,
 	    zfs_prop_to_name(ZFS_PROP_ATIME), atime_changed_cb, zfsvfs);
 	error = error ? error : dsl_prop_register(ds,
 	    zfs_prop_to_name(ZFS_PROP_RELATIME), relatime_changed_cb, zfsvfs);
 	error = error ? error : dsl_prop_register(ds,
 	    zfs_prop_to_name(ZFS_PROP_XATTR), xattr_changed_cb, zfsvfs);
 	error = error ? error : dsl_prop_register(ds,
 	    zfs_prop_to_name(ZFS_PROP_RECORDSIZE), blksz_changed_cb, zfsvfs);
 	error = error ? error : dsl_prop_register(ds,
 	    zfs_prop_to_name(ZFS_PROP_READONLY), readonly_changed_cb, zfsvfs);
 	error = error ? error : dsl_prop_register(ds,
 	    zfs_prop_to_name(ZFS_PROP_DEVICES), devices_changed_cb, zfsvfs);
 	error = error ? error : dsl_prop_register(ds,
 	    zfs_prop_to_name(ZFS_PROP_SETUID), setuid_changed_cb, zfsvfs);
 	error = error ? error : dsl_prop_register(ds,
 	    zfs_prop_to_name(ZFS_PROP_EXEC), exec_changed_cb, zfsvfs);
 	error = error ? error : dsl_prop_register(ds,
 	    zfs_prop_to_name(ZFS_PROP_SNAPDIR), snapdir_changed_cb, zfsvfs);
 	error = error ? error : dsl_prop_register(ds,
 	    zfs_prop_to_name(ZFS_PROP_ACLTYPE), acltype_changed_cb, zfsvfs);
 	error = error ? error : dsl_prop_register(ds,
 	    zfs_prop_to_name(ZFS_PROP_ACLMODE), acl_mode_changed_cb, zfsvfs);
 	error = error ? error : dsl_prop_register(ds,
 	    zfs_prop_to_name(ZFS_PROP_ACLINHERIT), acl_inherit_changed_cb,
 	    zfsvfs);
 	error = error ? error : dsl_prop_register(ds,
 	    zfs_prop_to_name(ZFS_PROP_NBMAND), nbmand_changed_cb, zfsvfs);
 	error = error ? error : dsl_prop_register(ds,
 	    zfs_prop_to_name(ZFS_PROP_LONGNAME), longname_changed_cb, zfsvfs);
 	dsl_pool_config_exit(dmu_objset_pool(os), FTAG);
 	if (error)
 		goto unregister;
 
 	/*
 	 * Invoke our callbacks to restore temporary mount options.
 	 */
 	if (vfsp->vfs_do_readonly)
 		readonly_changed_cb(zfsvfs, vfsp->vfs_readonly);
 	if (vfsp->vfs_do_setuid)
 		setuid_changed_cb(zfsvfs, vfsp->vfs_setuid);
 	if (vfsp->vfs_do_exec)
 		exec_changed_cb(zfsvfs, vfsp->vfs_exec);
 	if (vfsp->vfs_do_devices)
 		devices_changed_cb(zfsvfs, vfsp->vfs_devices);
 	if (vfsp->vfs_do_xattr)
 		xattr_changed_cb(zfsvfs, vfsp->vfs_xattr);
 	if (vfsp->vfs_do_atime)
 		atime_changed_cb(zfsvfs, vfsp->vfs_atime);
 	if (vfsp->vfs_do_relatime)
 		relatime_changed_cb(zfsvfs, vfsp->vfs_relatime);
 	if (vfsp->vfs_do_nbmand)
 		nbmand_changed_cb(zfsvfs, vfsp->vfs_nbmand);
 
 	return (0);
 
 unregister:
 	dsl_prop_unregister_all(ds, zfsvfs);
 	return (error);
 }
 
 /*
  * Takes a dataset, a property, a value and that value's setpoint as
  * found in the ZAP. Checks if the property has been changed in the vfs.
  * If so, val and setpoint will be overwritten with updated content.
  * Otherwise, they are left unchanged.
  */
 int
 zfs_get_temporary_prop(dsl_dataset_t *ds, zfs_prop_t zfs_prop, uint64_t *val,
     char *setpoint)
 {
 	int error;
 	zfsvfs_t *zfvp;
 	vfs_t *vfsp;
 	objset_t *os;
 	uint64_t tmp = *val;
 
 	error = dmu_objset_from_ds(ds, &os);
 	if (error != 0)
 		return (error);
 
 	if (dmu_objset_type(os) != DMU_OST_ZFS)
 		return (EINVAL);
 
 	mutex_enter(&os->os_user_ptr_lock);
 	zfvp = dmu_objset_get_user(os);
 	mutex_exit(&os->os_user_ptr_lock);
 	if (zfvp == NULL)
 		return (ESRCH);
 
 	vfsp = zfvp->z_vfs;
 
 	switch (zfs_prop) {
 	case ZFS_PROP_ATIME:
 		if (vfsp->vfs_do_atime)
 			tmp = vfsp->vfs_atime;
 		break;
 	case ZFS_PROP_RELATIME:
 		if (vfsp->vfs_do_relatime)
 			tmp = vfsp->vfs_relatime;
 		break;
 	case ZFS_PROP_DEVICES:
 		if (vfsp->vfs_do_devices)
 			tmp = vfsp->vfs_devices;
 		break;
 	case ZFS_PROP_EXEC:
 		if (vfsp->vfs_do_exec)
 			tmp = vfsp->vfs_exec;
 		break;
 	case ZFS_PROP_SETUID:
 		if (vfsp->vfs_do_setuid)
 			tmp = vfsp->vfs_setuid;
 		break;
 	case ZFS_PROP_READONLY:
 		if (vfsp->vfs_do_readonly)
 			tmp = vfsp->vfs_readonly;
 		break;
 	case ZFS_PROP_XATTR:
 		if (vfsp->vfs_do_xattr)
 			tmp = vfsp->vfs_xattr;
 		break;
 	case ZFS_PROP_NBMAND:
 		if (vfsp->vfs_do_nbmand)
 			tmp = vfsp->vfs_nbmand;
 		break;
 	default:
 		return (ENOENT);
 	}
 
 	if (tmp != *val) {
 		if (setpoint)
 			(void) strcpy(setpoint, "temporary");
 		*val = tmp;
 	}
 	return (0);
 }
 
 /*
  * Associate this zfsvfs with the given objset, which must be owned.
  * This will cache a bunch of on-disk state from the objset in the
  * zfsvfs.
  */
 static int
 zfsvfs_init(zfsvfs_t *zfsvfs, objset_t *os)
 {
 	int error;
 	uint64_t val;
 
 	zfsvfs->z_max_blksz = SPA_OLD_MAXBLOCKSIZE;
 	zfsvfs->z_show_ctldir = ZFS_SNAPDIR_VISIBLE;
 	zfsvfs->z_os = os;
 
 	error = zfs_get_zplprop(os, ZFS_PROP_VERSION, &zfsvfs->z_version);
 	if (error != 0)
 		return (error);
 	if (zfsvfs->z_version >
 	    zfs_zpl_version_map(spa_version(dmu_objset_spa(os)))) {
 		(void) printk("Can't mount a version %lld file system "
 		    "on a version %lld pool\n. Pool must be upgraded to mount "
 		    "this file system.\n", (u_longlong_t)zfsvfs->z_version,
 		    (u_longlong_t)spa_version(dmu_objset_spa(os)));
 		return (SET_ERROR(ENOTSUP));
 	}
 	error = zfs_get_zplprop(os, ZFS_PROP_NORMALIZE, &val);
 	if (error != 0)
 		return (error);
 	zfsvfs->z_norm = (int)val;
 
 	error = zfs_get_zplprop(os, ZFS_PROP_UTF8ONLY, &val);
 	if (error != 0)
 		return (error);
 	zfsvfs->z_utf8 = (val != 0);
 
 	error = zfs_get_zplprop(os, ZFS_PROP_CASE, &val);
 	if (error != 0)
 		return (error);
 	zfsvfs->z_case = (uint_t)val;
 
 	if ((error = zfs_get_zplprop(os, ZFS_PROP_ACLTYPE, &val)) != 0)
 		return (error);
 	zfsvfs->z_acl_type = (uint_t)val;
 
 	/*
 	 * Fold case on file systems that are always or sometimes case
 	 * insensitive.
 	 */
 	if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE ||
 	    zfsvfs->z_case == ZFS_CASE_MIXED)
 		zfsvfs->z_norm |= U8_TEXTPREP_TOUPPER;
 
 	zfsvfs->z_use_fuids = USE_FUIDS(zfsvfs->z_version, zfsvfs->z_os);
 	zfsvfs->z_use_sa = USE_SA(zfsvfs->z_version, zfsvfs->z_os);
 
 	uint64_t sa_obj = 0;
 	if (zfsvfs->z_use_sa) {
 		/* should either have both of these objects or none */
 		error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_SA_ATTRS, 8, 1,
 		    &sa_obj);
 		if (error != 0)
 			return (error);
 
 		error = zfs_get_zplprop(os, ZFS_PROP_XATTR, &val);
 		if ((error == 0) && (val == ZFS_XATTR_SA))
 			zfsvfs->z_xattr_sa = B_TRUE;
 	}
 
 	error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_ROOT_OBJ, 8, 1,
 	    &zfsvfs->z_root);
 	if (error != 0)
 		return (error);
 	ASSERT(zfsvfs->z_root != 0);
 
 	error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_UNLINKED_SET, 8, 1,
 	    &zfsvfs->z_unlinkedobj);
 	if (error != 0)
 		return (error);
 
 	error = zap_lookup(os, MASTER_NODE_OBJ,
 	    zfs_userquota_prop_prefixes[ZFS_PROP_USERQUOTA],
 	    8, 1, &zfsvfs->z_userquota_obj);
 	if (error == ENOENT)
 		zfsvfs->z_userquota_obj = 0;
 	else if (error != 0)
 		return (error);
 
 	error = zap_lookup(os, MASTER_NODE_OBJ,
 	    zfs_userquota_prop_prefixes[ZFS_PROP_GROUPQUOTA],
 	    8, 1, &zfsvfs->z_groupquota_obj);
 	if (error == ENOENT)
 		zfsvfs->z_groupquota_obj = 0;
 	else if (error != 0)
 		return (error);
 
 	error = zap_lookup(os, MASTER_NODE_OBJ,
 	    zfs_userquota_prop_prefixes[ZFS_PROP_PROJECTQUOTA],
 	    8, 1, &zfsvfs->z_projectquota_obj);
 	if (error == ENOENT)
 		zfsvfs->z_projectquota_obj = 0;
 	else if (error != 0)
 		return (error);
 
 	error = zap_lookup(os, MASTER_NODE_OBJ,
 	    zfs_userquota_prop_prefixes[ZFS_PROP_USEROBJQUOTA],
 	    8, 1, &zfsvfs->z_userobjquota_obj);
 	if (error == ENOENT)
 		zfsvfs->z_userobjquota_obj = 0;
 	else if (error != 0)
 		return (error);
 
 	error = zap_lookup(os, MASTER_NODE_OBJ,
 	    zfs_userquota_prop_prefixes[ZFS_PROP_GROUPOBJQUOTA],
 	    8, 1, &zfsvfs->z_groupobjquota_obj);
 	if (error == ENOENT)
 		zfsvfs->z_groupobjquota_obj = 0;
 	else if (error != 0)
 		return (error);
 
 	error = zap_lookup(os, MASTER_NODE_OBJ,
 	    zfs_userquota_prop_prefixes[ZFS_PROP_PROJECTOBJQUOTA],
 	    8, 1, &zfsvfs->z_projectobjquota_obj);
 	if (error == ENOENT)
 		zfsvfs->z_projectobjquota_obj = 0;
 	else if (error != 0)
 		return (error);
 
 	error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_FUID_TABLES, 8, 1,
 	    &zfsvfs->z_fuid_obj);
 	if (error == ENOENT)
 		zfsvfs->z_fuid_obj = 0;
 	else if (error != 0)
 		return (error);
 
 	error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_SHARES_DIR, 8, 1,
 	    &zfsvfs->z_shares_dir);
 	if (error == ENOENT)
 		zfsvfs->z_shares_dir = 0;
 	else if (error != 0)
 		return (error);
 
 	error = sa_setup(os, sa_obj, zfs_attr_table, ZPL_END,
 	    &zfsvfs->z_attr_table);
 	if (error != 0)
 		return (error);
 
 	if (zfsvfs->z_version >= ZPL_VERSION_SA)
 		sa_register_update_callback(os, zfs_sa_upgrade);
 
 	return (0);
 }
 
 int
 zfsvfs_create(const char *osname, boolean_t readonly, zfsvfs_t **zfvp)
 {
 	objset_t *os;
 	zfsvfs_t *zfsvfs;
 	int error;
 	boolean_t ro = (readonly || (strchr(osname, '@') != NULL));
 
 	zfsvfs = kmem_zalloc(sizeof (zfsvfs_t), KM_SLEEP);
 
 	error = dmu_objset_own(osname, DMU_OST_ZFS, ro, B_TRUE, zfsvfs, &os);
 	if (error != 0) {
 		kmem_free(zfsvfs, sizeof (zfsvfs_t));
 		return (error);
 	}
 
 	error = zfsvfs_create_impl(zfvp, zfsvfs, os);
 
 	return (error);
 }
 
 
 /*
  * Note: zfsvfs is assumed to be malloc'd, and will be freed by this function
  * on a failure.  Do not pass in a statically allocated zfsvfs.
  */
 int
 zfsvfs_create_impl(zfsvfs_t **zfvp, zfsvfs_t *zfsvfs, objset_t *os)
 {
 	int error;
 
 	zfsvfs->z_vfs = NULL;
 	zfsvfs->z_sb = NULL;
 	zfsvfs->z_parent = zfsvfs;
 
 	mutex_init(&zfsvfs->z_znodes_lock, NULL, MUTEX_DEFAULT, NULL);
 	mutex_init(&zfsvfs->z_lock, NULL, MUTEX_DEFAULT, NULL);
 	list_create(&zfsvfs->z_all_znodes, sizeof (znode_t),
 	    offsetof(znode_t, z_link_node));
 	ZFS_TEARDOWN_INIT(zfsvfs);
 	rw_init(&zfsvfs->z_teardown_inactive_lock, NULL, RW_DEFAULT, NULL);
 	rw_init(&zfsvfs->z_fuid_lock, NULL, RW_DEFAULT, NULL);
 
 	int 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 (int 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);
 	}
 
 	error = zfsvfs_init(zfsvfs, os);
 	if (error != 0) {
 		dmu_objset_disown(os, B_TRUE, zfsvfs);
 		*zfvp = NULL;
 		zfsvfs_free(zfsvfs);
 		return (error);
 	}
 
 	zfsvfs->z_drain_task = TASKQID_INVALID;
 	zfsvfs->z_draining = B_FALSE;
 	zfsvfs->z_drain_cancel = B_TRUE;
 
 	*zfvp = zfsvfs;
 	return (0);
 }
 
 static int
 zfsvfs_setup(zfsvfs_t *zfsvfs, boolean_t mounting)
 {
 	int error;
 	boolean_t readonly = zfs_is_readonly(zfsvfs);
 
 	error = zfs_register_callbacks(zfsvfs->z_vfs);
 	if (error)
 		return (error);
 
 	/*
 	 * If we are not mounting (ie: online recv), then we don't
 	 * have to worry about replaying the log as we blocked all
 	 * operations out since we closed the ZIL.
 	 */
 	if (mounting) {
 		ASSERT3P(zfsvfs->z_kstat.dk_kstats, ==, NULL);
 		error = dataset_kstats_create(&zfsvfs->z_kstat, zfsvfs->z_os);
 		if (error)
 			return (error);
 		zfsvfs->z_log = zil_open(zfsvfs->z_os, zfs_get_data,
 		    &zfsvfs->z_kstat.dk_zil_sums);
 
 		/*
 		 * During replay we remove the read only flag to
 		 * allow replays to succeed.
 		 */
 		if (readonly != 0) {
 			readonly_changed_cb(zfsvfs, B_FALSE);
 		} else {
 			zap_stats_t zs;
 			if (zap_get_stats(zfsvfs->z_os, zfsvfs->z_unlinkedobj,
 			    &zs) == 0) {
 				dataset_kstats_update_nunlinks_kstat(
 				    &zfsvfs->z_kstat, zs.zs_num_entries);
 				dprintf_ds(zfsvfs->z_os->os_dsl_dataset,
 				    "num_entries in unlinked set: %llu",
 				    zs.zs_num_entries);
 			}
 			zfs_unlinked_drain(zfsvfs);
 			dsl_dir_t *dd = zfsvfs->z_os->os_dsl_dataset->ds_dir;
 			dd->dd_activity_cancelled = B_FALSE;
 		}
 
 		/*
 		 * Parse and replay the intent log.
 		 *
 		 * Because of ziltest, this must be done after
 		 * zfs_unlinked_drain().  (Further note: ziltest
 		 * doesn't use readonly mounts, where
 		 * zfs_unlinked_drain() isn't called.)  This is because
 		 * ziltest causes spa_sync() to think it's committed,
 		 * but actually it is not, so the intent log contains
 		 * many txg's worth of changes.
 		 *
 		 * In particular, if object N is in the unlinked set in
 		 * the last txg to actually sync, then it could be
 		 * actually freed in a later txg and then reallocated
 		 * in a yet later txg.  This would write a "create
 		 * object N" record to the intent log.  Normally, this
 		 * would be fine because the spa_sync() would have
 		 * written out the fact that object N is free, before
 		 * we could write the "create object N" intent log
 		 * record.
 		 *
 		 * But when we are in ziltest mode, we advance the "open
 		 * txg" without actually spa_sync()-ing the changes to
 		 * disk.  So we would see that object N is still
 		 * allocated and in the unlinked set, and there is an
 		 * intent log record saying to allocate it.
 		 */
 		if (spa_writeable(dmu_objset_spa(zfsvfs->z_os))) {
 			if (zil_replay_disable) {
 				zil_destroy(zfsvfs->z_log, B_FALSE);
 			} else {
 				zfsvfs->z_replay = B_TRUE;
 				zil_replay(zfsvfs->z_os, zfsvfs,
 				    zfs_replay_vector);
 				zfsvfs->z_replay = B_FALSE;
 			}
 		}
 
 		/* restore readonly bit */
 		if (readonly != 0)
 			readonly_changed_cb(zfsvfs, B_TRUE);
 	} else {
 		ASSERT3P(zfsvfs->z_kstat.dk_kstats, !=, NULL);
 		zfsvfs->z_log = zil_open(zfsvfs->z_os, zfs_get_data,
 		    &zfsvfs->z_kstat.dk_zil_sums);
 	}
 
 	/*
 	 * Set the objset user_ptr to track its zfsvfs.
 	 */
 	mutex_enter(&zfsvfs->z_os->os_user_ptr_lock);
 	dmu_objset_set_user(zfsvfs->z_os, zfsvfs);
 	mutex_exit(&zfsvfs->z_os->os_user_ptr_lock);
 
 	return (0);
 }
 
 void
 zfsvfs_free(zfsvfs_t *zfsvfs)
 {
 	int i, size = zfsvfs->z_hold_size;
 
 	zfs_fuid_destroy(zfsvfs);
 
 	mutex_destroy(&zfsvfs->z_znodes_lock);
 	mutex_destroy(&zfsvfs->z_lock);
 	list_destroy(&zfsvfs->z_all_znodes);
 	ZFS_TEARDOWN_DESTROY(zfsvfs);
 	rw_destroy(&zfsvfs->z_teardown_inactive_lock);
 	rw_destroy(&zfsvfs->z_fuid_lock);
 	for (i = 0; i != size; i++) {
 		avl_destroy(&zfsvfs->z_hold_trees[i]);
 		mutex_destroy(&zfsvfs->z_hold_locks[i]);
 	}
 	vmem_free(zfsvfs->z_hold_trees, sizeof (avl_tree_t) * size);
 	vmem_free(zfsvfs->z_hold_locks, sizeof (kmutex_t) * size);
 	zfsvfs_vfs_free(zfsvfs->z_vfs);
 	dataset_kstats_destroy(&zfsvfs->z_kstat);
 	kmem_free(zfsvfs, sizeof (zfsvfs_t));
 }
 
 static void
 zfs_set_fuid_feature(zfsvfs_t *zfsvfs)
 {
 	zfsvfs->z_use_fuids = USE_FUIDS(zfsvfs->z_version, zfsvfs->z_os);
 	zfsvfs->z_use_sa = USE_SA(zfsvfs->z_version, zfsvfs->z_os);
 }
 
 static void
 zfs_unregister_callbacks(zfsvfs_t *zfsvfs)
 {
 	objset_t *os = zfsvfs->z_os;
 
 	if (!dmu_objset_is_snapshot(os))
 		dsl_prop_unregister_all(dmu_objset_ds(os), zfsvfs);
 }
 
 #ifdef HAVE_MLSLABEL
 /*
  * Check that the hex label string is appropriate for the dataset being
  * mounted into the global_zone proper.
  *
  * Return an error if the hex label string is not default or
  * admin_low/admin_high.  For admin_low labels, the corresponding
  * dataset must be readonly.
  */
 int
 zfs_check_global_label(const char *dsname, const char *hexsl)
 {
 	if (strcasecmp(hexsl, ZFS_MLSLABEL_DEFAULT) == 0)
 		return (0);
 	if (strcasecmp(hexsl, ADMIN_HIGH) == 0)
 		return (0);
 	if (strcasecmp(hexsl, ADMIN_LOW) == 0) {
 		/* must be readonly */
 		uint64_t rdonly;
 
 		if (dsl_prop_get_integer(dsname,
 		    zfs_prop_to_name(ZFS_PROP_READONLY), &rdonly, NULL))
 			return (SET_ERROR(EACCES));
 		return (rdonly ? 0 : SET_ERROR(EACCES));
 	}
 	return (SET_ERROR(EACCES));
 }
 #endif /* HAVE_MLSLABEL */
 
 static int
 zfs_statfs_project(zfsvfs_t *zfsvfs, znode_t *zp, struct kstatfs *statp,
     uint32_t bshift)
 {
 	char buf[20 + DMU_OBJACCT_PREFIX_LEN];
 	uint64_t offset = DMU_OBJACCT_PREFIX_LEN;
 	uint64_t quota;
 	uint64_t used;
 	int err;
 
 	strlcpy(buf, DMU_OBJACCT_PREFIX, DMU_OBJACCT_PREFIX_LEN + 1);
 	err = zfs_id_to_fuidstr(zfsvfs, NULL, zp->z_projid, buf + offset,
 	    sizeof (buf) - offset, B_FALSE);
 	if (err)
 		return (err);
 
 	if (zfsvfs->z_projectquota_obj == 0)
 		goto objs;
 
 	err = zap_lookup(zfsvfs->z_os, zfsvfs->z_projectquota_obj,
 	    buf + offset, 8, 1, &quota);
 	if (err == ENOENT)
 		goto objs;
 	else if (err)
 		return (err);
 
 	err = zap_lookup(zfsvfs->z_os, DMU_PROJECTUSED_OBJECT,
 	    buf + offset, 8, 1, &used);
 	if (unlikely(err == ENOENT)) {
 		uint32_t blksize;
 		u_longlong_t nblocks;
 
 		/*
 		 * Quota accounting is async, so it is possible race case.
 		 * There is at least one object with the given project ID.
 		 */
 		sa_object_size(zp->z_sa_hdl, &blksize, &nblocks);
 		if (unlikely(zp->z_blksz == 0))
 			blksize = zfsvfs->z_max_blksz;
 
 		used = blksize * nblocks;
 	} else if (err) {
 		return (err);
 	}
 
 	statp->f_blocks = quota >> bshift;
 	statp->f_bfree = (quota > used) ? ((quota - used) >> bshift) : 0;
 	statp->f_bavail = statp->f_bfree;
 
 objs:
 	if (zfsvfs->z_projectobjquota_obj == 0)
 		return (0);
 
 	err = zap_lookup(zfsvfs->z_os, zfsvfs->z_projectobjquota_obj,
 	    buf + offset, 8, 1, &quota);
 	if (err == ENOENT)
 		return (0);
 	else if (err)
 		return (err);
 
 	err = zap_lookup(zfsvfs->z_os, DMU_PROJECTUSED_OBJECT,
 	    buf, 8, 1, &used);
 	if (unlikely(err == ENOENT)) {
 		/*
 		 * Quota accounting is async, so it is possible race case.
 		 * There is at least one object with the given project ID.
 		 */
 		used = 1;
 	} else if (err) {
 		return (err);
 	}
 
 	statp->f_files = quota;
 	statp->f_ffree = (quota > used) ? (quota - used) : 0;
 
 	return (0);
 }
 
 int
 zfs_statvfs(struct inode *ip, struct kstatfs *statp)
 {
 	zfsvfs_t *zfsvfs = ITOZSB(ip);
 	uint64_t refdbytes, availbytes, usedobjs, availobjs;
 	int err = 0;
 
 	if ((err = zfs_enter(zfsvfs, FTAG)) != 0)
 		return (err);
 
 	dmu_objset_space(zfsvfs->z_os,
 	    &refdbytes, &availbytes, &usedobjs, &availobjs);
 
 	uint64_t fsid = dmu_objset_fsid_guid(zfsvfs->z_os);
 	/*
 	 * The underlying storage pool actually uses multiple block
 	 * size.  Under Solaris frsize (fragment size) is reported as
 	 * the smallest block size we support, and bsize (block size)
 	 * as the filesystem's maximum block size.  Unfortunately,
 	 * under Linux the fragment size and block size are often used
 	 * interchangeably.  Thus we are forced to report both of them
 	 * as the filesystem's maximum block size.
 	 */
 	statp->f_frsize = zfsvfs->z_max_blksz;
 	statp->f_bsize = zfsvfs->z_max_blksz;
 	uint32_t bshift = fls(statp->f_bsize) - 1;
 
 	/*
 	 * The following report "total" blocks of various kinds in
 	 * the file system, but reported in terms of f_bsize - the
 	 * "preferred" size.
 	 */
 
 	/* Round up so we never have a filesystem using 0 blocks. */
 	refdbytes = P2ROUNDUP(refdbytes, statp->f_bsize);
 	statp->f_blocks = (refdbytes + availbytes) >> bshift;
 	statp->f_bfree = availbytes >> bshift;
 	statp->f_bavail = statp->f_bfree; /* no root reservation */
 
 	/*
 	 * statvfs() should really be called statufs(), because it assumes
 	 * static metadata.  ZFS doesn't preallocate files, so the best
 	 * we can do is report the max that could possibly fit in f_files,
 	 * and that minus the number actually used in f_ffree.
 	 * For f_ffree, report the smaller of the number of objects available
 	 * and the number of blocks (each object will take at least a block).
 	 */
 	statp->f_ffree = MIN(availobjs, availbytes >> DNODE_SHIFT);
 	statp->f_files = statp->f_ffree + usedobjs;
 	statp->f_fsid.val[0] = (uint32_t)fsid;
 	statp->f_fsid.val[1] = (uint32_t)(fsid >> 32);
 	statp->f_type = ZFS_SUPER_MAGIC;
 	statp->f_namelen =
 	    zfsvfs->z_longname ? (ZAP_MAXNAMELEN_NEW - 1) : (MAXNAMELEN - 1);
 
 	/*
 	 * We have all of 40 characters to stuff a string here.
 	 * Is there anything useful we could/should provide?
 	 */
 	memset(statp->f_spare, 0, sizeof (statp->f_spare));
 
 	if (dmu_objset_projectquota_enabled(zfsvfs->z_os) &&
 	    dmu_objset_projectquota_present(zfsvfs->z_os)) {
 		znode_t *zp = ITOZ(ip);
 
 		if (zp->z_pflags & ZFS_PROJINHERIT && zp->z_projid &&
 		    zpl_is_valid_projid(zp->z_projid))
 			err = zfs_statfs_project(zfsvfs, zp, statp, bshift);
 	}
 
 	zfs_exit(zfsvfs, FTAG);
 	return (err);
 }
 
 static int
 zfs_root(zfsvfs_t *zfsvfs, struct inode **ipp)
 {
 	znode_t *rootzp;
 	int error;
 
 	if ((error = zfs_enter(zfsvfs, FTAG)) != 0)
 		return (error);
 
 	error = zfs_zget(zfsvfs, zfsvfs->z_root, &rootzp);
 	if (error == 0)
 		*ipp = ZTOI(rootzp);
 
 	zfs_exit(zfsvfs, FTAG);
 	return (error);
 }
 
 /*
  * The ARC has requested that the filesystem drop entries from the dentry
  * and inode caches.  This can occur when the ARC needs to free meta data
  * blocks but can't because they are all pinned by entries in these caches.
  */
 #if defined(HAVE_SUPER_BLOCK_S_SHRINK)
 #define	S_SHRINK(sb)	(&(sb)->s_shrink)
 #elif defined(HAVE_SUPER_BLOCK_S_SHRINK_PTR)
 #define	S_SHRINK(sb)	((sb)->s_shrink)
 #endif
 
 int
 zfs_prune(struct super_block *sb, unsigned long nr_to_scan, int *objects)
 {
 	zfsvfs_t *zfsvfs = sb->s_fs_info;
 	int error = 0;
 	struct shrinker *shrinker = S_SHRINK(sb);
 	struct shrink_control sc = {
 		.nr_to_scan = nr_to_scan,
 		.gfp_mask = GFP_KERNEL,
 	};
 
 	if ((error = zfs_enter(zfsvfs, FTAG)) != 0)
 		return (error);
 
 #ifdef SHRINKER_NUMA_AWARE
 	if (shrinker->flags & SHRINKER_NUMA_AWARE) {
 		long tc = 1;
 		for_each_online_node(sc.nid) {
 			long c = shrinker->count_objects(shrinker, &sc);
 			if (c  == 0 || c == SHRINK_EMPTY)
 				continue;
 			tc += c;
 		}
 		*objects = 0;
 		for_each_online_node(sc.nid) {
 			long c = shrinker->count_objects(shrinker, &sc);
 			if (c  == 0 || c == SHRINK_EMPTY)
 				continue;
 			if (c > tc)
 				tc = c;
 			sc.nr_to_scan = mult_frac(nr_to_scan, c, tc) + 1;
 			*objects += (*shrinker->scan_objects)(shrinker, &sc);
 		}
 	} else {
 			*objects = (*shrinker->scan_objects)(shrinker, &sc);
 	}
 #else
 	*objects = (*shrinker->scan_objects)(shrinker, &sc);
 #endif
 
 	zfs_exit(zfsvfs, FTAG);
 
 	dprintf_ds(zfsvfs->z_os->os_dsl_dataset,
 	    "pruning, nr_to_scan=%lu objects=%d error=%d\n",
 	    nr_to_scan, *objects, error);
 
 	return (error);
 }
 
 /*
  * Teardown the zfsvfs_t.
  *
  * Note, if 'unmounting' is FALSE, we return with the 'z_teardown_lock'
  * and 'z_teardown_inactive_lock' held.
  */
 static int
 zfsvfs_teardown(zfsvfs_t *zfsvfs, boolean_t unmounting)
 {
 	znode_t	*zp;
 
 	zfs_unlinked_drain_stop_wait(zfsvfs);
 
 	/*
 	 * If someone has not already unmounted this file system,
 	 * drain the zrele_taskq to ensure all active references to the
 	 * zfsvfs_t have been handled only then can it be safely destroyed.
 	 */
 	if (zfsvfs->z_os) {
 		/*
 		 * If we're unmounting we have to wait for the list to
 		 * drain completely.
 		 *
 		 * If we're not unmounting there's no guarantee the list
 		 * will drain completely, but iputs run from the taskq
 		 * may add the parents of dir-based xattrs to the taskq
 		 * so we want to wait for these.
 		 *
 		 * We can safely check z_all_znodes for being empty because the
 		 * VFS has already blocked operations which add to it.
 		 */
 		int round = 0;
 		while (!list_is_empty(&zfsvfs->z_all_znodes)) {
 			taskq_wait_outstanding(dsl_pool_zrele_taskq(
 			    dmu_objset_pool(zfsvfs->z_os)), 0);
 			if (++round > 1 && !unmounting)
 				break;
 		}
 	}
 
 	ZFS_TEARDOWN_ENTER_WRITE(zfsvfs, FTAG);
 
 	if (!unmounting) {
 		/*
 		 * We purge the parent filesystem's super block as the
 		 * parent filesystem and all of its snapshots have their
 		 * inode's super block set to the parent's filesystem's
 		 * super block.  Note,  'z_parent' is self referential
 		 * for non-snapshots.
 		 */
 		shrink_dcache_sb(zfsvfs->z_parent->z_sb);
 	}
 
 	/*
 	 * Close the zil. NB: Can't close the zil while zfs_inactive
 	 * threads are blocked as zil_close can call zfs_inactive.
 	 */
 	if (zfsvfs->z_log) {
 		zil_close(zfsvfs->z_log);
 		zfsvfs->z_log = NULL;
 	}
 
 	rw_enter(&zfsvfs->z_teardown_inactive_lock, RW_WRITER);
 
 	/*
 	 * If we are not unmounting (ie: online recv) and someone already
 	 * unmounted this file system while we were doing the switcheroo,
 	 * or a reopen of z_os failed then just bail out now.
 	 */
 	if (!unmounting && (zfsvfs->z_unmounted || zfsvfs->z_os == NULL)) {
 		rw_exit(&zfsvfs->z_teardown_inactive_lock);
 		ZFS_TEARDOWN_EXIT(zfsvfs, FTAG);
 		return (SET_ERROR(EIO));
 	}
 
 	/*
 	 * At this point there are no VFS ops active, and any new VFS ops
 	 * will fail with EIO since we have z_teardown_lock for writer (only
 	 * relevant for forced unmount).
 	 *
 	 * Release all holds on dbufs. We also grab an extra reference to all
 	 * the remaining inodes so that the kernel does not attempt to free
 	 * any inodes of a suspended fs. This can cause deadlocks since the
 	 * zfs_resume_fs() process may involve starting threads, which might
 	 * attempt to free unreferenced inodes to free up memory for the new
 	 * thread.
 	 */
 	if (!unmounting) {
 		mutex_enter(&zfsvfs->z_znodes_lock);
 		for (zp = list_head(&zfsvfs->z_all_znodes); zp != NULL;
 		    zp = list_next(&zfsvfs->z_all_znodes, zp)) {
 			if (zp->z_sa_hdl)
 				zfs_znode_dmu_fini(zp);
 			if (igrab(ZTOI(zp)) != NULL)
 				zp->z_suspended = B_TRUE;
 
 		}
 		mutex_exit(&zfsvfs->z_znodes_lock);
 	}
 
 	/*
 	 * If we are unmounting, set the unmounted flag and let new VFS ops
 	 * unblock.  zfs_inactive will have the unmounted behavior, and all
 	 * other VFS ops will fail with EIO.
 	 */
 	if (unmounting) {
 		zfsvfs->z_unmounted = B_TRUE;
 		rw_exit(&zfsvfs->z_teardown_inactive_lock);
 		ZFS_TEARDOWN_EXIT(zfsvfs, FTAG);
 	}
 
 	/*
 	 * z_os will be NULL if there was an error in attempting to reopen
 	 * zfsvfs, so just return as the properties had already been
 	 *
 	 * unregistered and cached data had been evicted before.
 	 */
 	if (zfsvfs->z_os == NULL)
 		return (0);
 
 	/*
 	 * Unregister properties.
 	 */
 	zfs_unregister_callbacks(zfsvfs);
 
 	/*
 	 * Evict cached data. We must write out any dirty data before
 	 * disowning the dataset.
 	 */
 	objset_t *os = zfsvfs->z_os;
 	boolean_t os_dirty = B_FALSE;
 	for (int t = 0; t < TXG_SIZE; t++) {
 		if (dmu_objset_is_dirty(os, t)) {
 			os_dirty = B_TRUE;
 			break;
 		}
 	}
 	if (!zfs_is_readonly(zfsvfs) && os_dirty) {
 		txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0);
 	}
 	dmu_objset_evict_dbufs(zfsvfs->z_os);
 	dsl_dir_t *dd = os->os_dsl_dataset->ds_dir;
 	dsl_dir_cancel_waiters(dd);
 
 	return (0);
 }
 
 static atomic_long_t zfs_bdi_seq = ATOMIC_LONG_INIT(0);
 
 int
 zfs_domount(struct super_block *sb, zfs_mnt_t *zm, int silent)
 {
 	const char *osname = zm->mnt_osname;
 	struct inode *root_inode = NULL;
 	uint64_t recordsize;
 	int error = 0;
 	zfsvfs_t *zfsvfs = NULL;
 	vfs_t *vfs = NULL;
 	int canwrite;
 	int dataset_visible_zone;
 
 	ASSERT(zm);
 	ASSERT(osname);
 
 	dataset_visible_zone = zone_dataset_visible(osname, &canwrite);
 
 	/*
 	 * Refuse to mount a filesystem if we are in a namespace and the
 	 * dataset is not visible or writable in that namespace.
 	 */
 	if (!INGLOBALZONE(curproc) &&
 	    (!dataset_visible_zone || !canwrite)) {
 		return (SET_ERROR(EPERM));
 	}
 
 	error = zfsvfs_parse_options(zm->mnt_data, &vfs);
 	if (error)
 		return (error);
 
 	/*
 	 * If a non-writable filesystem is being mounted without the
 	 * read-only flag, pretend it was set, as done for snapshots.
 	 */
 	if (!canwrite)
 		vfs->vfs_readonly = B_TRUE;
 
 	error = zfsvfs_create(osname, vfs->vfs_readonly, &zfsvfs);
 	if (error) {
 		zfsvfs_vfs_free(vfs);
 		goto out;
 	}
 
 	if ((error = dsl_prop_get_integer(osname, "recordsize",
 	    &recordsize, NULL))) {
 		zfsvfs_vfs_free(vfs);
 		goto out;
 	}
 
 	vfs->vfs_data = zfsvfs;
 	zfsvfs->z_vfs = vfs;
 	zfsvfs->z_sb = sb;
 	sb->s_fs_info = zfsvfs;
 	sb->s_magic = ZFS_SUPER_MAGIC;
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 	sb->s_time_gran = 1;
 	sb->s_blocksize = recordsize;
 	sb->s_blocksize_bits = ilog2(recordsize);
 
 	error = -super_setup_bdi_name(sb, "%.28s-%ld", "zfs",
 	    atomic_long_inc_return(&zfs_bdi_seq));
 	if (error)
 		goto out;
 
 	sb->s_bdi->ra_pages = 0;
 
 	/* Set callback operations for the file system. */
 	sb->s_op = &zpl_super_operations;
 	sb->s_xattr = zpl_xattr_handlers;
 	sb->s_export_op = &zpl_export_operations;
 
 	/* Set features for file system. */
 	zfs_set_fuid_feature(zfsvfs);
 
 	if (dmu_objset_is_snapshot(zfsvfs->z_os)) {
 		uint64_t pval;
 
 		atime_changed_cb(zfsvfs, B_FALSE);
 		readonly_changed_cb(zfsvfs, B_TRUE);
 		if ((error = dsl_prop_get_integer(osname,
 		    "xattr", &pval, NULL)))
 			goto out;
 		xattr_changed_cb(zfsvfs, pval);
 		if ((error = dsl_prop_get_integer(osname,
 		    "acltype", &pval, NULL)))
 			goto out;
 		acltype_changed_cb(zfsvfs, pval);
 		zfsvfs->z_issnap = B_TRUE;
 		zfsvfs->z_os->os_sync = ZFS_SYNC_DISABLED;
 		zfsvfs->z_snap_defer_time = jiffies;
 
 		mutex_enter(&zfsvfs->z_os->os_user_ptr_lock);
 		dmu_objset_set_user(zfsvfs->z_os, zfsvfs);
 		mutex_exit(&zfsvfs->z_os->os_user_ptr_lock);
 	} else {
 		if ((error = zfsvfs_setup(zfsvfs, B_TRUE)))
 			goto out;
 	}
 
 	/* Allocate a root inode for the filesystem. */
 	error = zfs_root(zfsvfs, &root_inode);
 	if (error) {
 		(void) zfs_umount(sb);
 		zfsvfs = NULL; /* avoid double-free; first in zfs_umount */
 		goto out;
 	}
 
 	/* Allocate a root dentry for the filesystem */
 	sb->s_root = d_make_root(root_inode);
 	if (sb->s_root == NULL) {
 		(void) zfs_umount(sb);
 		zfsvfs = NULL; /* avoid double-free; first in zfs_umount */
 		error = SET_ERROR(ENOMEM);
 		goto out;
 	}
 
 	if (!zfsvfs->z_issnap)
 		zfsctl_create(zfsvfs);
 
 	zfsvfs->z_arc_prune = arc_add_prune_callback(zpl_prune_sb, sb);
 out:
 	if (error) {
 		if (zfsvfs != NULL) {
 			dmu_objset_disown(zfsvfs->z_os, B_TRUE, zfsvfs);
 			zfsvfs_free(zfsvfs);
 		}
 		/*
 		 * make sure we don't have dangling sb->s_fs_info which
 		 * zfs_preumount will use.
 		 */
 		sb->s_fs_info = NULL;
 	}
 
 	return (error);
 }
 
 /*
  * Called when an unmount is requested and certain sanity checks have
  * already passed.  At this point no dentries or inodes have been reclaimed
  * from their respective caches.  We drop the extra reference on the .zfs
  * control directory to allow everything to be reclaimed.  All snapshots
  * must already have been unmounted to reach this point.
  */
 void
 zfs_preumount(struct super_block *sb)
 {
 	zfsvfs_t *zfsvfs = sb->s_fs_info;
 
 	/* zfsvfs is NULL when zfs_domount fails during mount */
 	if (zfsvfs) {
 		zfs_unlinked_drain_stop_wait(zfsvfs);
 		zfsctl_destroy(sb->s_fs_info);
 		/*
 		 * Wait for zrele_async before entering evict_inodes in
 		 * generic_shutdown_super. The reason we must finish before
 		 * evict_inodes is when lazytime is on, or when zfs_purgedir
 		 * calls zfs_zget, zrele would bump i_count from 0 to 1. This
 		 * would race with the i_count check in evict_inodes. This means
 		 * it could destroy the inode while we are still using it.
 		 *
 		 * We wait for two passes. xattr directories in the first pass
 		 * may add xattr entries in zfs_purgedir, so in the second pass
 		 * we wait for them. We don't use taskq_wait here because it is
 		 * a pool wide taskq. Other mounted filesystems can constantly
 		 * do zrele_async and there's no guarantee when taskq will be
 		 * empty.
 		 */
 		taskq_wait_outstanding(dsl_pool_zrele_taskq(
 		    dmu_objset_pool(zfsvfs->z_os)), 0);
 		taskq_wait_outstanding(dsl_pool_zrele_taskq(
 		    dmu_objset_pool(zfsvfs->z_os)), 0);
 	}
 }
 
 /*
  * Called once all other unmount released tear down has occurred.
  * It is our responsibility to release any remaining infrastructure.
  */
 int
 zfs_umount(struct super_block *sb)
 {
 	zfsvfs_t *zfsvfs = sb->s_fs_info;
 	objset_t *os;
 
 	if (zfsvfs->z_arc_prune != NULL)
 		arc_remove_prune_callback(zfsvfs->z_arc_prune);
 	VERIFY(zfsvfs_teardown(zfsvfs, B_TRUE) == 0);
 	os = zfsvfs->z_os;
 
 	/*
 	 * z_os will be NULL if there was an error in
 	 * attempting to reopen zfsvfs.
 	 */
 	if (os != NULL) {
 		/*
 		 * Unset the objset user_ptr.
 		 */
 		mutex_enter(&os->os_user_ptr_lock);
 		dmu_objset_set_user(os, NULL);
 		mutex_exit(&os->os_user_ptr_lock);
 
 		/*
 		 * Finally release the objset
 		 */
 		dmu_objset_disown(os, B_TRUE, zfsvfs);
 	}
 
 	zfsvfs_free(zfsvfs);
 	sb->s_fs_info = NULL;
 	return (0);
 }
 
 int
 zfs_remount(struct super_block *sb, int *flags, zfs_mnt_t *zm)
 {
 	zfsvfs_t *zfsvfs = sb->s_fs_info;
 	vfs_t *vfsp;
 	boolean_t issnap = dmu_objset_is_snapshot(zfsvfs->z_os);
 	int error;
 
 	if ((issnap || !spa_writeable(dmu_objset_spa(zfsvfs->z_os))) &&
 	    !(*flags & SB_RDONLY)) {
 		*flags |= SB_RDONLY;
 		return (EROFS);
 	}
 
 	error = zfsvfs_parse_options(zm->mnt_data, &vfsp);
 	if (error)
 		return (error);
 
 	if (!zfs_is_readonly(zfsvfs) && (*flags & SB_RDONLY))
 		txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0);
 
 	zfs_unregister_callbacks(zfsvfs);
 	zfsvfs_vfs_free(zfsvfs->z_vfs);
 
 	vfsp->vfs_data = zfsvfs;
 	zfsvfs->z_vfs = vfsp;
 	if (!issnap)
 		(void) zfs_register_callbacks(vfsp);
 
 	return (error);
 }
 
 int
 zfs_vget(struct super_block *sb, struct inode **ipp, fid_t *fidp)
 {
 	zfsvfs_t	*zfsvfs = sb->s_fs_info;
 	znode_t		*zp;
 	uint64_t	object = 0;
 	uint64_t	fid_gen = 0;
 	uint64_t	gen_mask;
 	uint64_t	zp_gen;
 	int		i, err;
 
 	*ipp = NULL;
 
 	if (fidp->fid_len == SHORT_FID_LEN || fidp->fid_len == LONG_FID_LEN) {
 		zfid_short_t	*zfid = (zfid_short_t *)fidp;
 
 		for (i = 0; i < sizeof (zfid->zf_object); i++)
 			object |= ((uint64_t)zfid->zf_object[i]) << (8 * i);
 
 		for (i = 0; i < sizeof (zfid->zf_gen); i++)
 			fid_gen |= ((uint64_t)zfid->zf_gen[i]) << (8 * i);
 	} else {
 		return (SET_ERROR(EINVAL));
 	}
 
 	/* LONG_FID_LEN means snapdirs */
 	if (fidp->fid_len == LONG_FID_LEN) {
 		zfid_long_t	*zlfid = (zfid_long_t *)fidp;
 		uint64_t	objsetid = 0;
 		uint64_t	setgen = 0;
 
 		for (i = 0; i < sizeof (zlfid->zf_setid); i++)
 			objsetid |= ((uint64_t)zlfid->zf_setid[i]) << (8 * i);
 
 		for (i = 0; i < sizeof (zlfid->zf_setgen); i++)
 			setgen |= ((uint64_t)zlfid->zf_setgen[i]) << (8 * i);
 
 		if (objsetid != ZFSCTL_INO_SNAPDIRS - object) {
 			dprintf("snapdir fid: objsetid (%llu) != "
 			    "ZFSCTL_INO_SNAPDIRS (%llu) - object (%llu)\n",
 			    objsetid, ZFSCTL_INO_SNAPDIRS, object);
 
 			return (SET_ERROR(EINVAL));
 		}
 
 		if (fid_gen > 1 || setgen != 0) {
 			dprintf("snapdir fid: fid_gen (%llu) and setgen "
 			    "(%llu)\n", fid_gen, setgen);
 			return (SET_ERROR(EINVAL));
 		}
 
 		return (zfsctl_snapdir_vget(sb, objsetid, fid_gen, ipp));
 	}
 
 	if ((err = zfs_enter(zfsvfs, FTAG)) != 0)
 		return (err);
 	/* A zero fid_gen means we are in the .zfs control directories */
 	if (fid_gen == 0 &&
 	    (object == ZFSCTL_INO_ROOT || object == ZFSCTL_INO_SNAPDIR)) {
 		*ipp = zfsvfs->z_ctldir;
 		ASSERT(*ipp != NULL);
 
 		if (zfsvfs->z_show_ctldir == ZFS_SNAPDIR_DISABLED) {
 			return (SET_ERROR(ENOENT));
 		}
 
 		if (object == ZFSCTL_INO_SNAPDIR) {
 			VERIFY(zfsctl_root_lookup(*ipp, "snapshot", ipp,
 			    0, kcred, NULL, NULL) == 0);
 		} else {
 			/*
 			 * Must have an existing ref, so igrab()
 			 * cannot return NULL
 			 */
 			VERIFY3P(igrab(*ipp), !=, NULL);
 		}
 		zfs_exit(zfsvfs, FTAG);
 		return (0);
 	}
 
 	gen_mask = -1ULL >> (64 - 8 * i);
 
 	dprintf("getting %llu [%llu mask %llx]\n", object, fid_gen, gen_mask);
 	if ((err = zfs_zget(zfsvfs, object, &zp))) {
 		zfs_exit(zfsvfs, FTAG);
 		return (err);
 	}
 
 	/* Don't export xattr stuff */
 	if (zp->z_pflags & ZFS_XATTR) {
 		zrele(zp);
 		zfs_exit(zfsvfs, FTAG);
 		return (SET_ERROR(ENOENT));
 	}
 
 	(void) sa_lookup(zp->z_sa_hdl, SA_ZPL_GEN(zfsvfs), &zp_gen,
 	    sizeof (uint64_t));
 	zp_gen = zp_gen & gen_mask;
 	if (zp_gen == 0)
 		zp_gen = 1;
 	if ((fid_gen == 0) && (zfsvfs->z_root == object))
 		fid_gen = zp_gen;
 	if (zp->z_unlinked || zp_gen != fid_gen) {
 		dprintf("znode gen (%llu) != fid gen (%llu)\n", zp_gen,
 		    fid_gen);
 		zrele(zp);
 		zfs_exit(zfsvfs, FTAG);
 		return (SET_ERROR(ENOENT));
 	}
 
 	*ipp = ZTOI(zp);
 	if (*ipp)
 		zfs_znode_update_vfs(ITOZ(*ipp));
 
 	zfs_exit(zfsvfs, FTAG);
 	return (0);
 }
 
 /*
  * Block out VFS ops and close zfsvfs_t
  *
  * Note, if successful, then we return with the 'z_teardown_lock' and
  * 'z_teardown_inactive_lock' write held.  We leave ownership of the underlying
  * dataset and objset intact so that they can be atomically handed off during
  * a subsequent rollback or recv operation and the resume thereafter.
  */
 int
 zfs_suspend_fs(zfsvfs_t *zfsvfs)
 {
 	int error;
 
 	if ((error = zfsvfs_teardown(zfsvfs, B_FALSE)) != 0)
 		return (error);
 
 	return (0);
 }
 
 /*
  * Rebuild SA and release VOPs.  Note that ownership of the underlying dataset
  * is an invariant across any of the operations that can be performed while the
  * filesystem was suspended.  Whether it succeeded or failed, the preconditions
  * are the same: the relevant objset and associated dataset are owned by
  * zfsvfs, held, and long held on entry.
  */
 int
 zfs_resume_fs(zfsvfs_t *zfsvfs, dsl_dataset_t *ds)
 {
 	int err, err2;
 	znode_t *zp;
 
 	ASSERT(ZFS_TEARDOWN_WRITE_HELD(zfsvfs));
 	ASSERT(RW_WRITE_HELD(&zfsvfs->z_teardown_inactive_lock));
 
 	/*
 	 * We already own this, so just update the objset_t, as the one we
 	 * had before may have been evicted.
 	 */
 	objset_t *os;
 	VERIFY3P(ds->ds_owner, ==, zfsvfs);
 	VERIFY(dsl_dataset_long_held(ds));
 	dsl_pool_t *dp = spa_get_dsl(dsl_dataset_get_spa(ds));
 	dsl_pool_config_enter(dp, FTAG);
 	VERIFY0(dmu_objset_from_ds(ds, &os));
 	dsl_pool_config_exit(dp, FTAG);
 
 	err = zfsvfs_init(zfsvfs, os);
 	if (err != 0)
 		goto bail;
 
 	ds->ds_dir->dd_activity_cancelled = B_FALSE;
 	VERIFY(zfsvfs_setup(zfsvfs, B_FALSE) == 0);
 
 	zfs_set_fuid_feature(zfsvfs);
 	zfsvfs->z_rollback_time = jiffies;
 
 	/*
 	 * Attempt to re-establish all the active inodes with their
 	 * dbufs.  If a zfs_rezget() fails, then we unhash the inode
 	 * and mark it stale.  This prevents a collision if a new
 	 * inode/object is created which must use the same inode
 	 * number.  The stale inode will be be released when the
 	 * VFS prunes the dentry holding the remaining references
 	 * on the stale inode.
 	 */
 	mutex_enter(&zfsvfs->z_znodes_lock);
 	for (zp = list_head(&zfsvfs->z_all_znodes); zp;
 	    zp = list_next(&zfsvfs->z_all_znodes, zp)) {
 		err2 = zfs_rezget(zp);
 		if (err2) {
 			zpl_d_drop_aliases(ZTOI(zp));
 			remove_inode_hash(ZTOI(zp));
 		}
 
 		/* see comment in zfs_suspend_fs() */
 		if (zp->z_suspended) {
 			zfs_zrele_async(zp);
 			zp->z_suspended = B_FALSE;
 		}
 	}
 	mutex_exit(&zfsvfs->z_znodes_lock);
 
 	if (!zfs_is_readonly(zfsvfs) && !zfsvfs->z_unmounted) {
 		/*
 		 * zfs_suspend_fs() could have interrupted freeing
 		 * of dnodes. We need to restart this freeing so
 		 * that we don't "leak" the space.
 		 */
 		zfs_unlinked_drain(zfsvfs);
 	}
 
 	/*
 	 * Most of the time zfs_suspend_fs is used for changing the contents
 	 * of the underlying dataset. ZFS rollback and receive operations
 	 * might create files for which negative dentries are present in
 	 * the cache. Since walking the dcache would require a lot of GPL-only
 	 * code duplication, it's much easier on these rather rare occasions
 	 * just to flush the whole dcache for the given dataset/filesystem.
 	 */
 	shrink_dcache_sb(zfsvfs->z_sb);
 
 bail:
 	if (err != 0)
 		zfsvfs->z_unmounted = B_TRUE;
 
 	/* release the VFS ops */
 	rw_exit(&zfsvfs->z_teardown_inactive_lock);
 	ZFS_TEARDOWN_EXIT(zfsvfs, FTAG);
 
 	if (err != 0) {
 		/*
 		 * Since we couldn't setup the sa framework, try to force
 		 * unmount this file system.
 		 */
 		if (zfsvfs->z_os)
 			(void) zfs_umount(zfsvfs->z_sb);
 	}
 	return (err);
 }
 
 /*
  * Release VOPs and unmount a suspended filesystem.
  */
 int
 zfs_end_fs(zfsvfs_t *zfsvfs, dsl_dataset_t *ds)
 {
 	ASSERT(ZFS_TEARDOWN_WRITE_HELD(zfsvfs));
 	ASSERT(RW_WRITE_HELD(&zfsvfs->z_teardown_inactive_lock));
 
 	/*
 	 * We already own this, so just hold and rele it to update the
 	 * objset_t, as the one we had before may have been evicted.
 	 */
 	objset_t *os;
 	VERIFY3P(ds->ds_owner, ==, zfsvfs);
 	VERIFY(dsl_dataset_long_held(ds));
 	dsl_pool_t *dp = spa_get_dsl(dsl_dataset_get_spa(ds));
 	dsl_pool_config_enter(dp, FTAG);
 	VERIFY0(dmu_objset_from_ds(ds, &os));
 	dsl_pool_config_exit(dp, FTAG);
 	zfsvfs->z_os = os;
 
 	/* release the VOPs */
 	rw_exit(&zfsvfs->z_teardown_inactive_lock);
 	ZFS_TEARDOWN_EXIT(zfsvfs, FTAG);
 
 	/*
 	 * Try to force unmount this file system.
 	 */
 	(void) zfs_umount(zfsvfs->z_sb);
 	zfsvfs->z_unmounted = B_TRUE;
 	return (0);
 }
 
 /*
  * Automounted snapshots rely on periodic revalidation
  * to defer snapshots from being automatically unmounted.
  */
 
 inline void
 zfs_exit_fs(zfsvfs_t *zfsvfs)
 {
 	if (!zfsvfs->z_issnap)
 		return;
 
 	if (time_after(jiffies, zfsvfs->z_snap_defer_time +
 	    MAX(zfs_expire_snapshot * HZ / 2, HZ))) {
 		zfsvfs->z_snap_defer_time = jiffies;
 		zfsctl_snapshot_unmount_delay(zfsvfs->z_os->os_spa,
 		    dmu_objset_id(zfsvfs->z_os),
 		    zfs_expire_snapshot);
 	}
 }
 
 int
 zfs_set_version(zfsvfs_t *zfsvfs, uint64_t newvers)
 {
 	int error;
 	objset_t *os = zfsvfs->z_os;
 	dmu_tx_t *tx;
 
 	if (newvers < ZPL_VERSION_INITIAL || newvers > ZPL_VERSION)
 		return (SET_ERROR(EINVAL));
 
 	if (newvers < zfsvfs->z_version)
 		return (SET_ERROR(EINVAL));
 
 	if (zfs_spa_version_map(newvers) >
 	    spa_version(dmu_objset_spa(zfsvfs->z_os)))
 		return (SET_ERROR(ENOTSUP));
 
 	tx = dmu_tx_create(os);
 	dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, B_FALSE, ZPL_VERSION_STR);
 	if (newvers >= ZPL_VERSION_SA && !zfsvfs->z_use_sa) {
 		dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, B_TRUE,
 		    ZFS_SA_ATTRS);
 		dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, FALSE, NULL);
 	}
 	error = dmu_tx_assign(tx, TXG_WAIT);
 	if (error) {
 		dmu_tx_abort(tx);
 		return (error);
 	}
 
 	error = zap_update(os, MASTER_NODE_OBJ, ZPL_VERSION_STR,
 	    8, 1, &newvers, tx);
 
 	if (error) {
 		dmu_tx_commit(tx);
 		return (error);
 	}
 
 	if (newvers >= ZPL_VERSION_SA && !zfsvfs->z_use_sa) {
 		uint64_t sa_obj;
 
 		ASSERT3U(spa_version(dmu_objset_spa(zfsvfs->z_os)), >=,
 		    SPA_VERSION_SA);
 		sa_obj = zap_create(os, DMU_OT_SA_MASTER_NODE,
 		    DMU_OT_NONE, 0, tx);
 
 		error = zap_add(os, MASTER_NODE_OBJ,
 		    ZFS_SA_ATTRS, 8, 1, &sa_obj, tx);
 		ASSERT0(error);
 
 		VERIFY(0 == sa_set_sa_object(os, sa_obj));
 		sa_register_update_callback(os, zfs_sa_upgrade);
 	}
 
 	spa_history_log_internal_ds(dmu_objset_ds(os), "upgrade", tx,
 	    "from %llu to %llu", zfsvfs->z_version, newvers);
 
 	dmu_tx_commit(tx);
 
 	zfsvfs->z_version = newvers;
 	os->os_version = newvers;
 
 	zfs_set_fuid_feature(zfsvfs);
 
 	return (0);
 }
 
 /*
  * Return true if the corresponding vfs's unmounted flag is set.
  * Otherwise return false.
  * If this function returns true we know VFS unmount has been initiated.
  */
 boolean_t
 zfs_get_vfs_flag_unmounted(objset_t *os)
 {
 	zfsvfs_t *zfvp;
 	boolean_t unmounted = B_FALSE;
 
 	ASSERT(dmu_objset_type(os) == DMU_OST_ZFS);
 
 	mutex_enter(&os->os_user_ptr_lock);
 	zfvp = dmu_objset_get_user(os);
 	if (zfvp != NULL && zfvp->z_unmounted)
 		unmounted = B_TRUE;
 	mutex_exit(&os->os_user_ptr_lock);
 
 	return (unmounted);
 }
 
 void
 zfsvfs_update_fromname(const char *oldname, const char *newname)
 {
 	/*
 	 * We don't need to do anything here, the devname is always current by
 	 * virtue of zfsvfs->z_sb->s_op->show_devname.
 	 */
 	(void) oldname, (void) newname;
 }
 
 void
 zfs_init(void)
 {
 	zfsctl_init();
 	zfs_znode_init();
 	dmu_objset_register_type(DMU_OST_ZFS, zpl_get_file_info);
 	register_filesystem(&zpl_fs_type);
 }
 
 void
 zfs_fini(void)
 {
 	/*
 	 * we don't use outstanding because zpl_posix_acl_free might add more.
 	 */
 	taskq_wait(system_delay_taskq);
 	taskq_wait(system_taskq);
 	unregister_filesystem(&zpl_fs_type);
 	zfs_znode_fini();
 	zfsctl_fini();
 }
 
 #if defined(_KERNEL)
 EXPORT_SYMBOL(zfs_suspend_fs);
 EXPORT_SYMBOL(zfs_resume_fs);
 EXPORT_SYMBOL(zfs_set_version);
 EXPORT_SYMBOL(zfsvfs_create);
 EXPORT_SYMBOL(zfsvfs_free);
 EXPORT_SYMBOL(zfs_is_readonly);
 EXPORT_SYMBOL(zfs_domount);
 EXPORT_SYMBOL(zfs_preumount);
 EXPORT_SYMBOL(zfs_umount);
 EXPORT_SYMBOL(zfs_remount);
 EXPORT_SYMBOL(zfs_statvfs);
 EXPORT_SYMBOL(zfs_vget);
 EXPORT_SYMBOL(zfs_prune);
 #endif
diff --git a/sys/contrib/openzfs/module/zcommon/zfs_valstr.c b/sys/contrib/openzfs/module/zcommon/zfs_valstr.c
index 622323bbbd5f..43bccea14a85 100644
--- a/sys/contrib/openzfs/module/zcommon/zfs_valstr.c
+++ b/sys/contrib/openzfs/module/zcommon/zfs_valstr.c
@@ -1,279 +1,280 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 
 /*
  * Copyright (c) 2024, Klara Inc.
  */
 
 #include <sys/fs/zfs.h>
 #include <sys/types.h>
 #include <sys/sysmacros.h>
 #include <sys/string.h>
 #include <sys/debug.h>
 #include "zfs_valstr.h"
 
 /*
  * Each bit in a bitfield has three possible string representations:
  * - single char
  * - two-char pair
  * - full name
  */
 typedef struct {
 	const char	vb_bit;
 	const char	vb_pair[2];
 	const char	*vb_name;
 } valstr_bit_t;
 
 /*
  * Emits a character for each bit in `bits`, up to the number of elements
  * in the table. Set bits get the character in vb_bit, clear bits get a
  * space. This results in all strings having the same width, for easier
  * visual comparison.
  */
 static size_t
 valstr_bitfield_bits(const valstr_bit_t *table, const size_t nelems,
     uint64_t bits, char *out, size_t outlen)
 {
 	ASSERT(out);
 	size_t n = 0;
 	for (int b = 0; b < nelems; b++) {
 		if (n == outlen)
 			break;
 		uint64_t mask = (1ULL << b);
 		out[n++] = (bits & mask) ? table[b].vb_bit : ' ';
 	}
 	if (n < outlen)
 		out[n++] = '\0';
 	return (n);
 }
 
 /*
  * Emits a two-char pair for each bit set in `bits`, taken from vb_pair, and
  * separated by a `|` character. This gives a concise representation of the
  * whole value.
  */
 static size_t
 valstr_bitfield_pairs(const valstr_bit_t *table, const size_t nelems,
     uint64_t bits, char *out, size_t outlen)
 {
 	ASSERT(out);
 	size_t n = 0;
 	for (int b = 0; b < nelems; b++) {
 		ASSERT3U(n, <=, outlen);
 		if (n == outlen)
 			break;
 		uint64_t mask = (1ULL << b);
 		if (bits & mask) {
 			size_t len = (n > 0) ? 3 : 2;
 			if (n > outlen-len)
 				break;
 			if (n > 0)
 				out[n++] = '|';
 			out[n++] = table[b].vb_pair[0];
 			out[n++] = table[b].vb_pair[1];
 		}
 	}
 	if (n < outlen)
 		out[n++] = '\0';
 	return (n);
 }
 
 /*
  * Emits the full name for each bit set in `bits`, taken from vb_name, and
  * separated by a space. This unambiguously shows the entire set of bits, but
  * can get very long.
  */
 static size_t
 valstr_bitfield_str(const valstr_bit_t *table, const size_t nelems,
     uint64_t bits, char *out, size_t outlen)
 {
 	ASSERT(out);
 	size_t n = 0;
 	for (int b = 0; b < nelems; b++) {
 		ASSERT3U(n, <=, outlen);
 		if (n == outlen)
 			break;
 		uint64_t mask = (1ULL << b);
 		if (bits & mask) {
 			size_t len = strlen(table[b].vb_name);
 			if (n > 0)
 				len++;
 			if (n > outlen-len)
 				break;
 			if (n > 0) {
 				out[n++] = ' ';
 				len--;
 			}
 			memcpy(&out[n], table[b].vb_name, len);
 			n += len;
 		}
 	}
 	if (n < outlen)
 		out[n++] = '\0';
 	return (n);
 }
 
 /*
  * Emits the name of the given enum value in the table.
  */
 static size_t
 valstr_enum_str(const char **table, const size_t nelems,
     int v, char *out, size_t outlen)
 {
 	ASSERT(out);
 	ASSERT3U(v, <, nelems);
 	if (v >= nelems)
 		return (0);
 	return (MIN(strlcpy(out, table[v], outlen), outlen));
 }
 
 /*
  * These macros create the string tables for the given name, and implement
  * the public functions described in zfs_valstr.h.
  */
 #define	_VALSTR_BITFIELD_IMPL(name, ...)				\
 static const valstr_bit_t valstr_ ## name ## _table[] = { __VA_ARGS__ };\
 size_t									\
 zfs_valstr_ ## name ## _bits(uint64_t bits, char *out, size_t outlen)	\
 {									\
 	return (valstr_bitfield_bits(valstr_ ## name ## _table,		\
 	    ARRAY_SIZE(valstr_ ## name ## _table), bits, out, outlen));	\
 }									\
 									\
 size_t									\
 zfs_valstr_ ## name ## _pairs(uint64_t bits, char *out, size_t outlen)	\
 {									\
 	return (valstr_bitfield_pairs(valstr_ ## name ## _table,	\
 	    ARRAY_SIZE(valstr_ ## name ## _table), bits, out, outlen));	\
 }									\
 									\
 size_t									\
 zfs_valstr_ ## name(uint64_t bits, char *out, size_t outlen)		\
 {									\
 	return (valstr_bitfield_str(valstr_ ## name ## _table,		\
 	    ARRAY_SIZE(valstr_ ## name ## _table), bits, out, outlen));	\
 }									\
 
 #define	_VALSTR_ENUM_IMPL(name, ...)					\
 static const char *valstr_ ## name ## _table[] = { __VA_ARGS__ };	\
 size_t									\
 zfs_valstr_ ## name(int v, char *out, size_t outlen)			\
 {									\
 	return (valstr_enum_str(valstr_ ## name ## _table,		\
 	    ARRAY_SIZE(valstr_ ## name ## _table), v, out, outlen));	\
 }									\
 
 
 /* String tables */
 
 /* ZIO flags: zio_flag_t, typically zio->io_flags */
 /* BEGIN CSTYLED */
 _VALSTR_BITFIELD_IMPL(zio_flag,
 	{ '.', "DA", "DONT_AGGREGATE" },
 	{ '.', "RP", "IO_REPAIR" },
 	{ '.', "SH", "SELF_HEAL" },
 	{ '.', "RS", "RESILVER" },
 	{ '.', "SC", "SCRUB" },
 	{ '.', "ST", "SCAN_THREAD" },
 	{ '.', "PH", "PHYSICAL" },
 	{ '.', "CF", "CANFAIL" },
 	{ '.', "SP", "SPECULATIVE" },
 	{ '.', "CW", "CONFIG_WRITER" },
 	{ '.', "DR", "DONT_RETRY" },
 	{ '?', "??", "[UNUSED 11]" },
 	{ '.', "ND", "NODATA" },
 	{ '.', "ID", "INDUCE_DAMAGE" },
 	{ '.', "AL", "IO_ALLOCATING" },
 	{ '.', "RE", "IO_RETRY" },
 	{ '.', "PR", "PROBE" },
 	{ '.', "TH", "TRYHARD" },
 	{ '.', "OP", "OPTIONAL" },
+	{ '.', "RD", "DIO_READ" },
 	{ '.', "DQ", "DONT_QUEUE" },
 	{ '.', "DP", "DONT_PROPAGATE" },
 	{ '.', "BY", "IO_BYPASS" },
 	{ '.', "RW", "IO_REWRITE" },
 	{ '.', "CM", "RAW_COMPRESS" },
 	{ '.', "EN", "RAW_ENCRYPT" },
 	{ '.', "GG", "GANG_CHILD" },
 	{ '.', "DD", "DDT_CHILD" },
 	{ '.', "GF", "GODFATHER" },
 	{ '.', "NP", "NOPWRITE" },
 	{ '.', "EX", "REEXECUTED" },
 	{ '.', "DG", "DELEGATED" },
 	{ '.', "DC", "DIO_CHKSUM_ERR" },
 )
 /* END CSTYLED */
 
 /*
  * ZIO pipeline stage(s): enum zio_stage, typically zio->io_stage or
  *                        zio->io_pipeline.
  */
 /* BEGIN CSTYLED */
 _VALSTR_BITFIELD_IMPL(zio_stage,
 	{ 'O', "O ", "OPEN" },
 	{ 'I', "RI", "READ_BP_INIT" },
 	{ 'I', "WI", "WRITE_BP_INIT" },
 	{ 'I', "FI", "FREE_BP_INIT" },
 	{ 'A', "IA", "ISSUE_ASYNC" },
 	{ 'W', "WC", "WRITE_COMPRESS" },
 	{ 'E', "EN", "ENCRYPT" },
 	{ 'C', "CG", "CHECKSUM_GENERATE" },
 	{ 'N', "NW", "NOP_WRITE" },
 	{ 'B', "BF", "BRT_FREE" },
 	{ 'd', "dS", "DDT_READ_START" },
 	{ 'd', "dD", "DDT_READ_DONE" },
 	{ 'd', "dW", "DDT_WRITE" },
 	{ 'd', "dF", "DDT_FREE" },
 	{ 'G', "GA", "GANG_ASSEMBLE" },
 	{ 'G', "GI", "GANG_ISSUE" },
 	{ 'D', "DT", "DVA_THROTTLE" },
 	{ 'D', "DA", "DVA_ALLOCATE" },
 	{ 'D', "DF", "DVA_FREE" },
 	{ 'D', "DC", "DVA_CLAIM" },
 	{ 'R', "R ", "READY" },
 	{ 'V', "VS", "VDEV_IO_START" },
 	{ 'V', "VD", "VDEV_IO_DONE" },
 	{ 'V', "VA", "VDEV_IO_ASSESS" },
 	{ 'C', "CV", "CHECKSUM_VERIFY" },
 	{ 'C', "DC", "DIO_CHECKSUM_VERIFY" },
 	{ 'X', "X ", "DONE" },
 )
 /* END CSTYLED */
 
 /* ZIO priority: zio_priority_t, typically zio->io_priority */
 /* BEGIN CSTYLED */
 _VALSTR_ENUM_IMPL(zio_priority,
 	"SYNC_READ",
 	"SYNC_WRITE",
 	"ASYNC_READ",
 	"ASYNC_WRITE",
 	"SCRUB",
 	"REMOVAL",
 	"INITIALIZING",
 	"TRIM",
 	"REBUILD",
 	"[NUM_QUEUEABLE]",
 	"NOW",
 )
 /* END CSTYLED */
 
 #undef _VALSTR_BITFIELD_IMPL
 #undef _VALSTR_ENUM_IMPL
diff --git a/sys/contrib/openzfs/module/zfs/dmu_direct.c b/sys/contrib/openzfs/module/zfs/dmu_direct.c
index 91a7fd8df464..ed96e7515bc7 100644
--- a/sys/contrib/openzfs/module/zfs/dmu_direct.c
+++ b/sys/contrib/openzfs/module/zfs/dmu_direct.c
@@ -1,395 +1,395 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 
 
 #include <sys/dmu.h>
 #include <sys/dmu_impl.h>
 #include <sys/dbuf.h>
 #include <sys/dnode.h>
 #include <sys/zfs_context.h>
 #include <sys/zfs_racct.h>
 #include <sys/dsl_dataset.h>
 #include <sys/dmu_objset.h>
 
 static abd_t *
 make_abd_for_dbuf(dmu_buf_impl_t *db, abd_t *data, uint64_t offset,
     uint64_t size)
 {
 	size_t buf_size = db->db.db_size;
 	abd_t *pre_buf = NULL, *post_buf = NULL, *mbuf = NULL;
 	size_t buf_off = 0;
 
 	ASSERT(MUTEX_HELD(&db->db_mtx));
 
 	if (offset > db->db.db_offset) {
 		size_t pre_size = offset - db->db.db_offset;
 		pre_buf = abd_alloc_for_io(pre_size, B_TRUE);
 		buf_size -= pre_size;
 		buf_off = 0;
 	} else {
 		buf_off = db->db.db_offset - offset;
 		size -= buf_off;
 	}
 
 	if (size < buf_size) {
 		size_t post_size = buf_size - size;
 		post_buf = abd_alloc_for_io(post_size, B_TRUE);
 		buf_size -= post_size;
 	}
 
 	ASSERT3U(buf_size, >, 0);
 	abd_t *buf = abd_get_offset_size(data, buf_off, buf_size);
 
 	if (pre_buf || post_buf) {
 		mbuf = abd_alloc_gang();
 		if (pre_buf)
 			abd_gang_add(mbuf, pre_buf, B_TRUE);
 		abd_gang_add(mbuf, buf, B_TRUE);
 		if (post_buf)
 			abd_gang_add(mbuf, post_buf, B_TRUE);
 	} else {
 		mbuf = buf;
 	}
 
 	return (mbuf);
 }
 
 static void
 dmu_read_abd_done(zio_t *zio)
 {
 	abd_free(zio->io_abd);
 }
 
 static void
 dmu_write_direct_ready(zio_t *zio)
 {
 	dmu_sync_ready(zio, NULL, zio->io_private);
 }
 
 static void
 dmu_write_direct_done(zio_t *zio)
 {
 	dmu_sync_arg_t *dsa = zio->io_private;
 	dbuf_dirty_record_t *dr = dsa->dsa_dr;
 	dmu_buf_impl_t *db = dr->dr_dbuf;
 
 	abd_free(zio->io_abd);
 
 	mutex_enter(&db->db_mtx);
 	ASSERT3P(db->db_buf, ==, NULL);
 	ASSERT3P(dr->dt.dl.dr_data, ==, NULL);
 	ASSERT3P(db->db.db_data, ==, NULL);
 	db->db_state = DB_UNCACHED;
 	mutex_exit(&db->db_mtx);
 
 	dmu_sync_done(zio, NULL, zio->io_private);
 
 	if (zio->io_error != 0) {
 		if (zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR)
 			ASSERT3U(zio->io_error, ==, EIO);
 
 		/*
 		 * In the event of an I/O error this block has been freed in
 		 * zio_done() through zio_dva_unallocate(). Calling
 		 * dmu_sync_done() above set dr_override_state to
 		 * DR_NOT_OVERRIDDEN. In this case when dbuf_undirty() calls
 		 * dbuf_unoverride(), it will skip doing zio_free() to free
 		 * this block as that was already taken care of.
 		 *
 		 * Since we are undirtying the record in open-context, we must
 		 * have a hold on the db, so it should never be evicted after
 		 * calling dbuf_undirty().
 		 */
 		mutex_enter(&db->db_mtx);
 		VERIFY3B(dbuf_undirty(db, dsa->dsa_tx), ==, B_FALSE);
 		mutex_exit(&db->db_mtx);
 	}
 
 	kmem_free(zio->io_bp, sizeof (blkptr_t));
 	zio->io_bp = NULL;
 }
 
 int
 dmu_write_direct(zio_t *pio, dmu_buf_impl_t *db, abd_t *data, dmu_tx_t *tx)
 {
 	objset_t *os = db->db_objset;
 	dsl_dataset_t *ds = dmu_objset_ds(os);
 	zbookmark_phys_t zb;
 	dbuf_dirty_record_t *dr_head;
 
 	SET_BOOKMARK(&zb, ds->ds_object,
 	    db->db.db_object, db->db_level, db->db_blkid);
 
 	DB_DNODE_ENTER(db);
 	zio_prop_t zp;
 	dmu_write_policy(os, DB_DNODE(db), db->db_level,
 	    WP_DMU_SYNC | WP_DIRECT_WR, &zp);
 	DB_DNODE_EXIT(db);
 
 	/*
 	 * Dirty this dbuf with DB_NOFILL since we will not have any data
 	 * associated with the dbuf.
 	 */
 	dmu_buf_will_clone_or_dio(&db->db, tx);
 
 	mutex_enter(&db->db_mtx);
 
 	uint64_t txg = dmu_tx_get_txg(tx);
 	ASSERT3U(txg, >, spa_last_synced_txg(os->os_spa));
 	ASSERT3U(txg, >, spa_syncing_txg(os->os_spa));
 
 	dr_head = list_head(&db->db_dirty_records);
 	ASSERT3U(dr_head->dr_txg, ==, txg);
 	dr_head->dt.dl.dr_diowrite = B_TRUE;
 	dr_head->dr_accounted = db->db.db_size;
 
 	blkptr_t *bp = kmem_alloc(sizeof (blkptr_t), KM_SLEEP);
 	if (db->db_blkptr != NULL) {
 		/*
 		 * Fill in bp with the current block pointer so that
 		 * the nopwrite code can check if we're writing the same
 		 * data that's already on disk.
 		 */
 		*bp = *db->db_blkptr;
 	} else {
 		memset(bp, 0, sizeof (blkptr_t));
 	}
 
 	/*
 	 * Disable nopwrite if the current block pointer could change
 	 * before this TXG syncs.
 	 */
 	if (list_next(&db->db_dirty_records, dr_head) != NULL)
 		zp.zp_nopwrite = B_FALSE;
 
 	ASSERT3S(dr_head->dt.dl.dr_override_state, ==, DR_NOT_OVERRIDDEN);
 	dr_head->dt.dl.dr_override_state = DR_IN_DMU_SYNC;
 
 	mutex_exit(&db->db_mtx);
 
 	dmu_objset_willuse_space(os, dr_head->dr_accounted, tx);
 
 	dmu_sync_arg_t *dsa = kmem_zalloc(sizeof (dmu_sync_arg_t), KM_SLEEP);
 	dsa->dsa_dr = dr_head;
 	dsa->dsa_tx = tx;
 
 	zio_t *zio = zio_write(pio, os->os_spa, txg, bp, data,
 	    db->db.db_size, db->db.db_size, &zp,
 	    dmu_write_direct_ready, NULL, dmu_write_direct_done, dsa,
 	    ZIO_PRIORITY_SYNC_WRITE, ZIO_FLAG_CANFAIL, &zb);
 
 	if (pio == NULL)
 		return (zio_wait(zio));
 
 	zio_nowait(zio);
 
 	return (0);
 }
 
 int
 dmu_write_abd(dnode_t *dn, uint64_t offset, uint64_t size,
     abd_t *data, uint32_t flags, dmu_tx_t *tx)
 {
 	dmu_buf_t **dbp;
 	spa_t *spa = dn->dn_objset->os_spa;
 	int numbufs, err;
 
 	ASSERT(flags & DMU_DIRECTIO);
 
 	err = dmu_buf_hold_array_by_dnode(dn, offset,
 	    size, B_FALSE, FTAG, &numbufs, &dbp, flags);
 	if (err)
 		return (err);
 
 	zio_t *pio = zio_root(spa, NULL, NULL, ZIO_FLAG_CANFAIL);
 
 	for (int i = 0; i < numbufs && err == 0; i++) {
 		dmu_buf_impl_t *db = (dmu_buf_impl_t *)dbp[i];
 
 		abd_t *abd = abd_get_offset_size(data,
 		    db->db.db_offset - offset, dn->dn_datablksz);
 
 		zfs_racct_write(spa, db->db.db_size, 1, flags);
 		err = dmu_write_direct(pio, db, abd, tx);
 		ASSERT0(err);
 	}
 
 	err = zio_wait(pio);
 
 	/*
 	 * The dbuf must be held until the Direct I/O write has completed in
 	 * the event there was any errors and dbuf_undirty() was called.
 	 */
 	dmu_buf_rele_array(dbp, numbufs, FTAG);
 
 	return (err);
 }
 
 int
 dmu_read_abd(dnode_t *dn, uint64_t offset, uint64_t size,
     abd_t *data, uint32_t flags)
 {
 	objset_t *os = dn->dn_objset;
 	spa_t *spa = os->os_spa;
 	dmu_buf_t **dbp;
 	int numbufs, err;
 
 	ASSERT(flags & DMU_DIRECTIO);
 
 	err = dmu_buf_hold_array_by_dnode(dn, offset,
 	    size, B_FALSE, FTAG, &numbufs, &dbp, flags);
 	if (err)
 		return (err);
 
 	zio_t *rio = zio_root(spa, NULL, NULL, ZIO_FLAG_CANFAIL);
 
 	for (int i = 0; i < numbufs; i++) {
 		dmu_buf_impl_t *db = (dmu_buf_impl_t *)dbp[i];
 		abd_t *mbuf;
 		zbookmark_phys_t zb;
 		blkptr_t *bp;
 
 		mutex_enter(&db->db_mtx);
 
 		SET_BOOKMARK(&zb, dmu_objset_ds(os)->ds_object,
 		    db->db.db_object, db->db_level, db->db_blkid);
 
 		/*
 		 * If there is another read for this dbuf, we will wait for
 		 * that to complete first before checking the db_state below.
 		 */
 		while (db->db_state == DB_READ)
 			cv_wait(&db->db_changed, &db->db_mtx);
 
 		err = dmu_buf_get_bp_from_dbuf(db, &bp);
 		if (err) {
 			mutex_exit(&db->db_mtx);
 			goto error;
 		}
 
 		/*
 		 * There is no need to read if this is a hole or the data is
 		 * cached. This will not be considered a direct read for IO
 		 * accounting in the same way that an ARC hit is not counted.
 		 */
 		if (bp == NULL || BP_IS_HOLE(bp) || db->db_state == DB_CACHED) {
 			size_t aoff = offset < db->db.db_offset ?
 			    db->db.db_offset - offset : 0;
 			size_t boff = offset > db->db.db_offset ?
 			    offset - db->db.db_offset : 0;
 			size_t len = MIN(size - aoff, db->db.db_size - boff);
 
 			if (db->db_state == DB_CACHED) {
 				/*
 				 * We need to untransformed the ARC buf data
 				 * before we copy it over.
 				 */
 				err = dmu_buf_untransform_direct(db, spa);
 				ASSERT0(err);
 				abd_copy_from_buf_off(data,
 				    (char *)db->db.db_data + boff, aoff, len);
 			} else {
 				abd_zero_off(data, aoff, len);
 			}
 
 			mutex_exit(&db->db_mtx);
 			continue;
 		}
 
 		mbuf = make_abd_for_dbuf(db, data, offset, size);
 		ASSERT3P(mbuf, !=, NULL);
 
 		/*
 		 * The dbuf mutex (db_mtx) must be held when creating the ZIO
 		 * for the read. The BP returned from
 		 * dmu_buf_get_bp_from_dbuf() could be from a pending block
 		 * clone or a yet to be synced Direct I/O write that is in the
 		 * dbuf's dirty record. When zio_read() is called, zio_create()
 		 * will make a copy of the BP. However, if zio_read() is called
 		 * without the mutex being held then the dirty record from the
 		 * dbuf could be freed in dbuf_write_done() resulting in garbage
 		 * being set for the zio BP.
 		 */
 		zio_t *cio = zio_read(rio, spa, bp, mbuf, db->db.db_size,
 		    dmu_read_abd_done, NULL, ZIO_PRIORITY_SYNC_READ,
-		    ZIO_FLAG_CANFAIL, &zb);
+		    ZIO_FLAG_CANFAIL | ZIO_FLAG_DIO_READ, &zb);
 		mutex_exit(&db->db_mtx);
 
 		zfs_racct_read(spa, db->db.db_size, 1, flags);
 		zio_nowait(cio);
 	}
 
 	dmu_buf_rele_array(dbp, numbufs, FTAG);
 
 	return (zio_wait(rio));
 
 error:
 	dmu_buf_rele_array(dbp, numbufs, FTAG);
 	(void) zio_wait(rio);
 	return (err);
 }
 
 #ifdef _KERNEL
 int
 dmu_read_uio_direct(dnode_t *dn, zfs_uio_t *uio, uint64_t size)
 {
 	offset_t offset = zfs_uio_offset(uio);
 	offset_t page_index = (offset - zfs_uio_soffset(uio)) >> PAGESHIFT;
 	int err;
 
 	ASSERT(uio->uio_extflg & UIO_DIRECT);
 	ASSERT3U(page_index, <, uio->uio_dio.npages);
 
 	abd_t *data = abd_alloc_from_pages(&uio->uio_dio.pages[page_index],
 	    offset & (PAGESIZE - 1), size);
 	err = dmu_read_abd(dn, offset, size, data, DMU_DIRECTIO);
 	abd_free(data);
 
 	if (err == 0)
 		zfs_uioskip(uio, size);
 
 	return (err);
 }
 
 int
 dmu_write_uio_direct(dnode_t *dn, zfs_uio_t *uio, uint64_t size, dmu_tx_t *tx)
 {
 	offset_t offset = zfs_uio_offset(uio);
 	offset_t page_index = (offset - zfs_uio_soffset(uio)) >> PAGESHIFT;
 	int err;
 
 	ASSERT(uio->uio_extflg & UIO_DIRECT);
 	ASSERT3U(page_index, <, uio->uio_dio.npages);
 
 	abd_t *data = abd_alloc_from_pages(&uio->uio_dio.pages[page_index],
 	    offset & (PAGESIZE - 1), size);
 	err = dmu_write_abd(dn, offset, size, data, DMU_DIRECTIO, tx);
 	abd_free(data);
 
 	if (err == 0)
 		zfs_uioskip(uio, size);
 
 	return (err);
 }
 #endif /* _KERNEL */
 
 EXPORT_SYMBOL(dmu_read_uio_direct);
 EXPORT_SYMBOL(dmu_write_uio_direct);
diff --git a/sys/contrib/openzfs/module/zfs/dsl_dataset.c b/sys/contrib/openzfs/module/zfs/dsl_dataset.c
index 6a9ed891093b..2248f644bee7 100644
--- a/sys/contrib/openzfs/module/zfs/dsl_dataset.c
+++ b/sys/contrib/openzfs/module/zfs/dsl_dataset.c
@@ -1,5030 +1,5037 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 
 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2011, 2020 by Delphix. All rights reserved.
  * Copyright (c) 2014, Joyent, Inc. All rights reserved.
  * Copyright (c) 2014 RackTop Systems.
  * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
  * Copyright (c) 2016 Actifio, Inc. All rights reserved.
  * Copyright 2016, OmniTI Computer Consulting, Inc. All rights reserved.
  * Copyright 2017 Nexenta Systems, Inc.
  * 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.
  */
 
 #include <sys/dmu_objset.h>
 #include <sys/dsl_dataset.h>
 #include <sys/dsl_dir.h>
 #include <sys/dsl_prop.h>
 #include <sys/dsl_synctask.h>
 #include <sys/dmu_traverse.h>
 #include <sys/dmu_impl.h>
 #include <sys/dmu_tx.h>
 #include <sys/arc.h>
 #include <sys/zio.h>
 #include <sys/zap.h>
 #include <sys/zfeature.h>
 #include <sys/unique.h>
 #include <sys/zfs_context.h>
 #include <sys/zfs_ioctl.h>
 #include <sys/spa.h>
 #include <sys/spa_impl.h>
 #include <sys/vdev.h>
 #include <sys/zfs_znode.h>
 #include <sys/zfs_onexit.h>
 #include <sys/zvol.h>
 #include <sys/dsl_scan.h>
 #include <sys/dsl_deadlist.h>
 #include <sys/dsl_destroy.h>
 #include <sys/dsl_userhold.h>
 #include <sys/dsl_bookmark.h>
 #include <sys/policy.h>
 #include <sys/dmu_send.h>
 #include <sys/dmu_recv.h>
 #include <sys/zio_compress.h>
 #include <zfs_fletcher.h>
 #include <sys/zio_checksum.h>
 
 /*
  * The SPA supports block sizes up to 16MB.  However, very large blocks
  * can have an impact on i/o latency (e.g. tying up a spinning disk for
  * ~300ms), and also potentially on the memory allocator.  Therefore,
  * we did not allow the recordsize to be set larger than zfs_max_recordsize
  * (former default: 1MB).  Larger blocks could be created by changing this
  * tunable, and pools with larger blocks could always be imported and used,
  * regardless of this setting.
  *
  * We do, however, still limit it by default to 1M on x86_32, because Linux's
  * 3/1 memory split doesn't leave much room for 16M chunks.
  */
 #ifdef _ILP32
 uint_t zfs_max_recordsize =  1 * 1024 * 1024;
 #else
 uint_t zfs_max_recordsize = 16 * 1024 * 1024;
 #endif
 static int zfs_allow_redacted_dataset_mount = 0;
 
 int zfs_snapshot_history_enabled = 1;
 
 #define	SWITCH64(x, y) \
 	{ \
 		uint64_t __tmp = (x); \
 		(x) = (y); \
 		(y) = __tmp; \
 	}
 
 #define	DS_REF_MAX	(1ULL << 62)
 
 static void dsl_dataset_set_remap_deadlist_object(dsl_dataset_t *ds,
     uint64_t obj, dmu_tx_t *tx);
 static void dsl_dataset_unset_remap_deadlist_object(dsl_dataset_t *ds,
     dmu_tx_t *tx);
 
 static void unload_zfeature(dsl_dataset_t *ds, spa_feature_t f);
 
 extern uint_t spa_asize_inflation;
 
 static zil_header_t zero_zil;
 
 /*
  * Figure out how much of this delta should be propagated to the dsl_dir
  * layer.  If there's a refreservation, that space has already been
  * partially accounted for in our ancestors.
  */
 static int64_t
 parent_delta(dsl_dataset_t *ds, int64_t delta)
 {
 	dsl_dataset_phys_t *ds_phys;
 	uint64_t old_bytes, new_bytes;
 
 	if (ds->ds_reserved == 0)
 		return (delta);
 
 	ds_phys = dsl_dataset_phys(ds);
 	old_bytes = MAX(ds_phys->ds_unique_bytes, ds->ds_reserved);
 	new_bytes = MAX(ds_phys->ds_unique_bytes + delta, ds->ds_reserved);
 
 	ASSERT3U(ABS((int64_t)(new_bytes - old_bytes)), <=, ABS(delta));
 	return (new_bytes - old_bytes);
 }
 
 void
 dsl_dataset_block_born(dsl_dataset_t *ds, const blkptr_t *bp, dmu_tx_t *tx)
 {
 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
 	int used = bp_get_dsize_sync(spa, bp);
 	int compressed = BP_GET_PSIZE(bp);
 	int uncompressed = BP_GET_UCSIZE(bp);
 	int64_t delta;
 	spa_feature_t f;
 
 	dprintf_bp(bp, "ds=%p", ds);
 
 	ASSERT(dmu_tx_is_syncing(tx));
 	/* It could have been compressed away to nothing */
 	if (BP_IS_HOLE(bp) || BP_IS_REDACTED(bp))
 		return;
 	ASSERT(BP_GET_TYPE(bp) != DMU_OT_NONE);
 	ASSERT(DMU_OT_IS_VALID(BP_GET_TYPE(bp)));
 	if (ds == NULL) {
 		dsl_pool_mos_diduse_space(tx->tx_pool,
 		    used, compressed, uncompressed);
 		return;
 	}
 
 	ASSERT3U(BP_GET_LOGICAL_BIRTH(bp), >,
 	    dsl_dataset_phys(ds)->ds_prev_snap_txg);
 	dmu_buf_will_dirty(ds->ds_dbuf, tx);
 	mutex_enter(&ds->ds_lock);
 	delta = parent_delta(ds, used);
 	dsl_dataset_phys(ds)->ds_referenced_bytes += used;
 	dsl_dataset_phys(ds)->ds_compressed_bytes += compressed;
 	dsl_dataset_phys(ds)->ds_uncompressed_bytes += uncompressed;
 	dsl_dataset_phys(ds)->ds_unique_bytes += used;
 
 	if (BP_GET_LSIZE(bp) > SPA_OLD_MAXBLOCKSIZE) {
 		ds->ds_feature_activation[SPA_FEATURE_LARGE_BLOCKS] =
 		    (void *)B_TRUE;
 	}
 
 
 	f = zio_checksum_to_feature(BP_GET_CHECKSUM(bp));
 	if (f != SPA_FEATURE_NONE) {
 		ASSERT3S(spa_feature_table[f].fi_type, ==,
 		    ZFEATURE_TYPE_BOOLEAN);
 		ds->ds_feature_activation[f] = (void *)B_TRUE;
 	}
 
 	f = zio_compress_to_feature(BP_GET_COMPRESS(bp));
 	if (f != SPA_FEATURE_NONE) {
 		ASSERT3S(spa_feature_table[f].fi_type, ==,
 		    ZFEATURE_TYPE_BOOLEAN);
 		ds->ds_feature_activation[f] = (void *)B_TRUE;
 	}
 
 	/*
 	 * Track block for livelist, but ignore embedded blocks because
 	 * they do not need to be freed.
 	 */
 	if (dsl_deadlist_is_open(&ds->ds_dir->dd_livelist) &&
 	    BP_GET_LOGICAL_BIRTH(bp) > ds->ds_dir->dd_origin_txg &&
 	    !(BP_IS_EMBEDDED(bp))) {
 		ASSERT(dsl_dir_is_clone(ds->ds_dir));
 		ASSERT(spa_feature_is_enabled(spa,
 		    SPA_FEATURE_LIVELIST));
 		bplist_append(&ds->ds_dir->dd_pending_allocs, bp);
 	}
 
 	mutex_exit(&ds->ds_lock);
 	dsl_dir_diduse_transfer_space(ds->ds_dir, delta,
 	    compressed, uncompressed, used,
 	    DD_USED_REFRSRV, DD_USED_HEAD, tx);
 }
 
 /*
  * Called when the specified segment has been remapped, and is thus no
  * longer referenced in the head dataset.  The vdev must be indirect.
  *
  * If the segment is referenced by a snapshot, put it on the remap deadlist.
  * Otherwise, add this segment to the obsolete spacemap.
  */
 void
 dsl_dataset_block_remapped(dsl_dataset_t *ds, uint64_t vdev, uint64_t offset,
     uint64_t size, uint64_t birth, dmu_tx_t *tx)
 {
 	spa_t *spa = ds->ds_dir->dd_pool->dp_spa;
 
 	ASSERT(dmu_tx_is_syncing(tx));
 	ASSERT(birth <= tx->tx_txg);
 	ASSERT(!ds->ds_is_snapshot);
 
 	if (birth > dsl_dataset_phys(ds)->ds_prev_snap_txg) {
 		spa_vdev_indirect_mark_obsolete(spa, vdev, offset, size, tx);
 	} else {
 		blkptr_t fakebp;
 		dva_t *dva = &fakebp.blk_dva[0];
 
 		ASSERT(ds != NULL);
 
 		mutex_enter(&ds->ds_remap_deadlist_lock);
 		if (!dsl_dataset_remap_deadlist_exists(ds)) {
 			dsl_dataset_create_remap_deadlist(ds, tx);
 		}
 		mutex_exit(&ds->ds_remap_deadlist_lock);
 
 		BP_ZERO(&fakebp);
 		BP_SET_LOGICAL_BIRTH(&fakebp, birth);
 		DVA_SET_VDEV(dva, vdev);
 		DVA_SET_OFFSET(dva, offset);
 		DVA_SET_ASIZE(dva, size);
 		dsl_deadlist_insert(&ds->ds_remap_deadlist, &fakebp, B_FALSE,
 		    tx);
 	}
 }
 
 int
 dsl_dataset_block_kill(dsl_dataset_t *ds, const blkptr_t *bp, dmu_tx_t *tx,
     boolean_t async)
 {
 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
 
 	int used = bp_get_dsize_sync(spa, bp);
 	int compressed = BP_GET_PSIZE(bp);
 	int uncompressed = BP_GET_UCSIZE(bp);
 
 	if (BP_IS_HOLE(bp) || BP_IS_REDACTED(bp))
 		return (0);
 
 	ASSERT(dmu_tx_is_syncing(tx));
 	ASSERT(BP_GET_LOGICAL_BIRTH(bp) <= tx->tx_txg);
 
 	if (ds == NULL) {
 		dsl_free(tx->tx_pool, tx->tx_txg, bp);
 		dsl_pool_mos_diduse_space(tx->tx_pool,
 		    -used, -compressed, -uncompressed);
 		return (used);
 	}
 	ASSERT3P(tx->tx_pool, ==, ds->ds_dir->dd_pool);
 
 	ASSERT(!ds->ds_is_snapshot);
 	dmu_buf_will_dirty(ds->ds_dbuf, tx);
 
 	/*
 	 * Track block for livelist, but ignore embedded blocks because
 	 * they do not need to be freed.
 	 */
 	if (dsl_deadlist_is_open(&ds->ds_dir->dd_livelist) &&
 	    BP_GET_LOGICAL_BIRTH(bp) > ds->ds_dir->dd_origin_txg &&
 	    !(BP_IS_EMBEDDED(bp))) {
 		ASSERT(dsl_dir_is_clone(ds->ds_dir));
 		ASSERT(spa_feature_is_enabled(spa,
 		    SPA_FEATURE_LIVELIST));
 		bplist_append(&ds->ds_dir->dd_pending_frees, bp);
 	}
 
 	if (BP_GET_LOGICAL_BIRTH(bp) > dsl_dataset_phys(ds)->ds_prev_snap_txg) {
 		int64_t delta;
 
 		dprintf_bp(bp, "freeing ds=%llu", (u_longlong_t)ds->ds_object);
 		dsl_free(tx->tx_pool, tx->tx_txg, bp);
 
 		mutex_enter(&ds->ds_lock);
 		ASSERT(dsl_dataset_phys(ds)->ds_unique_bytes >= used ||
 		    !DS_UNIQUE_IS_ACCURATE(ds));
 		delta = parent_delta(ds, -used);
 		dsl_dataset_phys(ds)->ds_unique_bytes -= used;
 		mutex_exit(&ds->ds_lock);
 		dsl_dir_diduse_transfer_space(ds->ds_dir,
 		    delta, -compressed, -uncompressed, -used,
 		    DD_USED_REFRSRV, DD_USED_HEAD, tx);
 	} else {
 		dprintf_bp(bp, "putting on dead list: %s", "");
 		if (async) {
 			/*
 			 * We are here as part of zio's write done callback,
 			 * which means we're a zio interrupt thread.  We can't
 			 * call dsl_deadlist_insert() now because it may block
 			 * waiting for I/O.  Instead, put bp on the deferred
 			 * queue and let dsl_pool_sync() finish the job.
 			 */
 			bplist_append(&ds->ds_pending_deadlist, bp);
 		} else {
 			dsl_deadlist_insert(&ds->ds_deadlist, bp, B_FALSE, tx);
 		}
 		ASSERT3U(ds->ds_prev->ds_object, ==,
 		    dsl_dataset_phys(ds)->ds_prev_snap_obj);
 		ASSERT(dsl_dataset_phys(ds->ds_prev)->ds_num_children > 0);
 		/* if (logical birth > prev prev snap txg) prev unique += bs */
 		if (dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj ==
 		    ds->ds_object && BP_GET_LOGICAL_BIRTH(bp) >
 		    dsl_dataset_phys(ds->ds_prev)->ds_prev_snap_txg) {
 			dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx);
 			mutex_enter(&ds->ds_prev->ds_lock);
 			dsl_dataset_phys(ds->ds_prev)->ds_unique_bytes += used;
 			mutex_exit(&ds->ds_prev->ds_lock);
 		}
 		if (BP_GET_LOGICAL_BIRTH(bp) > ds->ds_dir->dd_origin_txg) {
 			dsl_dir_transfer_space(ds->ds_dir, used,
 			    DD_USED_HEAD, DD_USED_SNAP, tx);
 		}
 	}
 
 	dsl_bookmark_block_killed(ds, bp, tx);
 
 	mutex_enter(&ds->ds_lock);
 	ASSERT3U(dsl_dataset_phys(ds)->ds_referenced_bytes, >=, used);
 	dsl_dataset_phys(ds)->ds_referenced_bytes -= used;
 	ASSERT3U(dsl_dataset_phys(ds)->ds_compressed_bytes, >=, compressed);
 	dsl_dataset_phys(ds)->ds_compressed_bytes -= compressed;
 	ASSERT3U(dsl_dataset_phys(ds)->ds_uncompressed_bytes, >=, uncompressed);
 	dsl_dataset_phys(ds)->ds_uncompressed_bytes -= uncompressed;
 	mutex_exit(&ds->ds_lock);
 
 	return (used);
 }
 
 struct feature_type_uint64_array_arg {
 	uint64_t length;
 	uint64_t *array;
 };
 
 static void
 unload_zfeature(dsl_dataset_t *ds, spa_feature_t f)
 {
 	switch (spa_feature_table[f].fi_type) {
 	case ZFEATURE_TYPE_BOOLEAN:
 		break;
 	case ZFEATURE_TYPE_UINT64_ARRAY:
 	{
 		struct feature_type_uint64_array_arg *ftuaa = ds->ds_feature[f];
 		kmem_free(ftuaa->array, ftuaa->length * sizeof (uint64_t));
 		kmem_free(ftuaa, sizeof (*ftuaa));
 		break;
 	}
 	default:
 		panic("Invalid zfeature type %d", spa_feature_table[f].fi_type);
 	}
 }
 
 static int
 load_zfeature(objset_t *mos, dsl_dataset_t *ds, spa_feature_t f)
 {
 	int err = 0;
 	switch (spa_feature_table[f].fi_type) {
 	case ZFEATURE_TYPE_BOOLEAN:
 		err = zap_contains(mos, ds->ds_object,
 		    spa_feature_table[f].fi_guid);
 		if (err == 0) {
 			ds->ds_feature[f] = (void *)B_TRUE;
 		} else {
 			ASSERT3U(err, ==, ENOENT);
 			err = 0;
 		}
 		break;
 	case ZFEATURE_TYPE_UINT64_ARRAY:
 	{
 		uint64_t int_size, num_int;
 		uint64_t *data;
 		err = zap_length(mos, ds->ds_object,
 		    spa_feature_table[f].fi_guid, &int_size, &num_int);
 		if (err != 0) {
 			ASSERT3U(err, ==, ENOENT);
 			err = 0;
 			break;
 		}
 		ASSERT3U(int_size, ==, sizeof (uint64_t));
 		data = kmem_alloc(int_size * num_int, KM_SLEEP);
 		VERIFY0(zap_lookup(mos, ds->ds_object,
 		    spa_feature_table[f].fi_guid, int_size, num_int, data));
 		struct feature_type_uint64_array_arg *ftuaa =
 		    kmem_alloc(sizeof (*ftuaa), KM_SLEEP);
 		ftuaa->length = num_int;
 		ftuaa->array = data;
 		ds->ds_feature[f] = ftuaa;
 		break;
 	}
 	default:
 		panic("Invalid zfeature type %d", spa_feature_table[f].fi_type);
 	}
 	return (err);
 }
 
 /*
  * We have to release the fsid synchronously or we risk that a subsequent
  * mount of the same dataset will fail to unique_insert the fsid.  This
  * failure would manifest itself as the fsid of this dataset changing
  * between mounts which makes NFS clients quite unhappy.
  */
 static void
 dsl_dataset_evict_sync(void *dbu)
 {
 	dsl_dataset_t *ds = dbu;
 
 	ASSERT(ds->ds_owner == NULL);
 
 	unique_remove(ds->ds_fsid_guid);
 }
 
 static void
 dsl_dataset_evict_async(void *dbu)
 {
 	dsl_dataset_t *ds = dbu;
 
 	ASSERT(ds->ds_owner == NULL);
 
 	ds->ds_dbuf = NULL;
 
 	if (ds->ds_objset != NULL)
 		dmu_objset_evict(ds->ds_objset);
 
 	if (ds->ds_prev) {
 		dsl_dataset_rele(ds->ds_prev, ds);
 		ds->ds_prev = NULL;
 	}
 
 	dsl_bookmark_fini_ds(ds);
 
 	bplist_destroy(&ds->ds_pending_deadlist);
 	if (dsl_deadlist_is_open(&ds->ds_deadlist))
 		dsl_deadlist_close(&ds->ds_deadlist);
 	if (dsl_deadlist_is_open(&ds->ds_remap_deadlist))
 		dsl_deadlist_close(&ds->ds_remap_deadlist);
 	if (ds->ds_dir)
 		dsl_dir_async_rele(ds->ds_dir, ds);
 
 	ASSERT(!list_link_active(&ds->ds_synced_link));
 
 	for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
 		if (dsl_dataset_feature_is_active(ds, f))
 			unload_zfeature(ds, f);
 	}
 
 	list_destroy(&ds->ds_prop_cbs);
 	mutex_destroy(&ds->ds_lock);
 	mutex_destroy(&ds->ds_opening_lock);
 	mutex_destroy(&ds->ds_sendstream_lock);
 	mutex_destroy(&ds->ds_remap_deadlist_lock);
 	zfs_refcount_destroy(&ds->ds_longholds);
 	rrw_destroy(&ds->ds_bp_rwlock);
 
 	kmem_free(ds, sizeof (dsl_dataset_t));
 }
 
 int
 dsl_dataset_get_snapname(dsl_dataset_t *ds)
 {
 	dsl_dataset_phys_t *headphys;
 	int err;
 	dmu_buf_t *headdbuf;
 	dsl_pool_t *dp = ds->ds_dir->dd_pool;
 	objset_t *mos = dp->dp_meta_objset;
 
 	if (ds->ds_snapname[0])
 		return (0);
 	if (dsl_dataset_phys(ds)->ds_next_snap_obj == 0)
 		return (0);
 
 	err = dmu_bonus_hold(mos, dsl_dir_phys(ds->ds_dir)->dd_head_dataset_obj,
 	    FTAG, &headdbuf);
 	if (err != 0)
 		return (err);
 	headphys = headdbuf->db_data;
 	err = zap_value_search(dp->dp_meta_objset,
 	    headphys->ds_snapnames_zapobj, ds->ds_object, 0, ds->ds_snapname,
 	    sizeof (ds->ds_snapname));
 	if (err != 0 && zfs_recover == B_TRUE) {
 		err = 0;
 		(void) snprintf(ds->ds_snapname, sizeof (ds->ds_snapname),
 		    "SNAPOBJ=%llu-ERR=%d",
 		    (unsigned long long)ds->ds_object, err);
 	}
 	dmu_buf_rele(headdbuf, FTAG);
 	return (err);
 }
 
 int
 dsl_dataset_snap_lookup(dsl_dataset_t *ds, const char *name, uint64_t *value)
 {
 	objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
 	uint64_t snapobj = dsl_dataset_phys(ds)->ds_snapnames_zapobj;
 	matchtype_t mt = 0;
 	int err;
 
 	if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
 		mt = MT_NORMALIZE;
 
 	err = zap_lookup_norm(mos, snapobj, name, 8, 1,
 	    value, mt, NULL, 0, NULL);
 	if (err == ENOTSUP && (mt & MT_NORMALIZE))
 		err = zap_lookup(mos, snapobj, name, 8, 1, value);
 	return (err);
 }
 
 int
 dsl_dataset_snap_remove(dsl_dataset_t *ds, const char *name, dmu_tx_t *tx,
     boolean_t adj_cnt)
 {
 	objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
 	uint64_t snapobj = dsl_dataset_phys(ds)->ds_snapnames_zapobj;
 	matchtype_t mt = 0;
 	int err;
 
 	dsl_dir_snap_cmtime_update(ds->ds_dir, tx);
 
 	if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
 		mt = MT_NORMALIZE;
 
 	err = zap_remove_norm(mos, snapobj, name, mt, tx);
 	if (err == ENOTSUP && (mt & MT_NORMALIZE))
 		err = zap_remove(mos, snapobj, name, tx);
 
 	if (err == 0 && adj_cnt)
 		dsl_fs_ss_count_adjust(ds->ds_dir, -1,
 		    DD_FIELD_SNAPSHOT_COUNT, tx);
 
 	return (err);
 }
 
 boolean_t
 dsl_dataset_try_add_ref(dsl_pool_t *dp, dsl_dataset_t *ds, const void *tag)
 {
 	dmu_buf_t *dbuf = ds->ds_dbuf;
 	boolean_t result = B_FALSE;
 
 	if (dbuf != NULL && dmu_buf_try_add_ref(dbuf, dp->dp_meta_objset,
 	    ds->ds_object, DMU_BONUS_BLKID, tag)) {
 
 		if (ds == dmu_buf_get_user(dbuf))
 			result = B_TRUE;
 		else
 			dmu_buf_rele(dbuf, tag);
 	}
 
 	return (result);
 }
 
 int
 dsl_dataset_hold_obj(dsl_pool_t *dp, uint64_t dsobj, const void *tag,
     dsl_dataset_t **dsp)
 {
 	objset_t *mos = dp->dp_meta_objset;
 	dmu_buf_t *dbuf;
 	dsl_dataset_t *ds;
 	int err;
 	dmu_object_info_t doi;
 
 	ASSERT(dsl_pool_config_held(dp));
 
 	err = dmu_bonus_hold(mos, dsobj, tag, &dbuf);
 	if (err != 0)
 		return (err);
 
 	/* Make sure dsobj has the correct object type. */
 	dmu_object_info_from_db(dbuf, &doi);
 	if (doi.doi_bonus_type != DMU_OT_DSL_DATASET) {
 		dmu_buf_rele(dbuf, tag);
 		return (SET_ERROR(EINVAL));
 	}
 
 	ds = dmu_buf_get_user(dbuf);
 	if (ds == NULL) {
 		dsl_dataset_t *winner = NULL;
 
 		ds = kmem_zalloc(sizeof (dsl_dataset_t), KM_SLEEP);
 		ds->ds_dbuf = dbuf;
 		ds->ds_object = dsobj;
 		ds->ds_is_snapshot = dsl_dataset_phys(ds)->ds_num_children != 0;
 		list_link_init(&ds->ds_synced_link);
 
 		err = dsl_dir_hold_obj(dp, dsl_dataset_phys(ds)->ds_dir_obj,
 		    NULL, ds, &ds->ds_dir);
 		if (err != 0) {
 			kmem_free(ds, sizeof (dsl_dataset_t));
 			dmu_buf_rele(dbuf, tag);
 			return (err);
 		}
 
 		mutex_init(&ds->ds_lock, NULL, MUTEX_DEFAULT, NULL);
 		mutex_init(&ds->ds_opening_lock, NULL, MUTEX_DEFAULT, NULL);
 		mutex_init(&ds->ds_sendstream_lock, NULL, MUTEX_DEFAULT, NULL);
 		mutex_init(&ds->ds_remap_deadlist_lock,
 		    NULL, MUTEX_DEFAULT, NULL);
 		rrw_init(&ds->ds_bp_rwlock, B_FALSE);
 		zfs_refcount_create(&ds->ds_longholds);
 
 		bplist_create(&ds->ds_pending_deadlist);
 
 		list_create(&ds->ds_sendstreams, sizeof (dmu_sendstatus_t),
 		    offsetof(dmu_sendstatus_t, dss_link));
 
 		list_create(&ds->ds_prop_cbs, sizeof (dsl_prop_cb_record_t),
 		    offsetof(dsl_prop_cb_record_t, cbr_ds_node));
 
 		if (doi.doi_type == DMU_OTN_ZAP_METADATA) {
 			spa_feature_t f;
 
 			for (f = 0; f < SPA_FEATURES; f++) {
 				if (!(spa_feature_table[f].fi_flags &
 				    ZFEATURE_FLAG_PER_DATASET))
 					continue;
 				err = load_zfeature(mos, ds, f);
 			}
 		}
 
 		if (!ds->ds_is_snapshot) {
 			ds->ds_snapname[0] = '\0';
 			if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0) {
 				err = dsl_dataset_hold_obj(dp,
 				    dsl_dataset_phys(ds)->ds_prev_snap_obj,
 				    ds, &ds->ds_prev);
 			}
 			if (err != 0)
 				goto after_dsl_bookmark_fini;
 			err = dsl_bookmark_init_ds(ds);
 		} else {
 			if (zfs_flags & ZFS_DEBUG_SNAPNAMES)
 				err = dsl_dataset_get_snapname(ds);
 			if (err == 0 &&
 			    dsl_dataset_phys(ds)->ds_userrefs_obj != 0) {
 				err = zap_count(
 				    ds->ds_dir->dd_pool->dp_meta_objset,
 				    dsl_dataset_phys(ds)->ds_userrefs_obj,
 				    &ds->ds_userrefs);
 			}
 		}
 
 		if (err == 0 && !ds->ds_is_snapshot) {
 			err = dsl_prop_get_int_ds(ds,
 			    zfs_prop_to_name(ZFS_PROP_REFRESERVATION),
 			    &ds->ds_reserved);
 			if (err == 0) {
 				err = dsl_prop_get_int_ds(ds,
 				    zfs_prop_to_name(ZFS_PROP_REFQUOTA),
 				    &ds->ds_quota);
 			}
 		} else {
 			ds->ds_reserved = ds->ds_quota = 0;
 		}
 
 		if (err == 0 && ds->ds_dir->dd_crypto_obj != 0 &&
 		    ds->ds_is_snapshot &&
 		    zap_contains(mos, dsobj, DS_FIELD_IVSET_GUID) != 0) {
 			dp->dp_spa->spa_errata =
 			    ZPOOL_ERRATA_ZOL_8308_ENCRYPTION;
 		}
 
 		dsl_deadlist_open(&ds->ds_deadlist,
 		    mos, dsl_dataset_phys(ds)->ds_deadlist_obj);
 		uint64_t remap_deadlist_obj =
 		    dsl_dataset_get_remap_deadlist_object(ds);
 		if (remap_deadlist_obj != 0) {
 			dsl_deadlist_open(&ds->ds_remap_deadlist, mos,
 			    remap_deadlist_obj);
 		}
 
 		dmu_buf_init_user(&ds->ds_dbu, dsl_dataset_evict_sync,
 		    dsl_dataset_evict_async, &ds->ds_dbuf);
 		if (err == 0)
 			winner = dmu_buf_set_user_ie(dbuf, &ds->ds_dbu);
 
 		if (err != 0 || winner != NULL) {
 			dsl_deadlist_close(&ds->ds_deadlist);
 			if (dsl_deadlist_is_open(&ds->ds_remap_deadlist))
 				dsl_deadlist_close(&ds->ds_remap_deadlist);
 			dsl_bookmark_fini_ds(ds);
 after_dsl_bookmark_fini:
 			if (ds->ds_prev)
 				dsl_dataset_rele(ds->ds_prev, ds);
 			dsl_dir_rele(ds->ds_dir, ds);
 			for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
 				if (dsl_dataset_feature_is_active(ds, f))
 					unload_zfeature(ds, f);
 			}
 
 			list_destroy(&ds->ds_prop_cbs);
 			list_destroy(&ds->ds_sendstreams);
 			bplist_destroy(&ds->ds_pending_deadlist);
 			mutex_destroy(&ds->ds_lock);
 			mutex_destroy(&ds->ds_opening_lock);
 			mutex_destroy(&ds->ds_sendstream_lock);
 			mutex_destroy(&ds->ds_remap_deadlist_lock);
 			zfs_refcount_destroy(&ds->ds_longholds);
 			rrw_destroy(&ds->ds_bp_rwlock);
 			kmem_free(ds, sizeof (dsl_dataset_t));
 			if (err != 0) {
 				dmu_buf_rele(dbuf, tag);
 				return (err);
 			}
 			ds = winner;
 		} else {
 			ds->ds_fsid_guid =
 			    unique_insert(dsl_dataset_phys(ds)->ds_fsid_guid);
 			if (ds->ds_fsid_guid !=
 			    dsl_dataset_phys(ds)->ds_fsid_guid) {
 				zfs_dbgmsg("ds_fsid_guid changed from "
 				    "%llx to %llx for pool %s dataset id %llu",
 				    (long long)
 				    dsl_dataset_phys(ds)->ds_fsid_guid,
 				    (long long)ds->ds_fsid_guid,
 				    spa_name(dp->dp_spa),
 				    (u_longlong_t)dsobj);
 			}
 		}
 	}
 
 	ASSERT3P(ds->ds_dbuf, ==, dbuf);
 	ASSERT3P(dsl_dataset_phys(ds), ==, dbuf->db_data);
 	ASSERT(dsl_dataset_phys(ds)->ds_prev_snap_obj != 0 ||
 	    spa_version(dp->dp_spa) < SPA_VERSION_ORIGIN ||
 	    dp->dp_origin_snap == NULL || ds == dp->dp_origin_snap);
 	*dsp = ds;
 
 	return (0);
 }
 
 int
 dsl_dataset_create_key_mapping(dsl_dataset_t *ds)
 {
 	dsl_dir_t *dd = ds->ds_dir;
 
 	if (dd->dd_crypto_obj == 0)
 		return (0);
 
 	return (spa_keystore_create_mapping(dd->dd_pool->dp_spa,
 	    ds, ds, &ds->ds_key_mapping));
 }
 
 int
 dsl_dataset_hold_obj_flags(dsl_pool_t *dp, uint64_t dsobj,
     ds_hold_flags_t flags, const void *tag, dsl_dataset_t **dsp)
 {
 	int err;
 
 	err = dsl_dataset_hold_obj(dp, dsobj, tag, dsp);
 	if (err != 0)
 		return (err);
 
 	ASSERT3P(*dsp, !=, NULL);
 
 	if (flags & DS_HOLD_FLAG_DECRYPT) {
 		err = dsl_dataset_create_key_mapping(*dsp);
 		if (err != 0)
 			dsl_dataset_rele(*dsp, tag);
 	}
 
 	return (err);
 }
 
 int
 dsl_dataset_hold_flags(dsl_pool_t *dp, const char *name, ds_hold_flags_t flags,
     const void *tag, dsl_dataset_t **dsp)
 {
 	dsl_dir_t *dd;
 	const char *snapname;
 	uint64_t obj;
 	int err = 0;
 	dsl_dataset_t *ds;
 
 	err = dsl_dir_hold(dp, name, FTAG, &dd, &snapname);
 	if (err != 0)
 		return (err);
 
 	ASSERT(dsl_pool_config_held(dp));
 	obj = dsl_dir_phys(dd)->dd_head_dataset_obj;
 	if (obj != 0)
 		err = dsl_dataset_hold_obj_flags(dp, obj, flags, tag, &ds);
 	else
 		err = SET_ERROR(ENOENT);
 
 	/* we may be looking for a snapshot */
 	if (err == 0 && snapname != NULL) {
 		dsl_dataset_t *snap_ds;
 
 		if (*snapname++ != '@') {
 			dsl_dataset_rele_flags(ds, flags, tag);
 			dsl_dir_rele(dd, FTAG);
 			return (SET_ERROR(ENOENT));
 		}
 
 		dprintf("looking for snapshot '%s'\n", snapname);
 		err = dsl_dataset_snap_lookup(ds, snapname, &obj);
 		if (err == 0) {
 			err = dsl_dataset_hold_obj_flags(dp, obj, flags, tag,
 			    &snap_ds);
 		}
 		dsl_dataset_rele_flags(ds, flags, tag);
 
 		if (err == 0) {
 			mutex_enter(&snap_ds->ds_lock);
 			if (snap_ds->ds_snapname[0] == 0)
 				(void) strlcpy(snap_ds->ds_snapname, snapname,
 				    sizeof (snap_ds->ds_snapname));
 			mutex_exit(&snap_ds->ds_lock);
 			ds = snap_ds;
 		}
 	}
 	if (err == 0)
 		*dsp = ds;
 	dsl_dir_rele(dd, FTAG);
 	return (err);
 }
 
 int
 dsl_dataset_hold(dsl_pool_t *dp, const char *name, const void *tag,
     dsl_dataset_t **dsp)
 {
 	return (dsl_dataset_hold_flags(dp, name, 0, tag, dsp));
 }
 
 static int
 dsl_dataset_own_obj_impl(dsl_pool_t *dp, uint64_t dsobj, ds_hold_flags_t flags,
     const void *tag, boolean_t override, dsl_dataset_t **dsp)
 {
 	int err = dsl_dataset_hold_obj_flags(dp, dsobj, flags, tag, dsp);
 	if (err != 0)
 		return (err);
 	if (!dsl_dataset_tryown(*dsp, tag, override)) {
 		dsl_dataset_rele_flags(*dsp, flags, tag);
 		*dsp = NULL;
 		return (SET_ERROR(EBUSY));
 	}
 	return (0);
 }
 
 
 int
 dsl_dataset_own_obj(dsl_pool_t *dp, uint64_t dsobj, ds_hold_flags_t flags,
     const void *tag, dsl_dataset_t **dsp)
 {
 	return (dsl_dataset_own_obj_impl(dp, dsobj, flags, tag, B_FALSE, dsp));
 }
 
 int
 dsl_dataset_own_obj_force(dsl_pool_t *dp, uint64_t dsobj,
     ds_hold_flags_t flags, const void *tag, dsl_dataset_t **dsp)
 {
 	return (dsl_dataset_own_obj_impl(dp, dsobj, flags, tag, B_TRUE, dsp));
 }
 
 static int
 dsl_dataset_own_impl(dsl_pool_t *dp, const char *name, ds_hold_flags_t flags,
     const void *tag, boolean_t override, dsl_dataset_t **dsp)
 {
 	int err = dsl_dataset_hold_flags(dp, name, flags, tag, dsp);
 	if (err != 0)
 		return (err);
 	if (!dsl_dataset_tryown(*dsp, tag, override)) {
 		dsl_dataset_rele_flags(*dsp, flags, tag);
 		return (SET_ERROR(EBUSY));
 	}
 	return (0);
 }
 
 int
 dsl_dataset_own_force(dsl_pool_t *dp, const char *name, ds_hold_flags_t flags,
     const void *tag, dsl_dataset_t **dsp)
 {
 	return (dsl_dataset_own_impl(dp, name, flags, tag, B_TRUE, dsp));
 }
 
 int
 dsl_dataset_own(dsl_pool_t *dp, const char *name, ds_hold_flags_t flags,
     const void *tag, dsl_dataset_t **dsp)
 {
 	return (dsl_dataset_own_impl(dp, name, flags, tag, B_FALSE, dsp));
 }
 
 /*
  * See the comment above dsl_pool_hold() for details.  In summary, a long
  * hold is used to prevent destruction of a dataset while the pool hold
  * is dropped, allowing other concurrent operations (e.g. spa_sync()).
  *
  * The dataset and pool must be held when this function is called.  After it
  * is called, the pool hold may be released while the dataset is still held
  * and accessed.
  */
 void
 dsl_dataset_long_hold(dsl_dataset_t *ds, const void *tag)
 {
 	ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
 	(void) zfs_refcount_add(&ds->ds_longholds, tag);
 }
 
 void
 dsl_dataset_long_rele(dsl_dataset_t *ds, const void *tag)
 {
 	(void) zfs_refcount_remove(&ds->ds_longholds, tag);
 }
 
 /* Return B_TRUE if there are any long holds on this dataset. */
 boolean_t
 dsl_dataset_long_held(dsl_dataset_t *ds)
 {
 	return (!zfs_refcount_is_zero(&ds->ds_longholds));
 }
 
 void
 dsl_dataset_name(dsl_dataset_t *ds, char *name)
 {
 	if (ds == NULL) {
 		(void) strlcpy(name, "mos", ZFS_MAX_DATASET_NAME_LEN);
 	} else {
 		dsl_dir_name(ds->ds_dir, name);
 		VERIFY0(dsl_dataset_get_snapname(ds));
 		if (ds->ds_snapname[0]) {
 			VERIFY3U(strlcat(name, "@", ZFS_MAX_DATASET_NAME_LEN),
 			    <, ZFS_MAX_DATASET_NAME_LEN);
 			/*
 			 * We use a "recursive" mutex so that we
 			 * can call dprintf_ds() with ds_lock held.
 			 */
 			if (!MUTEX_HELD(&ds->ds_lock)) {
 				mutex_enter(&ds->ds_lock);
 				VERIFY3U(strlcat(name, ds->ds_snapname,
 				    ZFS_MAX_DATASET_NAME_LEN), <,
 				    ZFS_MAX_DATASET_NAME_LEN);
 				mutex_exit(&ds->ds_lock);
 			} else {
 				VERIFY3U(strlcat(name, ds->ds_snapname,
 				    ZFS_MAX_DATASET_NAME_LEN), <,
 				    ZFS_MAX_DATASET_NAME_LEN);
 			}
 		}
 	}
 }
 
 int
 dsl_dataset_namelen(dsl_dataset_t *ds)
 {
 	VERIFY0(dsl_dataset_get_snapname(ds));
 	mutex_enter(&ds->ds_lock);
 	int len = strlen(ds->ds_snapname);
 	mutex_exit(&ds->ds_lock);
 	/* add '@' if ds is a snap */
 	if (len > 0)
 		len++;
 	len += dsl_dir_namelen(ds->ds_dir);
 	return (len);
 }
 
 void
 dsl_dataset_rele(dsl_dataset_t *ds, const void *tag)
 {
 	dmu_buf_rele(ds->ds_dbuf, tag);
 }
 
 void
 dsl_dataset_remove_key_mapping(dsl_dataset_t *ds)
 {
 	dsl_dir_t *dd = ds->ds_dir;
 
 	if (dd == NULL || dd->dd_crypto_obj == 0)
 		return;
 
 	(void) spa_keystore_remove_mapping(dd->dd_pool->dp_spa,
 	    ds->ds_object, ds);
 }
 
 void
 dsl_dataset_rele_flags(dsl_dataset_t *ds, ds_hold_flags_t flags,
     const void *tag)
 {
 	if (flags & DS_HOLD_FLAG_DECRYPT)
 		dsl_dataset_remove_key_mapping(ds);
 
 	dsl_dataset_rele(ds, tag);
 }
 
 void
 dsl_dataset_disown(dsl_dataset_t *ds, ds_hold_flags_t flags, const void *tag)
 {
 	ASSERT3P(ds->ds_owner, ==, tag);
 	ASSERT(ds->ds_dbuf != NULL);
 
 	mutex_enter(&ds->ds_lock);
 	ds->ds_owner = NULL;
 	mutex_exit(&ds->ds_lock);
 	dsl_dataset_long_rele(ds, tag);
 	dsl_dataset_rele_flags(ds, flags, tag);
 }
 
 boolean_t
 dsl_dataset_tryown(dsl_dataset_t *ds, const void *tag, boolean_t override)
 {
 	boolean_t gotit = FALSE;
 
 	ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
 	mutex_enter(&ds->ds_lock);
 	if (ds->ds_owner == NULL && (override || !(DS_IS_INCONSISTENT(ds) ||
 	    (dsl_dataset_feature_is_active(ds,
 	    SPA_FEATURE_REDACTED_DATASETS) &&
 	    !zfs_allow_redacted_dataset_mount)))) {
 		ds->ds_owner = tag;
 		dsl_dataset_long_hold(ds, tag);
 		gotit = TRUE;
 	}
 	mutex_exit(&ds->ds_lock);
 	return (gotit);
 }
 
 boolean_t
 dsl_dataset_has_owner(dsl_dataset_t *ds)
 {
 	boolean_t rv;
 	mutex_enter(&ds->ds_lock);
 	rv = (ds->ds_owner != NULL);
 	mutex_exit(&ds->ds_lock);
 	return (rv);
 }
 
 static boolean_t
 zfeature_active(spa_feature_t f, void *arg)
 {
 	switch (spa_feature_table[f].fi_type) {
 	case ZFEATURE_TYPE_BOOLEAN: {
 		boolean_t val = (boolean_t)(uintptr_t)arg;
 		ASSERT(val == B_FALSE || val == B_TRUE);
 		return (val);
 	}
 	case ZFEATURE_TYPE_UINT64_ARRAY:
 		/*
 		 * In this case, arg is a uint64_t array.  The feature is active
 		 * if the array is non-null.
 		 */
 		return (arg != NULL);
 	default:
 		panic("Invalid zfeature type %d", spa_feature_table[f].fi_type);
 		return (B_FALSE);
 	}
 }
 
 boolean_t
 dsl_dataset_feature_is_active(dsl_dataset_t *ds, spa_feature_t f)
 {
 	return (zfeature_active(f, ds->ds_feature[f]));
 }
 
 /*
  * The buffers passed out by this function are references to internal buffers;
  * they should not be freed by callers of this function, and they should not be
  * used after the dataset has been released.
  */
 boolean_t
 dsl_dataset_get_uint64_array_feature(dsl_dataset_t *ds, spa_feature_t f,
     uint64_t *outlength, uint64_t **outp)
 {
 	VERIFY(spa_feature_table[f].fi_type & ZFEATURE_TYPE_UINT64_ARRAY);
 	if (!dsl_dataset_feature_is_active(ds, f)) {
 		return (B_FALSE);
 	}
 	struct feature_type_uint64_array_arg *ftuaa = ds->ds_feature[f];
 	*outp = ftuaa->array;
 	*outlength = ftuaa->length;
 	return (B_TRUE);
 }
 
 void
 dsl_dataset_activate_feature(uint64_t dsobj, spa_feature_t f, void *arg,
     dmu_tx_t *tx)
 {
 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
 	objset_t *mos = dmu_tx_pool(tx)->dp_meta_objset;
 	uint64_t zero = 0;
 
 	VERIFY(spa_feature_table[f].fi_flags & ZFEATURE_FLAG_PER_DATASET);
 
 	spa_feature_incr(spa, f, tx);
 	dmu_object_zapify(mos, dsobj, DMU_OT_DSL_DATASET, tx);
 
 	switch (spa_feature_table[f].fi_type) {
 	case ZFEATURE_TYPE_BOOLEAN:
 		ASSERT3S((boolean_t)(uintptr_t)arg, ==, B_TRUE);
 		VERIFY0(zap_add(mos, dsobj, spa_feature_table[f].fi_guid,
 		    sizeof (zero), 1, &zero, tx));
 		break;
 	case ZFEATURE_TYPE_UINT64_ARRAY:
 	{
 		struct feature_type_uint64_array_arg *ftuaa = arg;
 		VERIFY0(zap_add(mos, dsobj, spa_feature_table[f].fi_guid,
 		    sizeof (uint64_t), ftuaa->length, ftuaa->array, tx));
 		break;
 	}
 	default:
 		panic("Invalid zfeature type %d", spa_feature_table[f].fi_type);
 	}
 }
 
 static void
 dsl_dataset_deactivate_feature_impl(dsl_dataset_t *ds, spa_feature_t f,
     dmu_tx_t *tx)
 {
 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
 	objset_t *mos = dmu_tx_pool(tx)->dp_meta_objset;
 	uint64_t dsobj = ds->ds_object;
 
 	VERIFY(spa_feature_table[f].fi_flags & ZFEATURE_FLAG_PER_DATASET);
 
 	VERIFY0(zap_remove(mos, dsobj, spa_feature_table[f].fi_guid, tx));
 	spa_feature_decr(spa, f, tx);
 	ds->ds_feature[f] = NULL;
 }
 
 void
 dsl_dataset_deactivate_feature(dsl_dataset_t *ds, spa_feature_t f, dmu_tx_t *tx)
 {
 	unload_zfeature(ds, f);
 	dsl_dataset_deactivate_feature_impl(ds, f, tx);
 }
 
 uint64_t
 dsl_dataset_create_sync_dd(dsl_dir_t *dd, dsl_dataset_t *origin,
     dsl_crypto_params_t *dcp, uint64_t flags, dmu_tx_t *tx)
 {
 	dsl_pool_t *dp = dd->dd_pool;
 	dmu_buf_t *dbuf;
 	dsl_dataset_phys_t *dsphys;
 	uint64_t dsobj;
 	objset_t *mos = dp->dp_meta_objset;
 
 	if (origin == NULL)
 		origin = dp->dp_origin_snap;
 
 	ASSERT(origin == NULL || origin->ds_dir->dd_pool == dp);
 	ASSERT(origin == NULL || dsl_dataset_phys(origin)->ds_num_children > 0);
 	ASSERT(dmu_tx_is_syncing(tx));
 	ASSERT(dsl_dir_phys(dd)->dd_head_dataset_obj == 0);
 
 	dsobj = dmu_object_alloc(mos, DMU_OT_DSL_DATASET, 0,
 	    DMU_OT_DSL_DATASET, sizeof (dsl_dataset_phys_t), tx);
 	VERIFY0(dmu_bonus_hold(mos, dsobj, FTAG, &dbuf));
 	dmu_buf_will_dirty(dbuf, tx);
 	dsphys = dbuf->db_data;
 	memset(dsphys, 0, sizeof (dsl_dataset_phys_t));
 	dsphys->ds_dir_obj = dd->dd_object;
 	dsphys->ds_flags = flags;
 	dsphys->ds_fsid_guid = unique_create();
 	(void) random_get_pseudo_bytes((void*)&dsphys->ds_guid,
 	    sizeof (dsphys->ds_guid));
 	dsphys->ds_snapnames_zapobj =
 	    zap_create_norm(mos, U8_TEXTPREP_TOUPPER, DMU_OT_DSL_DS_SNAP_MAP,
 	    DMU_OT_NONE, 0, tx);
 	dsphys->ds_creation_time = gethrestime_sec();
 	dsphys->ds_creation_txg = tx->tx_txg == TXG_INITIAL ? 1 : tx->tx_txg;
 
 	if (origin == NULL) {
 		dsphys->ds_deadlist_obj = dsl_deadlist_alloc(mos, tx);
 	} else {
 		dsl_dataset_t *ohds; /* head of the origin snapshot */
 
 		dsphys->ds_prev_snap_obj = origin->ds_object;
 		dsphys->ds_prev_snap_txg =
 		    dsl_dataset_phys(origin)->ds_creation_txg;
 		dsphys->ds_referenced_bytes =
 		    dsl_dataset_phys(origin)->ds_referenced_bytes;
 		dsphys->ds_compressed_bytes =
 		    dsl_dataset_phys(origin)->ds_compressed_bytes;
 		dsphys->ds_uncompressed_bytes =
 		    dsl_dataset_phys(origin)->ds_uncompressed_bytes;
 		rrw_enter(&origin->ds_bp_rwlock, RW_READER, FTAG);
 		dsphys->ds_bp = dsl_dataset_phys(origin)->ds_bp;
 		rrw_exit(&origin->ds_bp_rwlock, FTAG);
 
 		/*
 		 * Inherit flags that describe the dataset's contents
 		 * (INCONSISTENT) or properties (Case Insensitive).
 		 */
 		dsphys->ds_flags |= dsl_dataset_phys(origin)->ds_flags &
 		    (DS_FLAG_INCONSISTENT | DS_FLAG_CI_DATASET);
 
 		for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
 			if (zfeature_active(f, origin->ds_feature[f])) {
 				dsl_dataset_activate_feature(dsobj, f,
 				    origin->ds_feature[f], tx);
 			}
 		}
 
 		dmu_buf_will_dirty(origin->ds_dbuf, tx);
 		dsl_dataset_phys(origin)->ds_num_children++;
 
 		VERIFY0(dsl_dataset_hold_obj(dp,
 		    dsl_dir_phys(origin->ds_dir)->dd_head_dataset_obj,
 		    FTAG, &ohds));
 		dsphys->ds_deadlist_obj = dsl_deadlist_clone(&ohds->ds_deadlist,
 		    dsphys->ds_prev_snap_txg, dsphys->ds_prev_snap_obj, tx);
 		dsl_dataset_rele(ohds, FTAG);
 
 		if (spa_version(dp->dp_spa) >= SPA_VERSION_NEXT_CLONES) {
 			if (dsl_dataset_phys(origin)->ds_next_clones_obj == 0) {
 				dsl_dataset_phys(origin)->ds_next_clones_obj =
 				    zap_create(mos,
 				    DMU_OT_NEXT_CLONES, DMU_OT_NONE, 0, tx);
 			}
 			VERIFY0(zap_add_int(mos,
 			    dsl_dataset_phys(origin)->ds_next_clones_obj,
 			    dsobj, tx));
 		}
 
 		dmu_buf_will_dirty(dd->dd_dbuf, tx);
 		dsl_dir_phys(dd)->dd_origin_obj = origin->ds_object;
 		if (spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
 			if (dsl_dir_phys(origin->ds_dir)->dd_clones == 0) {
 				dmu_buf_will_dirty(origin->ds_dir->dd_dbuf, tx);
 				dsl_dir_phys(origin->ds_dir)->dd_clones =
 				    zap_create(mos,
 				    DMU_OT_DSL_CLONES, DMU_OT_NONE, 0, tx);
 			}
 			VERIFY0(zap_add_int(mos,
 			    dsl_dir_phys(origin->ds_dir)->dd_clones,
 			    dsobj, tx));
 		}
 	}
 
 	/* handle encryption */
 	dsl_dataset_create_crypt_sync(dsobj, dd, origin, dcp, tx);
 
 	if (spa_version(dp->dp_spa) >= SPA_VERSION_UNIQUE_ACCURATE)
 		dsphys->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
 
 	dmu_buf_rele(dbuf, FTAG);
 
 	dmu_buf_will_dirty(dd->dd_dbuf, tx);
 	dsl_dir_phys(dd)->dd_head_dataset_obj = dsobj;
 
 	return (dsobj);
 }
 
 static void
 dsl_dataset_zero_zil(dsl_dataset_t *ds, dmu_tx_t *tx)
 {
 	objset_t *os;
 
 	VERIFY0(dmu_objset_from_ds(ds, &os));
 	if (memcmp(&os->os_zil_header, &zero_zil, sizeof (zero_zil)) != 0) {
 		dsl_pool_t *dp = ds->ds_dir->dd_pool;
 		zio_t *zio;
 
 		memset(&os->os_zil_header, 0, sizeof (os->os_zil_header));
 		if (os->os_encrypted)
 			os->os_next_write_raw[tx->tx_txg & TXG_MASK] = B_TRUE;
 
 		zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
 		dsl_dataset_sync(ds, zio, tx);
 		VERIFY0(zio_wait(zio));
 		dsl_dataset_sync_done(ds, tx);
 	}
 }
 
 uint64_t
 dsl_dataset_create_sync(dsl_dir_t *pdd, const char *lastname,
     dsl_dataset_t *origin, uint64_t flags, cred_t *cr,
     dsl_crypto_params_t *dcp, dmu_tx_t *tx)
 {
 	dsl_pool_t *dp = pdd->dd_pool;
 	uint64_t dsobj, ddobj;
 	dsl_dir_t *dd;
 
 	ASSERT(dmu_tx_is_syncing(tx));
 	ASSERT(lastname[0] != '@');
 	/*
 	 * Filesystems will eventually have their origin set to dp_origin_snap,
 	 * but that's taken care of in dsl_dataset_create_sync_dd. When
 	 * creating a filesystem, this function is called with origin equal to
 	 * NULL.
 	 */
 	if (origin != NULL)
 		ASSERT3P(origin, !=, dp->dp_origin_snap);
 
 	ddobj = dsl_dir_create_sync(dp, pdd, lastname, tx);
 	VERIFY0(dsl_dir_hold_obj(dp, ddobj, lastname, FTAG, &dd));
 
 	dsobj = dsl_dataset_create_sync_dd(dd, origin, dcp,
 	    flags & ~DS_CREATE_FLAG_NODIRTY, tx);
 
 	dsl_deleg_set_create_perms(dd, tx, cr);
 
 	/*
 	 * If we are creating a clone and the livelist feature is enabled,
 	 * add the entry DD_FIELD_LIVELIST to ZAP.
 	 */
 	if (origin != NULL &&
 	    spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_LIVELIST)) {
 		objset_t *mos = dd->dd_pool->dp_meta_objset;
 		dsl_dir_zapify(dd, tx);
 		uint64_t obj = dsl_deadlist_alloc(mos, tx);
 		VERIFY0(zap_add(mos, dd->dd_object, DD_FIELD_LIVELIST,
 		    sizeof (uint64_t), 1, &obj, tx));
 		spa_feature_incr(dp->dp_spa, SPA_FEATURE_LIVELIST, tx);
 	}
 
 	/*
 	 * Since we're creating a new node we know it's a leaf, so we can
 	 * initialize the counts if the limit feature is active.
 	 */
 	if (spa_feature_is_active(dp->dp_spa, SPA_FEATURE_FS_SS_LIMIT)) {
 		uint64_t cnt = 0;
 		objset_t *os = dd->dd_pool->dp_meta_objset;
 
 		dsl_dir_zapify(dd, tx);
 		VERIFY0(zap_add(os, dd->dd_object, DD_FIELD_FILESYSTEM_COUNT,
 		    sizeof (cnt), 1, &cnt, tx));
 		VERIFY0(zap_add(os, dd->dd_object, DD_FIELD_SNAPSHOT_COUNT,
 		    sizeof (cnt), 1, &cnt, tx));
 	}
 
 	dsl_dir_rele(dd, FTAG);
 
 	/*
 	 * If we are creating a clone, make sure we zero out any stale
 	 * data from the origin snapshots zil header.
 	 */
 	if (origin != NULL && !(flags & DS_CREATE_FLAG_NODIRTY)) {
 		dsl_dataset_t *ds;
 
 		VERIFY0(dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds));
 		dsl_dataset_zero_zil(ds, tx);
 		dsl_dataset_rele(ds, FTAG);
 	}
 
 	return (dsobj);
 }
 
 /*
  * The unique space in the head dataset can be calculated by subtracting
  * the space used in the most recent snapshot, that is still being used
  * in this file system, from the space currently in use.  To figure out
  * the space in the most recent snapshot still in use, we need to take
  * the total space used in the snapshot and subtract out the space that
  * has been freed up since the snapshot was taken.
  */
 void
 dsl_dataset_recalc_head_uniq(dsl_dataset_t *ds)
 {
 	uint64_t mrs_used;
 	uint64_t dlused, dlcomp, dluncomp;
 
 	ASSERT(!ds->ds_is_snapshot);
 
 	if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0)
 		mrs_used = dsl_dataset_phys(ds->ds_prev)->ds_referenced_bytes;
 	else
 		mrs_used = 0;
 
 	dsl_deadlist_space(&ds->ds_deadlist, &dlused, &dlcomp, &dluncomp);
 
 	ASSERT3U(dlused, <=, mrs_used);
 	dsl_dataset_phys(ds)->ds_unique_bytes =
 	    dsl_dataset_phys(ds)->ds_referenced_bytes - (mrs_used - dlused);
 
 	if (spa_version(ds->ds_dir->dd_pool->dp_spa) >=
 	    SPA_VERSION_UNIQUE_ACCURATE)
 		dsl_dataset_phys(ds)->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
 }
 
 void
 dsl_dataset_remove_from_next_clones(dsl_dataset_t *ds, uint64_t obj,
     dmu_tx_t *tx)
 {
 	objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
 	uint64_t count __maybe_unused;
 	int err;
 
 	ASSERT(dsl_dataset_phys(ds)->ds_num_children >= 2);
 	err = zap_remove_int(mos, dsl_dataset_phys(ds)->ds_next_clones_obj,
 	    obj, tx);
 	/*
 	 * The err should not be ENOENT, but a bug in a previous version
 	 * of the code could cause upgrade_clones_cb() to not set
 	 * ds_next_snap_obj when it should, leading to a missing entry.
 	 * If we knew that the pool was created after
 	 * SPA_VERSION_NEXT_CLONES, we could assert that it isn't
 	 * ENOENT.  However, at least we can check that we don't have
 	 * too many entries in the next_clones_obj even after failing to
 	 * remove this one.
 	 */
 	if (err != ENOENT)
 		VERIFY0(err);
 	ASSERT0(zap_count(mos, dsl_dataset_phys(ds)->ds_next_clones_obj,
 	    &count));
 	ASSERT3U(count, <=, dsl_dataset_phys(ds)->ds_num_children - 2);
 }
 
 
 blkptr_t *
 dsl_dataset_get_blkptr(dsl_dataset_t *ds)
 {
 	return (&dsl_dataset_phys(ds)->ds_bp);
 }
 
 spa_t *
 dsl_dataset_get_spa(dsl_dataset_t *ds)
 {
 	return (ds->ds_dir->dd_pool->dp_spa);
 }
 
 void
 dsl_dataset_dirty(dsl_dataset_t *ds, dmu_tx_t *tx)
 {
 	dsl_pool_t *dp;
 
 	if (ds == NULL) /* this is the meta-objset */
 		return;
 
 	ASSERT(ds->ds_objset != NULL);
 
 	if (dsl_dataset_phys(ds)->ds_next_snap_obj != 0)
 		panic("dirtying snapshot!");
 
 	/* Must not dirty a dataset in the same txg where it got snapshotted. */
 	ASSERT3U(tx->tx_txg, >, dsl_dataset_phys(ds)->ds_prev_snap_txg);
 
 	dp = ds->ds_dir->dd_pool;
 	if (txg_list_add(&dp->dp_dirty_datasets, ds, tx->tx_txg)) {
 		objset_t *os = ds->ds_objset;
 
 		/* up the hold count until we can be written out */
 		dmu_buf_add_ref(ds->ds_dbuf, ds);
 
 		/* if this dataset is encrypted, grab a reference to the DCK */
 		if (ds->ds_dir->dd_crypto_obj != 0 &&
 		    !os->os_raw_receive &&
 		    !os->os_next_write_raw[tx->tx_txg & TXG_MASK]) {
 			ASSERT3P(ds->ds_key_mapping, !=, NULL);
 			key_mapping_add_ref(ds->ds_key_mapping, ds);
 		}
 	}
 }
 
 static int
 dsl_dataset_snapshot_reserve_space(dsl_dataset_t *ds, dmu_tx_t *tx)
 {
 	uint64_t asize;
 
 	if (!dmu_tx_is_syncing(tx))
 		return (0);
 
 	/*
 	 * If there's an fs-only reservation, any blocks that might become
 	 * owned by the snapshot dataset must be accommodated by space
 	 * outside of the reservation.
 	 */
 	ASSERT(ds->ds_reserved == 0 || DS_UNIQUE_IS_ACCURATE(ds));
 	asize = MIN(dsl_dataset_phys(ds)->ds_unique_bytes, ds->ds_reserved);
 	if (asize > dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE))
 		return (SET_ERROR(ENOSPC));
 
 	/*
 	 * Propagate any reserved space for this snapshot to other
 	 * snapshot checks in this sync group.
 	 */
 	if (asize > 0)
 		dsl_dir_willuse_space(ds->ds_dir, asize, tx);
 
 	return (0);
 }
 
 int
 dsl_dataset_snapshot_check_impl(dsl_dataset_t *ds, const char *snapname,
     dmu_tx_t *tx, boolean_t recv, uint64_t cnt, cred_t *cr, proc_t *proc)
 {
 	int error;
 	uint64_t value;
 
 	ds->ds_trysnap_txg = tx->tx_txg;
 
 	if (!dmu_tx_is_syncing(tx))
 		return (0);
 
 	/*
 	 * We don't allow multiple snapshots of the same txg.  If there
 	 * is already one, try again.
 	 */
 	if (dsl_dataset_phys(ds)->ds_prev_snap_txg >= tx->tx_txg)
 		return (SET_ERROR(EAGAIN));
 
 	/*
 	 * Check for conflicting snapshot name.
 	 */
 	error = dsl_dataset_snap_lookup(ds, snapname, &value);
 	if (error == 0)
 		return (SET_ERROR(EEXIST));
 	if (error != ENOENT)
 		return (error);
 
 	/*
 	 * We don't allow taking snapshots of inconsistent datasets, such as
 	 * those into which we are currently receiving.  However, if we are
 	 * creating this snapshot as part of a receive, this check will be
 	 * executed atomically with respect to the completion of the receive
 	 * itself but prior to the clearing of DS_FLAG_INCONSISTENT; in this
 	 * case we ignore this, knowing it will be fixed up for us shortly in
 	 * dmu_recv_end_sync().
 	 */
 	if (!recv && DS_IS_INCONSISTENT(ds))
 		return (SET_ERROR(EBUSY));
 
 	/*
 	 * Skip the check for temporary snapshots or if we have already checked
 	 * the counts in dsl_dataset_snapshot_check. This means we really only
 	 * check the count here when we're receiving a stream.
 	 */
 	if (cnt != 0 && cr != NULL) {
 		error = dsl_fs_ss_limit_check(ds->ds_dir, cnt,
 		    ZFS_PROP_SNAPSHOT_LIMIT, NULL, cr, proc);
 		if (error != 0)
 			return (error);
 	}
 
 	error = dsl_dataset_snapshot_reserve_space(ds, tx);
 	if (error != 0)
 		return (error);
 
 	return (0);
 }
 
 int
 dsl_dataset_snapshot_check(void *arg, dmu_tx_t *tx)
 {
 	dsl_dataset_snapshot_arg_t *ddsa = arg;
 	dsl_pool_t *dp = dmu_tx_pool(tx);
 	nvpair_t *pair;
 	int rv = 0;
 
 	/*
 	 * Pre-compute how many total new snapshots will be created for each
 	 * level in the tree and below. This is needed for validating the
 	 * snapshot limit when either taking a recursive snapshot or when
 	 * taking multiple snapshots.
 	 *
 	 * The problem is that the counts are not actually adjusted when
 	 * we are checking, only when we finally sync. For a single snapshot,
 	 * this is easy, the count will increase by 1 at each node up the tree,
 	 * but its more complicated for the recursive/multiple snapshot case.
 	 *
 	 * The dsl_fs_ss_limit_check function does recursively check the count
 	 * at each level up the tree but since it is validating each snapshot
 	 * independently we need to be sure that we are validating the complete
 	 * count for the entire set of snapshots. We do this by rolling up the
 	 * counts for each component of the name into an nvlist and then
 	 * checking each of those cases with the aggregated count.
 	 *
 	 * This approach properly handles not only the recursive snapshot
 	 * case (where we get all of those on the ddsa_snaps list) but also
 	 * the sibling case (e.g. snapshot a/b and a/c so that we will also
 	 * validate the limit on 'a' using a count of 2).
 	 *
 	 * We validate the snapshot names in the third loop and only report
 	 * name errors once.
 	 */
 	if (dmu_tx_is_syncing(tx)) {
 		char *nm;
 		nvlist_t *cnt_track = NULL;
 		cnt_track = fnvlist_alloc();
 
 		nm = kmem_alloc(MAXPATHLEN, KM_SLEEP);
 
 		/* Rollup aggregated counts into the cnt_track list */
 		for (pair = nvlist_next_nvpair(ddsa->ddsa_snaps, NULL);
 		    pair != NULL;
 		    pair = nvlist_next_nvpair(ddsa->ddsa_snaps, pair)) {
 			char *pdelim;
 			uint64_t val;
 
 			(void) strlcpy(nm, nvpair_name(pair), MAXPATHLEN);
 			pdelim = strchr(nm, '@');
 			if (pdelim == NULL)
 				continue;
 			*pdelim = '\0';
 
 			do {
 				if (nvlist_lookup_uint64(cnt_track, nm,
 				    &val) == 0) {
 					/* update existing entry */
 					fnvlist_add_uint64(cnt_track, nm,
 					    val + 1);
 				} else {
 					/* add to list */
 					fnvlist_add_uint64(cnt_track, nm, 1);
 				}
 
 				pdelim = strrchr(nm, '/');
 				if (pdelim != NULL)
 					*pdelim = '\0';
 			} while (pdelim != NULL);
 		}
 
 		kmem_free(nm, MAXPATHLEN);
 
 		/* Check aggregated counts at each level */
 		for (pair = nvlist_next_nvpair(cnt_track, NULL);
 		    pair != NULL; pair = nvlist_next_nvpair(cnt_track, pair)) {
 			int error = 0;
 			const char *name;
 			uint64_t cnt = 0;
 			dsl_dataset_t *ds;
 
 			name = nvpair_name(pair);
 			cnt = fnvpair_value_uint64(pair);
 			ASSERT(cnt > 0);
 
 			error = dsl_dataset_hold(dp, name, FTAG, &ds);
 			if (error == 0) {
 				error = dsl_fs_ss_limit_check(ds->ds_dir, cnt,
 				    ZFS_PROP_SNAPSHOT_LIMIT, NULL,
 				    ddsa->ddsa_cr, ddsa->ddsa_proc);
 				dsl_dataset_rele(ds, FTAG);
 			}
 
 			if (error != 0) {
 				if (ddsa->ddsa_errors != NULL)
 					fnvlist_add_int32(ddsa->ddsa_errors,
 					    name, error);
 				rv = error;
 				/* only report one error for this check */
 				break;
 			}
 		}
 		nvlist_free(cnt_track);
 	}
 
 	for (pair = nvlist_next_nvpair(ddsa->ddsa_snaps, NULL);
 	    pair != NULL; pair = nvlist_next_nvpair(ddsa->ddsa_snaps, pair)) {
 		int error = 0;
 		dsl_dataset_t *ds;
 		const char *name, *atp = NULL;
 		char dsname[ZFS_MAX_DATASET_NAME_LEN];
 
 		name = nvpair_name(pair);
 		if (strlen(name) >= ZFS_MAX_DATASET_NAME_LEN)
 			error = SET_ERROR(ENAMETOOLONG);
 		if (error == 0) {
 			atp = strchr(name, '@');
 			if (atp == NULL)
 				error = SET_ERROR(EINVAL);
 			if (error == 0)
 				(void) strlcpy(dsname, name, atp - name + 1);
 		}
 		if (error == 0)
 			error = dsl_dataset_hold(dp, dsname, FTAG, &ds);
 		if (error == 0) {
 			/* passing 0/NULL skips dsl_fs_ss_limit_check */
 			error = dsl_dataset_snapshot_check_impl(ds,
 			    atp + 1, tx, B_FALSE, 0, NULL, NULL);
 			dsl_dataset_rele(ds, FTAG);
 		}
 
 		if (error != 0) {
 			if (ddsa->ddsa_errors != NULL) {
 				fnvlist_add_int32(ddsa->ddsa_errors,
 				    name, error);
 			}
 			rv = error;
 		}
 	}
 
 	return (rv);
 }
 
 void
 dsl_dataset_snapshot_sync_impl(dsl_dataset_t *ds, const char *snapname,
     dmu_tx_t *tx)
 {
 	dsl_pool_t *dp = ds->ds_dir->dd_pool;
 	dmu_buf_t *dbuf;
 	dsl_dataset_phys_t *dsphys;
 	uint64_t dsobj, crtxg;
 	objset_t *mos = dp->dp_meta_objset;
 	objset_t *os __maybe_unused;
 
 	ASSERT(RRW_WRITE_HELD(&dp->dp_config_rwlock));
 
 	/*
 	 * If we are on an old pool, the zil must not be active, in which
 	 * case it will be zeroed.  Usually zil_suspend() accomplishes this.
 	 */
 	ASSERT(spa_version(dmu_tx_pool(tx)->dp_spa) >= SPA_VERSION_FAST_SNAP ||
 	    dmu_objset_from_ds(ds, &os) != 0 ||
 	    memcmp(&os->os_phys->os_zil_header, &zero_zil,
 	    sizeof (zero_zil)) == 0);
 
 	/* Should not snapshot a dirty dataset. */
 	ASSERT(!txg_list_member(&ds->ds_dir->dd_pool->dp_dirty_datasets,
 	    ds, tx->tx_txg));
 
 	dsl_fs_ss_count_adjust(ds->ds_dir, 1, DD_FIELD_SNAPSHOT_COUNT, tx);
 
 	/*
 	 * The origin's ds_creation_txg has to be < TXG_INITIAL
 	 */
 	if (strcmp(snapname, ORIGIN_DIR_NAME) == 0)
 		crtxg = 1;
 	else
 		crtxg = tx->tx_txg;
 
 	dsobj = dmu_object_alloc(mos, DMU_OT_DSL_DATASET, 0,
 	    DMU_OT_DSL_DATASET, sizeof (dsl_dataset_phys_t), tx);
 	VERIFY0(dmu_bonus_hold(mos, dsobj, FTAG, &dbuf));
 	dmu_buf_will_dirty(dbuf, tx);
 	dsphys = dbuf->db_data;
 	memset(dsphys, 0, sizeof (dsl_dataset_phys_t));
 	dsphys->ds_dir_obj = ds->ds_dir->dd_object;
 	dsphys->ds_fsid_guid = unique_create();
 	(void) random_get_pseudo_bytes((void*)&dsphys->ds_guid,
 	    sizeof (dsphys->ds_guid));
 	dsphys->ds_prev_snap_obj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
 	dsphys->ds_prev_snap_txg = dsl_dataset_phys(ds)->ds_prev_snap_txg;
 	dsphys->ds_next_snap_obj = ds->ds_object;
 	dsphys->ds_num_children = 1;
 	dsphys->ds_creation_time = gethrestime_sec();
 	dsphys->ds_creation_txg = crtxg;
 	dsphys->ds_deadlist_obj = dsl_dataset_phys(ds)->ds_deadlist_obj;
 	dsphys->ds_referenced_bytes = dsl_dataset_phys(ds)->ds_referenced_bytes;
 	dsphys->ds_compressed_bytes = dsl_dataset_phys(ds)->ds_compressed_bytes;
 	dsphys->ds_uncompressed_bytes =
 	    dsl_dataset_phys(ds)->ds_uncompressed_bytes;
 	dsphys->ds_flags = dsl_dataset_phys(ds)->ds_flags;
 	rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
 	dsphys->ds_bp = dsl_dataset_phys(ds)->ds_bp;
 	rrw_exit(&ds->ds_bp_rwlock, FTAG);
 	dmu_buf_rele(dbuf, FTAG);
 
 	for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
 		if (zfeature_active(f, ds->ds_feature[f])) {
 			dsl_dataset_activate_feature(dsobj, f,
 			    ds->ds_feature[f], tx);
 		}
 	}
 
 	ASSERT3U(ds->ds_prev != 0, ==,
 	    dsl_dataset_phys(ds)->ds_prev_snap_obj != 0);
 	if (ds->ds_prev) {
 		uint64_t next_clones_obj =
 		    dsl_dataset_phys(ds->ds_prev)->ds_next_clones_obj;
 		ASSERT(dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj ==
 		    ds->ds_object ||
 		    dsl_dataset_phys(ds->ds_prev)->ds_num_children > 1);
 		if (dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj ==
 		    ds->ds_object) {
 			dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx);
 			ASSERT3U(dsl_dataset_phys(ds)->ds_prev_snap_txg, ==,
 			    dsl_dataset_phys(ds->ds_prev)->ds_creation_txg);
 			dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj = dsobj;
 		} else if (next_clones_obj != 0) {
 			dsl_dataset_remove_from_next_clones(ds->ds_prev,
 			    dsphys->ds_next_snap_obj, tx);
 			VERIFY0(zap_add_int(mos,
 			    next_clones_obj, dsobj, tx));
 		}
 	}
 
 	/*
 	 * If we have a reference-reservation on this dataset, we will
 	 * need to increase the amount of refreservation being charged
 	 * since our unique space is going to zero.
 	 */
 	if (ds->ds_reserved) {
 		int64_t delta;
 		ASSERT(DS_UNIQUE_IS_ACCURATE(ds));
 		delta = MIN(dsl_dataset_phys(ds)->ds_unique_bytes,
 		    ds->ds_reserved);
 		dsl_dir_diduse_space(ds->ds_dir, DD_USED_REFRSRV,
 		    delta, 0, 0, tx);
 	}
 
 	dmu_buf_will_dirty(ds->ds_dbuf, tx);
 	dsl_dataset_phys(ds)->ds_deadlist_obj =
 	    dsl_deadlist_clone(&ds->ds_deadlist, UINT64_MAX,
 	    dsl_dataset_phys(ds)->ds_prev_snap_obj, tx);
 	dsl_deadlist_close(&ds->ds_deadlist);
 	dsl_deadlist_open(&ds->ds_deadlist, mos,
 	    dsl_dataset_phys(ds)->ds_deadlist_obj);
 	dsl_deadlist_add_key(&ds->ds_deadlist,
 	    dsl_dataset_phys(ds)->ds_prev_snap_txg, tx);
 	dsl_bookmark_snapshotted(ds, tx);
 
 	if (dsl_dataset_remap_deadlist_exists(ds)) {
 		uint64_t remap_deadlist_obj =
 		    dsl_dataset_get_remap_deadlist_object(ds);
 		/*
 		 * Move the remap_deadlist to the snapshot.  The head
 		 * will create a new remap deadlist on demand, from
 		 * dsl_dataset_block_remapped().
 		 */
 		dsl_dataset_unset_remap_deadlist_object(ds, tx);
 		dsl_deadlist_close(&ds->ds_remap_deadlist);
 
 		dmu_object_zapify(mos, dsobj, DMU_OT_DSL_DATASET, tx);
 		VERIFY0(zap_add(mos, dsobj, DS_FIELD_REMAP_DEADLIST,
 		    sizeof (remap_deadlist_obj), 1, &remap_deadlist_obj, tx));
 	}
 
 	/*
 	 * Create a ivset guid for this snapshot if the dataset is
 	 * encrypted. This may be overridden by a raw receive. A
 	 * previous implementation of this code did not have this
 	 * field as part of the on-disk format for ZFS encryption
 	 * (see errata #4). As part of the remediation for this
 	 * issue, we ask the user to enable the bookmark_v2 feature
 	 * which is now a dependency of the encryption feature. We
 	 * use this as a heuristic to determine when the user has
 	 * elected to correct any datasets created with the old code.
 	 * As a result, we only do this step if the bookmark_v2
 	 * feature is enabled, which limits the number of states a
 	 * given pool / dataset can be in with regards to terms of
 	 * correcting the issue.
 	 */
 	if (ds->ds_dir->dd_crypto_obj != 0 &&
 	    spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_BOOKMARK_V2)) {
 		uint64_t ivset_guid = unique_create();
 
 		dmu_object_zapify(mos, dsobj, DMU_OT_DSL_DATASET, tx);
 		VERIFY0(zap_add(mos, dsobj, DS_FIELD_IVSET_GUID,
 		    sizeof (ivset_guid), 1, &ivset_guid, tx));
 	}
 
 	ASSERT3U(dsl_dataset_phys(ds)->ds_prev_snap_txg, <, tx->tx_txg);
 	dsl_dataset_phys(ds)->ds_prev_snap_obj = dsobj;
 	dsl_dataset_phys(ds)->ds_prev_snap_txg = crtxg;
 	dsl_dataset_phys(ds)->ds_unique_bytes = 0;
 
 	if (spa_version(dp->dp_spa) >= SPA_VERSION_UNIQUE_ACCURATE)
 		dsl_dataset_phys(ds)->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
 
 	VERIFY0(zap_add(mos, dsl_dataset_phys(ds)->ds_snapnames_zapobj,
 	    snapname, 8, 1, &dsobj, tx));
 
 	if (ds->ds_prev)
 		dsl_dataset_rele(ds->ds_prev, ds);
 	VERIFY0(dsl_dataset_hold_obj(dp,
 	    dsl_dataset_phys(ds)->ds_prev_snap_obj, ds, &ds->ds_prev));
 
 	dsl_scan_ds_snapshotted(ds, tx);
 
 	dsl_dir_snap_cmtime_update(ds->ds_dir, tx);
 
 	if (zfs_snapshot_history_enabled)
 		spa_history_log_internal_ds(ds->ds_prev, "snapshot", tx, " ");
 }
 
 void
 dsl_dataset_snapshot_sync(void *arg, dmu_tx_t *tx)
 {
 	dsl_dataset_snapshot_arg_t *ddsa = arg;
 	dsl_pool_t *dp = dmu_tx_pool(tx);
 	nvpair_t *pair;
 
 	for (pair = nvlist_next_nvpair(ddsa->ddsa_snaps, NULL);
 	    pair != NULL; pair = nvlist_next_nvpair(ddsa->ddsa_snaps, pair)) {
 		dsl_dataset_t *ds;
 		const char *name, *atp;
 		char dsname[ZFS_MAX_DATASET_NAME_LEN];
 
 		name = nvpair_name(pair);
 		atp = strchr(name, '@');
 		(void) strlcpy(dsname, name, atp - name + 1);
 		VERIFY0(dsl_dataset_hold(dp, dsname, FTAG, &ds));
 
 		dsl_dataset_snapshot_sync_impl(ds, atp + 1, tx);
 		if (ddsa->ddsa_props != NULL) {
 			dsl_props_set_sync_impl(ds->ds_prev,
 			    ZPROP_SRC_LOCAL, ddsa->ddsa_props, tx);
 		}
 		dsl_dataset_rele(ds, FTAG);
 	}
 }
 
 /*
  * The snapshots must all be in the same pool.
  * All-or-nothing: if there are any failures, nothing will be modified.
  */
 int
 dsl_dataset_snapshot(nvlist_t *snaps, nvlist_t *props, nvlist_t *errors)
 {
 	dsl_dataset_snapshot_arg_t ddsa;
 	nvpair_t *pair;
 	boolean_t needsuspend;
 	int error;
 	spa_t *spa;
 	const char *firstname;
 	nvlist_t *suspended = NULL;
 
 	pair = nvlist_next_nvpair(snaps, NULL);
 	if (pair == NULL)
 		return (0);
 	firstname = nvpair_name(pair);
 
 	error = spa_open(firstname, &spa, FTAG);
 	if (error != 0)
 		return (error);
 	needsuspend = (spa_version(spa) < SPA_VERSION_FAST_SNAP);
 	spa_close(spa, FTAG);
 
 	if (needsuspend) {
 		suspended = fnvlist_alloc();
 		for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL;
 		    pair = nvlist_next_nvpair(snaps, pair)) {
 			char fsname[ZFS_MAX_DATASET_NAME_LEN];
 			const char *snapname = nvpair_name(pair);
 			const char *atp;
 			void *cookie;
 
 			atp = strchr(snapname, '@');
 			if (atp == NULL) {
 				error = SET_ERROR(EINVAL);
 				break;
 			}
 			(void) strlcpy(fsname, snapname, atp - snapname + 1);
 
 			error = zil_suspend(fsname, &cookie);
 			if (error != 0)
 				break;
 			fnvlist_add_uint64(suspended, fsname,
 			    (uintptr_t)cookie);
 		}
 	}
 
 	ddsa.ddsa_snaps = snaps;
 	ddsa.ddsa_props = props;
 	ddsa.ddsa_errors = errors;
 	ddsa.ddsa_cr = CRED();
 	ddsa.ddsa_proc = curproc;
 
 	if (error == 0) {
 		error = dsl_sync_task(firstname, dsl_dataset_snapshot_check,
 		    dsl_dataset_snapshot_sync, &ddsa,
 		    fnvlist_num_pairs(snaps) * 3, ZFS_SPACE_CHECK_NORMAL);
 	}
 
 	if (suspended != NULL) {
 		for (pair = nvlist_next_nvpair(suspended, NULL); pair != NULL;
 		    pair = nvlist_next_nvpair(suspended, pair)) {
 			zil_resume((void *)(uintptr_t)
 			    fnvpair_value_uint64(pair));
 		}
 		fnvlist_free(suspended);
 	}
 
 	if (error == 0) {
 		for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL;
 		    pair = nvlist_next_nvpair(snaps, pair)) {
 			zvol_create_minor(nvpair_name(pair));
 		}
 	}
 
 	return (error);
 }
 
 typedef struct dsl_dataset_snapshot_tmp_arg {
 	const char *ddsta_fsname;
 	const char *ddsta_snapname;
 	minor_t ddsta_cleanup_minor;
 	const char *ddsta_htag;
 } dsl_dataset_snapshot_tmp_arg_t;
 
 static int
 dsl_dataset_snapshot_tmp_check(void *arg, dmu_tx_t *tx)
 {
 	dsl_dataset_snapshot_tmp_arg_t *ddsta = arg;
 	dsl_pool_t *dp = dmu_tx_pool(tx);
 	dsl_dataset_t *ds;
 	int error;
 
 	error = dsl_dataset_hold(dp, ddsta->ddsta_fsname, FTAG, &ds);
 	if (error != 0)
 		return (error);
 
 	/* NULL cred means no limit check for tmp snapshot */
 	error = dsl_dataset_snapshot_check_impl(ds, ddsta->ddsta_snapname,
 	    tx, B_FALSE, 0, NULL, NULL);
 	if (error != 0) {
 		dsl_dataset_rele(ds, FTAG);
 		return (error);
 	}
 
 	if (spa_version(dp->dp_spa) < SPA_VERSION_USERREFS) {
 		dsl_dataset_rele(ds, FTAG);
 		return (SET_ERROR(ENOTSUP));
 	}
 	error = dsl_dataset_user_hold_check_one(NULL, ddsta->ddsta_htag,
 	    B_TRUE, tx);
 	if (error != 0) {
 		dsl_dataset_rele(ds, FTAG);
 		return (error);
 	}
 
 	dsl_dataset_rele(ds, FTAG);
 	return (0);
 }
 
 static void
 dsl_dataset_snapshot_tmp_sync(void *arg, dmu_tx_t *tx)
 {
 	dsl_dataset_snapshot_tmp_arg_t *ddsta = arg;
 	dsl_pool_t *dp = dmu_tx_pool(tx);
 	dsl_dataset_t *ds = NULL;
 
 	VERIFY0(dsl_dataset_hold(dp, ddsta->ddsta_fsname, FTAG, &ds));
 
 	dsl_dataset_snapshot_sync_impl(ds, ddsta->ddsta_snapname, tx);
 	dsl_dataset_user_hold_sync_one(ds->ds_prev, ddsta->ddsta_htag,
 	    ddsta->ddsta_cleanup_minor, gethrestime_sec(), tx);
 	dsl_destroy_snapshot_sync_impl(ds->ds_prev, B_TRUE, tx);
 
 	dsl_dataset_rele(ds, FTAG);
 }
 
 int
 dsl_dataset_snapshot_tmp(const char *fsname, const char *snapname,
     minor_t cleanup_minor, const char *htag)
 {
 	dsl_dataset_snapshot_tmp_arg_t ddsta;
 	int error;
 	spa_t *spa;
 	boolean_t needsuspend;
 	void *cookie;
 
 	ddsta.ddsta_fsname = fsname;
 	ddsta.ddsta_snapname = snapname;
 	ddsta.ddsta_cleanup_minor = cleanup_minor;
 	ddsta.ddsta_htag = htag;
 
 	error = spa_open(fsname, &spa, FTAG);
 	if (error != 0)
 		return (error);
 	needsuspend = (spa_version(spa) < SPA_VERSION_FAST_SNAP);
 	spa_close(spa, FTAG);
 
 	if (needsuspend) {
 		error = zil_suspend(fsname, &cookie);
 		if (error != 0)
 			return (error);
 	}
 
 	error = dsl_sync_task(fsname, dsl_dataset_snapshot_tmp_check,
 	    dsl_dataset_snapshot_tmp_sync, &ddsta, 3, ZFS_SPACE_CHECK_RESERVED);
 
 	if (needsuspend)
 		zil_resume(cookie);
 	return (error);
 }
 
 /* Nonblocking dataset sync. Assumes dataset:objset is always 1:1 */
 void
 dsl_dataset_sync(dsl_dataset_t *ds, zio_t *rio, dmu_tx_t *tx)
 {
 	ASSERT(dmu_tx_is_syncing(tx));
 	ASSERT(ds->ds_objset != NULL);
 	ASSERT(dsl_dataset_phys(ds)->ds_next_snap_obj == 0);
 
 	/*
 	 * in case we had to change ds_fsid_guid when we opened it,
 	 * sync it out now.
 	 */
 	dmu_buf_will_dirty(ds->ds_dbuf, tx);
 	dsl_dataset_phys(ds)->ds_fsid_guid = ds->ds_fsid_guid;
 
 	if (ds->ds_resume_bytes[tx->tx_txg & TXG_MASK] != 0) {
 		VERIFY0(zap_update(tx->tx_pool->dp_meta_objset,
 		    ds->ds_object, DS_FIELD_RESUME_OBJECT, 8, 1,
 		    &ds->ds_resume_object[tx->tx_txg & TXG_MASK], tx));
 		VERIFY0(zap_update(tx->tx_pool->dp_meta_objset,
 		    ds->ds_object, DS_FIELD_RESUME_OFFSET, 8, 1,
 		    &ds->ds_resume_offset[tx->tx_txg & TXG_MASK], tx));
 		VERIFY0(zap_update(tx->tx_pool->dp_meta_objset,
 		    ds->ds_object, DS_FIELD_RESUME_BYTES, 8, 1,
 		    &ds->ds_resume_bytes[tx->tx_txg & TXG_MASK], tx));
 		ds->ds_resume_object[tx->tx_txg & TXG_MASK] = 0;
 		ds->ds_resume_offset[tx->tx_txg & TXG_MASK] = 0;
 		ds->ds_resume_bytes[tx->tx_txg & TXG_MASK] = 0;
 	}
 
 	dmu_objset_sync(ds->ds_objset, rio, tx);
 }
 
 /*
  * Check if the percentage of blocks shared between the clone and the
  * snapshot (as opposed to those that are clone only) is below a certain
  * threshold
  */
 static boolean_t
 dsl_livelist_should_disable(dsl_dataset_t *ds)
 {
 	uint64_t used, referenced;
 	int percent_shared;
 
 	used = dsl_dir_get_usedds(ds->ds_dir);
 	referenced = dsl_get_referenced(ds);
 	if (referenced == 0)
 		return (B_FALSE);
 	percent_shared = (100 * (referenced - used)) / referenced;
 	if (percent_shared <= zfs_livelist_min_percent_shared)
 		return (B_TRUE);
 	return (B_FALSE);
 }
 
 /*
  *  Check if it is possible to combine two livelist entries into one.
  *  This is the case if the combined number of 'live' blkptrs (ALLOCs that
  *  don't have a matching FREE) is under the maximum sublist size.
  *  We check this by subtracting twice the total number of frees from the total
  *  number of blkptrs. FREEs are counted twice because each FREE blkptr
  *  will cancel out an ALLOC blkptr when the livelist is processed.
  */
 static boolean_t
 dsl_livelist_should_condense(dsl_deadlist_entry_t *first,
     dsl_deadlist_entry_t *next)
 {
 	uint64_t total_free = first->dle_bpobj.bpo_phys->bpo_num_freed +
 	    next->dle_bpobj.bpo_phys->bpo_num_freed;
 	uint64_t total_entries = first->dle_bpobj.bpo_phys->bpo_num_blkptrs +
 	    next->dle_bpobj.bpo_phys->bpo_num_blkptrs;
 	if ((total_entries - (2 * total_free)) < zfs_livelist_max_entries)
 		return (B_TRUE);
 	return (B_FALSE);
 }
 
 typedef struct try_condense_arg {
 	spa_t *spa;
 	dsl_dataset_t *ds;
 } try_condense_arg_t;
 
 /*
  * Iterate over the livelist entries, searching for a pair to condense.
  * A nonzero return value means stop, 0 means keep looking.
  */
 static int
 dsl_livelist_try_condense(void *arg, dsl_deadlist_entry_t *first)
 {
 	try_condense_arg_t *tca = arg;
 	spa_t *spa = tca->spa;
 	dsl_dataset_t *ds = tca->ds;
 	dsl_deadlist_t *ll = &ds->ds_dir->dd_livelist;
 	dsl_deadlist_entry_t *next;
 
 	/* The condense thread has not yet been created at import */
 	if (spa->spa_livelist_condense_zthr == NULL)
 		return (1);
 
 	/* A condense is already in progress */
 	if (spa->spa_to_condense.ds != NULL)
 		return (1);
 
 	next = AVL_NEXT(&ll->dl_tree, &first->dle_node);
 	/* The livelist has only one entry - don't condense it */
 	if (next == NULL)
 		return (1);
 
 	/* Next is the newest entry - don't condense it */
 	if (AVL_NEXT(&ll->dl_tree, &next->dle_node) == NULL)
 		return (1);
 
 	/* This pair is not ready to condense but keep looking */
 	if (!dsl_livelist_should_condense(first, next))
 		return (0);
 
 	/*
 	 * Add a ref to prevent the dataset from being evicted while
 	 * the condense zthr or synctask are running. Ref will be
 	 * released at the end of the condense synctask
 	 */
 	dmu_buf_add_ref(ds->ds_dbuf, spa);
 
 	spa->spa_to_condense.ds = ds;
 	spa->spa_to_condense.first = first;
 	spa->spa_to_condense.next = next;
 	spa->spa_to_condense.syncing = B_FALSE;
 	spa->spa_to_condense.cancelled = B_FALSE;
 
 	zthr_wakeup(spa->spa_livelist_condense_zthr);
 	return (1);
 }
 
 static void
 dsl_flush_pending_livelist(dsl_dataset_t *ds, dmu_tx_t *tx)
 {
 	dsl_dir_t *dd = ds->ds_dir;
 	spa_t *spa = ds->ds_dir->dd_pool->dp_spa;
 	dsl_deadlist_entry_t *last = dsl_deadlist_last(&dd->dd_livelist);
 
 	/* Check if we need to add a new sub-livelist */
 	if (last == NULL) {
 		/* The livelist is empty */
 		dsl_deadlist_add_key(&dd->dd_livelist,
 		    tx->tx_txg - 1, tx);
 	} else if (spa_sync_pass(spa) == 1) {
 		/*
 		 * Check if the newest entry is full. If it is, make a new one.
 		 * We only do this once per sync because we could overfill a
 		 * sublist in one sync pass and don't want to add another entry
 		 * for a txg that is already represented. This ensures that
 		 * blkptrs born in the same txg are stored in the same sublist.
 		 */
 		bpobj_t bpobj = last->dle_bpobj;
 		uint64_t all = bpobj.bpo_phys->bpo_num_blkptrs;
 		uint64_t free = bpobj.bpo_phys->bpo_num_freed;
 		uint64_t alloc = all - free;
 		if (alloc > zfs_livelist_max_entries) {
 			dsl_deadlist_add_key(&dd->dd_livelist,
 			    tx->tx_txg - 1, tx);
 		}
 	}
 
 	/* Insert each entry into the on-disk livelist */
 	bplist_iterate(&dd->dd_pending_allocs,
 	    dsl_deadlist_insert_alloc_cb, &dd->dd_livelist, tx);
 	bplist_iterate(&dd->dd_pending_frees,
 	    dsl_deadlist_insert_free_cb, &dd->dd_livelist, tx);
 
 	/* Attempt to condense every pair of adjacent entries */
 	try_condense_arg_t arg = {
 	    .spa = spa,
 	    .ds = ds
 	};
 	dsl_deadlist_iterate(&dd->dd_livelist, dsl_livelist_try_condense,
 	    &arg);
 }
 
 void
 dsl_dataset_sync_done(dsl_dataset_t *ds, dmu_tx_t *tx)
 {
 	objset_t *os = ds->ds_objset;
 
 	bplist_iterate(&ds->ds_pending_deadlist,
 	    dsl_deadlist_insert_alloc_cb, &ds->ds_deadlist, tx);
 
 	if (dsl_deadlist_is_open(&ds->ds_dir->dd_livelist)) {
 		dsl_flush_pending_livelist(ds, tx);
 		if (dsl_livelist_should_disable(ds)) {
 			dsl_dir_remove_livelist(ds->ds_dir, tx, B_TRUE);
 		}
 	}
 
 	dsl_bookmark_sync_done(ds, tx);
 
 	multilist_destroy(&os->os_synced_dnodes);
 
 	if (os->os_encrypted)
 		os->os_next_write_raw[tx->tx_txg & TXG_MASK] = B_FALSE;
 	else
 		ASSERT0(os->os_next_write_raw[tx->tx_txg & TXG_MASK]);
 
 	for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
 		if (zfeature_active(f,
 		    ds->ds_feature_activation[f])) {
 			if (zfeature_active(f, ds->ds_feature[f]))
 				continue;
 			dsl_dataset_activate_feature(ds->ds_object, f,
 			    ds->ds_feature_activation[f], tx);
 			ds->ds_feature[f] = ds->ds_feature_activation[f];
 		}
 	}
 
 	ASSERT(!dmu_objset_is_dirty(os, dmu_tx_get_txg(tx)));
 }
 
 int
 get_clones_stat_impl(dsl_dataset_t *ds, nvlist_t *val)
 {
 	uint64_t count = 0;
 	objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
 	zap_cursor_t zc;
 	zap_attribute_t *za;
 
 	ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
 
 	/*
 	 * There may be missing entries in ds_next_clones_obj
 	 * due to a bug in a previous version of the code.
 	 * Only trust it if it has the right number of entries.
 	 */
 	if (dsl_dataset_phys(ds)->ds_next_clones_obj != 0) {
 		VERIFY0(zap_count(mos, dsl_dataset_phys(ds)->ds_next_clones_obj,
 		    &count));
 	}
 	if (count != dsl_dataset_phys(ds)->ds_num_children - 1) {
 		return (SET_ERROR(ENOENT));
 	}
 
 	za = zap_attribute_alloc();
 	for (zap_cursor_init(&zc, mos,
 	    dsl_dataset_phys(ds)->ds_next_clones_obj);
 	    zap_cursor_retrieve(&zc, za) == 0;
 	    zap_cursor_advance(&zc)) {
 		dsl_dataset_t *clone;
 		char buf[ZFS_MAX_DATASET_NAME_LEN];
 		VERIFY0(dsl_dataset_hold_obj(ds->ds_dir->dd_pool,
 		    za->za_first_integer, FTAG, &clone));
 		dsl_dir_name(clone->ds_dir, buf);
 		fnvlist_add_boolean(val, buf);
 		dsl_dataset_rele(clone, FTAG);
 	}
 	zap_cursor_fini(&zc);
 	zap_attribute_free(za);
 	return (0);
 }
 
 void
 get_clones_stat(dsl_dataset_t *ds, nvlist_t *nv)
 {
 	nvlist_t *propval = fnvlist_alloc();
 	nvlist_t *val = fnvlist_alloc();
 
 	if (get_clones_stat_impl(ds, val) == 0) {
 		fnvlist_add_nvlist(propval, ZPROP_VALUE, val);
 		fnvlist_add_nvlist(nv, zfs_prop_to_name(ZFS_PROP_CLONES),
 		    propval);
 	}
 
 	nvlist_free(val);
 	nvlist_free(propval);
 }
 
 static char *
 get_receive_resume_token_impl(dsl_dataset_t *ds)
 {
 	if (!dsl_dataset_has_resume_receive_state(ds))
 		return (NULL);
 
 	dsl_pool_t *dp = ds->ds_dir->dd_pool;
 	char *str;
 	void *packed;
 	uint8_t *compressed;
 	uint64_t val;
 	nvlist_t *token_nv = fnvlist_alloc();
 	size_t packed_size, compressed_size;
 
 	if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
 	    DS_FIELD_RESUME_FROMGUID, sizeof (val), 1, &val) == 0) {
 		fnvlist_add_uint64(token_nv, "fromguid", val);
 	}
 	if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
 	    DS_FIELD_RESUME_OBJECT, sizeof (val), 1, &val) == 0) {
 		fnvlist_add_uint64(token_nv, "object", val);
 	}
 	if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
 	    DS_FIELD_RESUME_OFFSET, sizeof (val), 1, &val) == 0) {
 		fnvlist_add_uint64(token_nv, "offset", val);
 	}
 	if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
 	    DS_FIELD_RESUME_BYTES, sizeof (val), 1, &val) == 0) {
 		fnvlist_add_uint64(token_nv, "bytes", val);
 	}
 	if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
 	    DS_FIELD_RESUME_TOGUID, sizeof (val), 1, &val) == 0) {
 		fnvlist_add_uint64(token_nv, "toguid", val);
 	}
 	char buf[MAXNAMELEN];
 	if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
 	    DS_FIELD_RESUME_TONAME, 1, sizeof (buf), buf) == 0) {
 		fnvlist_add_string(token_nv, "toname", buf);
 	}
 	if (zap_contains(dp->dp_meta_objset, ds->ds_object,
 	    DS_FIELD_RESUME_LARGEBLOCK) == 0) {
 		fnvlist_add_boolean(token_nv, "largeblockok");
 	}
 	if (zap_contains(dp->dp_meta_objset, ds->ds_object,
 	    DS_FIELD_RESUME_EMBEDOK) == 0) {
 		fnvlist_add_boolean(token_nv, "embedok");
 	}
 	if (zap_contains(dp->dp_meta_objset, ds->ds_object,
 	    DS_FIELD_RESUME_COMPRESSOK) == 0) {
 		fnvlist_add_boolean(token_nv, "compressok");
 	}
 	if (zap_contains(dp->dp_meta_objset, ds->ds_object,
 	    DS_FIELD_RESUME_RAWOK) == 0) {
 		fnvlist_add_boolean(token_nv, "rawok");
 	}
 	if (dsl_dataset_feature_is_active(ds,
 	    SPA_FEATURE_REDACTED_DATASETS)) {
 		uint64_t num_redact_snaps = 0;
 		uint64_t *redact_snaps = NULL;
 		VERIFY3B(dsl_dataset_get_uint64_array_feature(ds,
 		    SPA_FEATURE_REDACTED_DATASETS, &num_redact_snaps,
 		    &redact_snaps), ==, B_TRUE);
 		fnvlist_add_uint64_array(token_nv, "redact_snaps",
 		    redact_snaps, num_redact_snaps);
 	}
 	if (zap_contains(dp->dp_meta_objset, ds->ds_object,
 	    DS_FIELD_RESUME_REDACT_BOOKMARK_SNAPS) == 0) {
 		uint64_t num_redact_snaps = 0, int_size = 0;
 		uint64_t *redact_snaps = NULL;
 		VERIFY0(zap_length(dp->dp_meta_objset, ds->ds_object,
 		    DS_FIELD_RESUME_REDACT_BOOKMARK_SNAPS, &int_size,
 		    &num_redact_snaps));
 		ASSERT3U(int_size, ==, sizeof (uint64_t));
 
 		redact_snaps = kmem_alloc(int_size * num_redact_snaps,
 		    KM_SLEEP);
 		VERIFY0(zap_lookup(dp->dp_meta_objset, ds->ds_object,
 		    DS_FIELD_RESUME_REDACT_BOOKMARK_SNAPS, int_size,
 		    num_redact_snaps, redact_snaps));
 		fnvlist_add_uint64_array(token_nv, "book_redact_snaps",
 		    redact_snaps, num_redact_snaps);
 		kmem_free(redact_snaps, int_size * num_redact_snaps);
 	}
 	packed = fnvlist_pack(token_nv, &packed_size);
 	fnvlist_free(token_nv);
 	compressed = kmem_alloc(packed_size, KM_SLEEP);
 
 	/* Call compress function directly to avoid hole detection. */
 	abd_t pabd, cabd;
 	abd_get_from_buf_struct(&pabd, packed, packed_size);
 	abd_get_from_buf_struct(&cabd, compressed, packed_size);
 	compressed_size = zfs_gzip_compress(&pabd, &cabd,
 	    packed_size, packed_size, 6);
 	abd_free(&cabd);
 	abd_free(&pabd);
 
 	zio_cksum_t cksum;
 	fletcher_4_native_varsize(compressed, compressed_size, &cksum);
 
 	size_t alloc_size = compressed_size * 2 + 1;
 	str = kmem_alloc(alloc_size, KM_SLEEP);
 	for (int i = 0; i < compressed_size; i++) {
 		size_t offset = i * 2;
 		(void) snprintf(str + offset, alloc_size - offset,
 	    "%02x", compressed[i]);
 	}
 	str[compressed_size * 2] = '\0';
 	char *propval = kmem_asprintf("%u-%llx-%llx-%s",
 	    ZFS_SEND_RESUME_TOKEN_VERSION,
 	    (longlong_t)cksum.zc_word[0],
 	    (longlong_t)packed_size, str);
 	kmem_free(packed, packed_size);
 	kmem_free(str, alloc_size);
 	kmem_free(compressed, packed_size);
 	return (propval);
 }
 
 /*
  * Returns a string that represents the receive resume state token. It should
  * be freed with strfree(). NULL is returned if no resume state is present.
  */
 char *
 get_receive_resume_token(dsl_dataset_t *ds)
 {
 	/*
 	 * A failed "newfs" (e.g. full) resumable receive leaves
 	 * the stats set on this dataset.  Check here for the prop.
 	 */
 	char *token = get_receive_resume_token_impl(ds);
 	if (token != NULL)
 		return (token);
 	/*
 	 * A failed incremental resumable receive leaves the
 	 * stats set on our child named "%recv".  Check the child
 	 * for the prop.
 	 */
 	/* 6 extra bytes for /%recv */
 	char name[ZFS_MAX_DATASET_NAME_LEN + 6];
 	dsl_dataset_t *recv_ds;
 	dsl_dataset_name(ds, name);
 	if (strlcat(name, "/", sizeof (name)) < sizeof (name) &&
 	    strlcat(name, recv_clone_name, sizeof (name)) < sizeof (name) &&
 	    dsl_dataset_hold(ds->ds_dir->dd_pool, name, FTAG, &recv_ds) == 0) {
 		token = get_receive_resume_token_impl(recv_ds);
 		dsl_dataset_rele(recv_ds, FTAG);
 	}
 	return (token);
 }
 
 uint64_t
 dsl_get_refratio(dsl_dataset_t *ds)
 {
 	uint64_t ratio = dsl_dataset_phys(ds)->ds_compressed_bytes == 0 ? 100 :
 	    (dsl_dataset_phys(ds)->ds_uncompressed_bytes * 100 /
 	    dsl_dataset_phys(ds)->ds_compressed_bytes);
 	return (ratio);
 }
 
 uint64_t
 dsl_get_logicalreferenced(dsl_dataset_t *ds)
 {
 	return (dsl_dataset_phys(ds)->ds_uncompressed_bytes);
 }
 
 uint64_t
 dsl_get_compressratio(dsl_dataset_t *ds)
 {
 	if (ds->ds_is_snapshot) {
 		return (dsl_get_refratio(ds));
 	} else {
 		dsl_dir_t *dd = ds->ds_dir;
 		mutex_enter(&dd->dd_lock);
 		uint64_t val = dsl_dir_get_compressratio(dd);
 		mutex_exit(&dd->dd_lock);
 		return (val);
 	}
 }
 
 uint64_t
 dsl_get_used(dsl_dataset_t *ds)
 {
 	if (ds->ds_is_snapshot) {
 		return (dsl_dataset_phys(ds)->ds_unique_bytes);
 	} else {
 		dsl_dir_t *dd = ds->ds_dir;
 		mutex_enter(&dd->dd_lock);
 		uint64_t val = dsl_dir_get_used(dd);
 		mutex_exit(&dd->dd_lock);
 		return (val);
 	}
 }
 
 uint64_t
 dsl_get_creation(dsl_dataset_t *ds)
 {
 	return (dsl_dataset_phys(ds)->ds_creation_time);
 }
 
 uint64_t
 dsl_get_creationtxg(dsl_dataset_t *ds)
 {
 	return (dsl_dataset_phys(ds)->ds_creation_txg);
 }
 
 uint64_t
 dsl_get_refquota(dsl_dataset_t *ds)
 {
 	return (ds->ds_quota);
 }
 
 uint64_t
 dsl_get_refreservation(dsl_dataset_t *ds)
 {
 	return (ds->ds_reserved);
 }
 
 uint64_t
 dsl_get_guid(dsl_dataset_t *ds)
 {
 	return (dsl_dataset_phys(ds)->ds_guid);
 }
 
 uint64_t
 dsl_get_unique(dsl_dataset_t *ds)
 {
 	return (dsl_dataset_phys(ds)->ds_unique_bytes);
 }
 
 uint64_t
 dsl_get_objsetid(dsl_dataset_t *ds)
 {
 	return (ds->ds_object);
 }
 
 uint64_t
 dsl_get_userrefs(dsl_dataset_t *ds)
 {
 	return (ds->ds_userrefs);
 }
 
 uint64_t
 dsl_get_defer_destroy(dsl_dataset_t *ds)
 {
 	return (DS_IS_DEFER_DESTROY(ds) ? 1 : 0);
 }
 
 uint64_t
 dsl_get_referenced(dsl_dataset_t *ds)
 {
 	return (dsl_dataset_phys(ds)->ds_referenced_bytes);
 }
 
 uint64_t
 dsl_get_numclones(dsl_dataset_t *ds)
 {
 	ASSERT(ds->ds_is_snapshot);
 	return (dsl_dataset_phys(ds)->ds_num_children - 1);
 }
 
 uint64_t
 dsl_get_inconsistent(dsl_dataset_t *ds)
 {
 	return ((dsl_dataset_phys(ds)->ds_flags & DS_FLAG_INCONSISTENT) ?
 	    1 : 0);
 }
 
 uint64_t
 dsl_get_redacted(dsl_dataset_t *ds)
 {
 	return (dsl_dataset_feature_is_active(ds,
 	    SPA_FEATURE_REDACTED_DATASETS));
 }
 
 uint64_t
 dsl_get_available(dsl_dataset_t *ds)
 {
 	uint64_t refdbytes = dsl_get_referenced(ds);
 	uint64_t availbytes = dsl_dir_space_available(ds->ds_dir,
 	    NULL, 0, TRUE);
 	if (ds->ds_reserved > dsl_dataset_phys(ds)->ds_unique_bytes) {
 		availbytes +=
 		    ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes;
 	}
 	if (ds->ds_quota != 0) {
 		/*
 		 * Adjust available bytes according to refquota
 		 */
 		if (refdbytes < ds->ds_quota) {
 			availbytes = MIN(availbytes,
 			    ds->ds_quota - refdbytes);
 		} else {
 			availbytes = 0;
 		}
 	}
 	return (availbytes);
 }
 
 int
 dsl_get_written(dsl_dataset_t *ds, uint64_t *written)
 {
 	dsl_pool_t *dp = ds->ds_dir->dd_pool;
 	dsl_dataset_t *prev;
 	int err = dsl_dataset_hold_obj(dp,
 	    dsl_dataset_phys(ds)->ds_prev_snap_obj, FTAG, &prev);
 	if (err == 0) {
 		uint64_t comp, uncomp;
 		err = dsl_dataset_space_written(prev, ds, written,
 		    &comp, &uncomp);
 		dsl_dataset_rele(prev, FTAG);
 	}
 	return (err);
 }
 
 /*
  * 'snap' should be a buffer of size ZFS_MAX_DATASET_NAME_LEN.
  */
 int
 dsl_get_prev_snap(dsl_dataset_t *ds, char *snap)
 {
 	dsl_pool_t *dp = ds->ds_dir->dd_pool;
 	if (ds->ds_prev != NULL && ds->ds_prev != dp->dp_origin_snap) {
 		dsl_dataset_name(ds->ds_prev, snap);
 		return (0);
 	} else {
 		return (SET_ERROR(ENOENT));
 	}
 }
 
 void
 dsl_get_redact_snaps(dsl_dataset_t *ds, nvlist_t *propval)
 {
 	uint64_t nsnaps;
 	uint64_t *snaps;
 	if (dsl_dataset_get_uint64_array_feature(ds,
 	    SPA_FEATURE_REDACTED_DATASETS, &nsnaps, &snaps)) {
 		fnvlist_add_uint64_array(propval, ZPROP_VALUE, snaps,
 		    nsnaps);
 	}
 }
 
 /*
  * Returns the mountpoint property and source for the given dataset in the value
  * and source buffers. The value buffer must be at least as large as MAXPATHLEN
  * and the source buffer as least as large a ZFS_MAX_DATASET_NAME_LEN.
  * Returns 0 on success and an error on failure.
  */
 int
 dsl_get_mountpoint(dsl_dataset_t *ds, const char *dsname, char *value,
     char *source)
 {
 	int error;
 	dsl_pool_t *dp = ds->ds_dir->dd_pool;
 
 	/* Retrieve the mountpoint value stored in the zap object */
 	error = dsl_prop_get_ds(ds, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), 1,
 	    ZAP_MAXVALUELEN, value, source);
 	if (error != 0) {
 		return (error);
 	}
 
 	/*
 	 * Process the dsname and source to find the full mountpoint string.
 	 * Can be skipped for 'legacy' or 'none'.
 	 */
 	if (value[0] == '/') {
 		char *buf = kmem_alloc(ZAP_MAXVALUELEN, KM_SLEEP);
 		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 {
 			ASSERT0(strncmp(dsname, source, strlen(source)));
 			relpath = dsname + strlen(source);
 			if (relpath[0] == '/')
 				relpath++;
 		}
 
 		spa_altroot(dp->dp_spa, root, ZAP_MAXVALUELEN);
 
 		/*
 		 * 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.
 		 */
 		char *mnt = value;
 		if (value[1] == '\0' && (root[0] != '\0' ||
 		    relpath[0] != '\0'))
 			mnt = value + 1;
 
 		mnt = kmem_strdup(mnt);
 
 		if (relpath[0] == '\0') {
 			(void) snprintf(value, ZAP_MAXVALUELEN, "%s%s",
 			    root, mnt);
 		} else {
 			(void) snprintf(value, ZAP_MAXVALUELEN, "%s%s%s%s",
 			    root, mnt, relpath[0] == '@' ? "" : "/",
 			    relpath);
 		}
 		kmem_free(buf, ZAP_MAXVALUELEN);
 		kmem_strfree(mnt);
 	}
 
 	return (0);
 }
 
 void
 dsl_dataset_stats(dsl_dataset_t *ds, nvlist_t *nv)
 {
 	dsl_pool_t *dp __maybe_unused = ds->ds_dir->dd_pool;
 
 	ASSERT(dsl_pool_config_held(dp));
 
 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFRATIO,
 	    dsl_get_refratio(ds));
 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_LOGICALREFERENCED,
 	    dsl_get_logicalreferenced(ds));
 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_COMPRESSRATIO,
 	    dsl_get_compressratio(ds));
 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USED,
 	    dsl_get_used(ds));
 
 	if (ds->ds_is_snapshot) {
 		get_clones_stat(ds, nv);
 	} else {
 		char buf[ZFS_MAX_DATASET_NAME_LEN];
 		if (dsl_get_prev_snap(ds, buf) == 0)
 			dsl_prop_nvlist_add_string(nv, ZFS_PROP_PREV_SNAP,
 			    buf);
 		dsl_dir_stats(ds->ds_dir, nv);
 	}
 
 	nvlist_t *propval = fnvlist_alloc();
 	dsl_get_redact_snaps(ds, propval);
 	fnvlist_add_nvlist(nv, zfs_prop_to_name(ZFS_PROP_REDACT_SNAPS),
 	    propval);
 	nvlist_free(propval);
 
 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_AVAILABLE,
 	    dsl_get_available(ds));
 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFERENCED,
 	    dsl_get_referenced(ds));
 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_CREATION,
 	    dsl_get_creation(ds));
 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_CREATETXG,
 	    dsl_get_creationtxg(ds));
 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFQUOTA,
 	    dsl_get_refquota(ds));
 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFRESERVATION,
 	    dsl_get_refreservation(ds));
 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_GUID,
 	    dsl_get_guid(ds));
 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_UNIQUE,
 	    dsl_get_unique(ds));
 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_OBJSETID,
 	    dsl_get_objsetid(ds));
 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USERREFS,
 	    dsl_get_userrefs(ds));
 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_DEFER_DESTROY,
 	    dsl_get_defer_destroy(ds));
 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_SNAPSHOTS_CHANGED,
 	    dsl_dir_snap_cmtime(ds->ds_dir).tv_sec);
 	dsl_dataset_crypt_stats(ds, nv);
 
 	if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0) {
 		uint64_t written;
 		if (dsl_get_written(ds, &written) == 0) {
 			dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_WRITTEN,
 			    written);
 		}
 	}
 
 	if (!dsl_dataset_is_snapshot(ds)) {
 		char *token = get_receive_resume_token(ds);
 		if (token != NULL) {
 			dsl_prop_nvlist_add_string(nv,
 			    ZFS_PROP_RECEIVE_RESUME_TOKEN, token);
 			kmem_strfree(token);
 		}
 	}
 }
 
 void
 dsl_dataset_fast_stat(dsl_dataset_t *ds, dmu_objset_stats_t *stat)
 {
 	dsl_pool_t *dp __maybe_unused = ds->ds_dir->dd_pool;
 	ASSERT(dsl_pool_config_held(dp));
 
 	stat->dds_creation_txg = dsl_get_creationtxg(ds);
 	stat->dds_inconsistent = dsl_get_inconsistent(ds);
 	stat->dds_guid = dsl_get_guid(ds);
 	stat->dds_redacted = dsl_get_redacted(ds);
 	stat->dds_origin[0] = '\0';
 	if (ds->ds_is_snapshot) {
 		stat->dds_is_snapshot = B_TRUE;
 		stat->dds_num_clones = dsl_get_numclones(ds);
 	} else {
 		stat->dds_is_snapshot = B_FALSE;
 		stat->dds_num_clones = 0;
 
 		if (dsl_dir_is_clone(ds->ds_dir)) {
 			dsl_dir_get_origin(ds->ds_dir, stat->dds_origin);
 		}
 	}
 }
 
 uint64_t
 dsl_dataset_fsid_guid(dsl_dataset_t *ds)
 {
 	return (ds->ds_fsid_guid);
 }
 
 void
 dsl_dataset_space(dsl_dataset_t *ds,
     uint64_t *refdbytesp, uint64_t *availbytesp,
     uint64_t *usedobjsp, uint64_t *availobjsp)
 {
 	*refdbytesp = dsl_dataset_phys(ds)->ds_referenced_bytes;
 	*availbytesp = dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE);
 	if (ds->ds_reserved > dsl_dataset_phys(ds)->ds_unique_bytes)
 		*availbytesp +=
 		    ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes;
 	if (ds->ds_quota != 0) {
 		/*
 		 * Adjust available bytes according to refquota
 		 */
 		if (*refdbytesp < ds->ds_quota)
 			*availbytesp = MIN(*availbytesp,
 			    ds->ds_quota - *refdbytesp);
 		else
 			*availbytesp = 0;
 	}
 	rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
 	*usedobjsp = BP_GET_FILL(&dsl_dataset_phys(ds)->ds_bp);
 	rrw_exit(&ds->ds_bp_rwlock, FTAG);
 	*availobjsp = DN_MAX_OBJECT - *usedobjsp;
 }
 
 boolean_t
 dsl_dataset_modified_since_snap(dsl_dataset_t *ds, dsl_dataset_t *snap)
 {
 	dsl_pool_t *dp __maybe_unused = ds->ds_dir->dd_pool;
 	uint64_t birth;
 
 	ASSERT(dsl_pool_config_held(dp));
 	if (snap == NULL)
 		return (B_FALSE);
 	rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
 	birth = BP_GET_LOGICAL_BIRTH(dsl_dataset_get_blkptr(ds));
 	rrw_exit(&ds->ds_bp_rwlock, FTAG);
 	if (birth > dsl_dataset_phys(snap)->ds_creation_txg) {
 		objset_t *os, *os_snap;
 		/*
 		 * It may be that only the ZIL differs, because it was
 		 * reset in the head.  Don't count that as being
 		 * modified.
 		 */
 		if (dmu_objset_from_ds(ds, &os) != 0)
 			return (B_TRUE);
 		if (dmu_objset_from_ds(snap, &os_snap) != 0)
 			return (B_TRUE);
 		return (memcmp(&os->os_phys->os_meta_dnode,
 		    &os_snap->os_phys->os_meta_dnode,
 		    sizeof (os->os_phys->os_meta_dnode)) != 0);
 	}
 	return (B_FALSE);
 }
 
 static int
 dsl_dataset_rename_snapshot_check_impl(dsl_pool_t *dp,
     dsl_dataset_t *hds, void *arg)
 {
 	(void) dp;
 	dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;
 	int error;
 	uint64_t val;
 
 	error = dsl_dataset_snap_lookup(hds, ddrsa->ddrsa_oldsnapname, &val);
 	if (error != 0) {
 		/* ignore nonexistent snapshots */
 		return (error == ENOENT ? 0 : error);
 	}
 
 	/* new name should not exist */
 	error = dsl_dataset_snap_lookup(hds, ddrsa->ddrsa_newsnapname, &val);
 	if (error == 0)
 		error = SET_ERROR(EEXIST);
 	else if (error == ENOENT)
 		error = 0;
 
 	/* dataset name + 1 for the "@" + the new snapshot name must fit */
 	if (dsl_dir_namelen(hds->ds_dir) + 1 +
 	    strlen(ddrsa->ddrsa_newsnapname) >= ZFS_MAX_DATASET_NAME_LEN)
 		error = SET_ERROR(ENAMETOOLONG);
 
 	return (error);
 }
 
 int
 dsl_dataset_rename_snapshot_check(void *arg, dmu_tx_t *tx)
 {
 	dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;
 	dsl_pool_t *dp = dmu_tx_pool(tx);
 	dsl_dataset_t *hds;
 	int error;
 
 	error = dsl_dataset_hold(dp, ddrsa->ddrsa_fsname, FTAG, &hds);
 	if (error != 0)
 		return (error);
 
 	if (ddrsa->ddrsa_recursive) {
 		error = dmu_objset_find_dp(dp, hds->ds_dir->dd_object,
 		    dsl_dataset_rename_snapshot_check_impl, ddrsa,
 		    DS_FIND_CHILDREN);
 	} else {
 		error = dsl_dataset_rename_snapshot_check_impl(dp, hds, ddrsa);
 	}
 	dsl_dataset_rele(hds, FTAG);
 	return (error);
 }
 
 static int
 dsl_dataset_rename_snapshot_sync_impl(dsl_pool_t *dp,
     dsl_dataset_t *hds, void *arg)
 {
 	dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;
 	dsl_dataset_t *ds;
 	uint64_t val;
 	dmu_tx_t *tx = ddrsa->ddrsa_tx;
+	char *oldname, *newname;
 	int error;
 
 	error = dsl_dataset_snap_lookup(hds, ddrsa->ddrsa_oldsnapname, &val);
 	ASSERT(error == 0 || error == ENOENT);
 	if (error == ENOENT) {
 		/* ignore nonexistent snapshots */
 		return (0);
 	}
 
 	VERIFY0(dsl_dataset_hold_obj(dp, val, FTAG, &ds));
 
 	/* log before we change the name */
 	spa_history_log_internal_ds(ds, "rename", tx,
 	    "-> @%s", ddrsa->ddrsa_newsnapname);
 
 	VERIFY0(dsl_dataset_snap_remove(hds, ddrsa->ddrsa_oldsnapname, tx,
 	    B_FALSE));
 	mutex_enter(&ds->ds_lock);
 	(void) strlcpy(ds->ds_snapname, ddrsa->ddrsa_newsnapname,
 	    sizeof (ds->ds_snapname));
 	mutex_exit(&ds->ds_lock);
 	VERIFY0(zap_add(dp->dp_meta_objset,
 	    dsl_dataset_phys(hds)->ds_snapnames_zapobj,
 	    ds->ds_snapname, 8, 1, &ds->ds_object, tx));
-	zvol_rename_minors(dp->dp_spa, ddrsa->ddrsa_oldsnapname,
-	    ddrsa->ddrsa_newsnapname, B_TRUE);
+
+	oldname = kmem_asprintf("%s@%s", ddrsa->ddrsa_fsname,
+	    ddrsa->ddrsa_oldsnapname);
+	newname = kmem_asprintf("%s@%s", ddrsa->ddrsa_fsname,
+	    ddrsa->ddrsa_newsnapname);
+	zvol_rename_minors(dp->dp_spa, oldname, newname, B_TRUE);
+	kmem_strfree(oldname);
+	kmem_strfree(newname);
 
 	dsl_dataset_rele(ds, FTAG);
 	return (0);
 }
 
 void
 dsl_dataset_rename_snapshot_sync(void *arg, dmu_tx_t *tx)
 {
 	dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;
 	dsl_pool_t *dp = dmu_tx_pool(tx);
 	dsl_dataset_t *hds = NULL;
 
 	VERIFY0(dsl_dataset_hold(dp, ddrsa->ddrsa_fsname, FTAG, &hds));
 	ddrsa->ddrsa_tx = tx;
 	if (ddrsa->ddrsa_recursive) {
 		VERIFY0(dmu_objset_find_dp(dp, hds->ds_dir->dd_object,
 		    dsl_dataset_rename_snapshot_sync_impl, ddrsa,
 		    DS_FIND_CHILDREN));
 	} else {
 		VERIFY0(dsl_dataset_rename_snapshot_sync_impl(dp, hds, ddrsa));
 	}
 	dsl_dataset_rele(hds, FTAG);
 }
 
 int
 dsl_dataset_rename_snapshot(const char *fsname,
     const char *oldsnapname, const char *newsnapname, boolean_t recursive)
 {
 	dsl_dataset_rename_snapshot_arg_t ddrsa;
 
 	ddrsa.ddrsa_fsname = fsname;
 	ddrsa.ddrsa_oldsnapname = oldsnapname;
 	ddrsa.ddrsa_newsnapname = newsnapname;
 	ddrsa.ddrsa_recursive = recursive;
 
 	return (dsl_sync_task(fsname, dsl_dataset_rename_snapshot_check,
 	    dsl_dataset_rename_snapshot_sync, &ddrsa,
 	    1, ZFS_SPACE_CHECK_RESERVED));
 }
 
 /*
  * If we're doing an ownership handoff, we need to make sure that there is
  * only one long hold on the dataset.  We're not allowed to change anything here
  * so we don't permanently release the long hold or regular hold here.  We want
  * to do this only when syncing to avoid the dataset unexpectedly going away
  * when we release the long hold.
  */
 static int
 dsl_dataset_handoff_check(dsl_dataset_t *ds, void *owner, dmu_tx_t *tx)
 {
 	boolean_t held = B_FALSE;
 
 	if (!dmu_tx_is_syncing(tx))
 		return (0);
 
 	dsl_dir_t *dd = ds->ds_dir;
 	mutex_enter(&dd->dd_activity_lock);
 	uint64_t holds = zfs_refcount_count(&ds->ds_longholds) -
 	    (owner != NULL ? 1 : 0);
 	/*
 	 * The value of dd_activity_waiters can chance as soon as we drop the
 	 * lock, but we're fine with that; new waiters coming in or old
 	 * waiters leaving doesn't cause problems, since we're going to cancel
 	 * waiters later anyway. The goal of this check is to verify that no
 	 * non-waiters have long-holds, and all new long-holds will be
 	 * prevented because we're holding the pool config as writer.
 	 */
 	if (holds != dd->dd_activity_waiters)
 		held = B_TRUE;
 	mutex_exit(&dd->dd_activity_lock);
 
 	if (held)
 		return (SET_ERROR(EBUSY));
 
 	return (0);
 }
 
 int
 dsl_dataset_rollback_check(void *arg, dmu_tx_t *tx)
 {
 	dsl_dataset_rollback_arg_t *ddra = arg;
 	dsl_pool_t *dp = dmu_tx_pool(tx);
 	dsl_dataset_t *ds;
 	int64_t unused_refres_delta;
 	int error;
 
 	error = dsl_dataset_hold(dp, ddra->ddra_fsname, FTAG, &ds);
 	if (error != 0)
 		return (error);
 
 	/* must not be a snapshot */
 	if (ds->ds_is_snapshot) {
 		dsl_dataset_rele(ds, FTAG);
 		return (SET_ERROR(EINVAL));
 	}
 
 	/* must have a most recent snapshot */
 	if (dsl_dataset_phys(ds)->ds_prev_snap_txg < TXG_INITIAL) {
 		dsl_dataset_rele(ds, FTAG);
 		return (SET_ERROR(ESRCH));
 	}
 
 	/*
 	 * No rollback to a snapshot created in the current txg, because
 	 * the rollback may dirty the dataset and create blocks that are
 	 * not reachable from the rootbp while having a birth txg that
 	 * falls into the snapshot's range.
 	 */
 	if (dmu_tx_is_syncing(tx) &&
 	    dsl_dataset_phys(ds)->ds_prev_snap_txg >= tx->tx_txg) {
 		dsl_dataset_rele(ds, FTAG);
 		return (SET_ERROR(EAGAIN));
 	}
 
 	/*
 	 * If the expected target snapshot is specified, then check that
 	 * the latest snapshot is it.
 	 */
 	if (ddra->ddra_tosnap != NULL) {
 		dsl_dataset_t *snapds;
 
 		/* Check if the target snapshot exists at all. */
 		error = dsl_dataset_hold(dp, ddra->ddra_tosnap, FTAG, &snapds);
 		if (error != 0) {
 			/*
 			 * ESRCH is used to signal that the target snapshot does
 			 * not exist, while ENOENT is used to report that
 			 * the rolled back dataset does not exist.
 			 * ESRCH is also used to cover other cases where the
 			 * target snapshot is not related to the dataset being
 			 * rolled back such as being in a different pool.
 			 */
 			if (error == ENOENT || error == EXDEV)
 				error = SET_ERROR(ESRCH);
 			dsl_dataset_rele(ds, FTAG);
 			return (error);
 		}
 		ASSERT(snapds->ds_is_snapshot);
 
 		/* Check if the snapshot is the latest snapshot indeed. */
 		if (snapds != ds->ds_prev) {
 			/*
 			 * Distinguish between the case where the only problem
 			 * is intervening snapshots (EEXIST) vs the snapshot
 			 * not being a valid target for rollback (ESRCH).
 			 */
 			if (snapds->ds_dir == ds->ds_dir ||
 			    (dsl_dir_is_clone(ds->ds_dir) &&
 			    dsl_dir_phys(ds->ds_dir)->dd_origin_obj ==
 			    snapds->ds_object)) {
 				error = SET_ERROR(EEXIST);
 			} else {
 				error = SET_ERROR(ESRCH);
 			}
 			dsl_dataset_rele(snapds, FTAG);
 			dsl_dataset_rele(ds, FTAG);
 			return (error);
 		}
 		dsl_dataset_rele(snapds, FTAG);
 	}
 
 	/* must not have any bookmarks after the most recent snapshot */
 	if (dsl_bookmark_latest_txg(ds) >
 	    dsl_dataset_phys(ds)->ds_prev_snap_txg) {
 		dsl_dataset_rele(ds, FTAG);
 		return (SET_ERROR(EEXIST));
 	}
 
 	error = dsl_dataset_handoff_check(ds, ddra->ddra_owner, tx);
 	if (error != 0) {
 		dsl_dataset_rele(ds, FTAG);
 		return (error);
 	}
 
 	/*
 	 * Check if the snap we are rolling back to uses more than
 	 * the refquota.
 	 */
 	if (ds->ds_quota != 0 &&
 	    dsl_dataset_phys(ds->ds_prev)->ds_referenced_bytes > ds->ds_quota) {
 		dsl_dataset_rele(ds, FTAG);
 		return (SET_ERROR(EDQUOT));
 	}
 
 	/*
 	 * When we do the clone swap, we will temporarily use more space
 	 * due to the refreservation (the head will no longer have any
 	 * unique space, so the entire amount of the refreservation will need
 	 * to be free).  We will immediately destroy the clone, freeing
 	 * this space, but the freeing happens over many txg's.
 	 */
 	unused_refres_delta = (int64_t)MIN(ds->ds_reserved,
 	    dsl_dataset_phys(ds)->ds_unique_bytes);
 
 	if (unused_refres_delta > 0 &&
 	    unused_refres_delta >
 	    dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE)) {
 		dsl_dataset_rele(ds, FTAG);
 		return (SET_ERROR(ENOSPC));
 	}
 
 	dsl_dataset_rele(ds, FTAG);
 	return (0);
 }
 
 void
 dsl_dataset_rollback_sync(void *arg, dmu_tx_t *tx)
 {
 	dsl_dataset_rollback_arg_t *ddra = arg;
 	dsl_pool_t *dp = dmu_tx_pool(tx);
 	dsl_dataset_t *ds, *clone;
 	uint64_t cloneobj;
 	char namebuf[ZFS_MAX_DATASET_NAME_LEN];
 
 	VERIFY0(dsl_dataset_hold(dp, ddra->ddra_fsname, FTAG, &ds));
 
 	dsl_dataset_name(ds->ds_prev, namebuf);
 	fnvlist_add_string(ddra->ddra_result, "target", namebuf);
 
 	cloneobj = dsl_dataset_create_sync(ds->ds_dir, "%rollback",
 	    ds->ds_prev, DS_CREATE_FLAG_NODIRTY, kcred, NULL, tx);
 
 	VERIFY0(dsl_dataset_hold_obj(dp, cloneobj, FTAG, &clone));
 
 	dsl_dataset_clone_swap_sync_impl(clone, ds, tx);
 	dsl_dataset_zero_zil(ds, tx);
 
 	dsl_destroy_head_sync_impl(clone, tx);
 
 	dsl_dataset_rele(clone, FTAG);
 	dsl_dataset_rele(ds, FTAG);
 }
 
 /*
  * Rolls back the given filesystem or volume to the most recent snapshot.
  * The name of the most recent snapshot will be returned under key "target"
  * in the result nvlist.
  *
  * If owner != NULL:
  * - The existing dataset MUST be owned by the specified owner at entry
  * - Upon return, dataset will still be held by the same owner, whether we
  *   succeed or not.
  *
  * This mode is required any time the existing filesystem is mounted.  See
  * notes above zfs_suspend_fs() for further details.
  */
 int
 dsl_dataset_rollback(const char *fsname, const char *tosnap, void *owner,
     nvlist_t *result)
 {
 	dsl_dataset_rollback_arg_t ddra;
 
 	ddra.ddra_fsname = fsname;
 	ddra.ddra_tosnap = tosnap;
 	ddra.ddra_owner = owner;
 	ddra.ddra_result = result;
 
 	return (dsl_sync_task(fsname, dsl_dataset_rollback_check,
 	    dsl_dataset_rollback_sync, &ddra,
 	    1, ZFS_SPACE_CHECK_RESERVED));
 }
 
 struct promotenode {
 	list_node_t link;
 	dsl_dataset_t *ds;
 };
 
 static int snaplist_space(list_t *l, uint64_t mintxg, uint64_t *spacep);
 static int promote_hold(dsl_dataset_promote_arg_t *ddpa, dsl_pool_t *dp,
     const void *tag);
 static void promote_rele(dsl_dataset_promote_arg_t *ddpa, const void *tag);
 
 int
 dsl_dataset_promote_check(void *arg, dmu_tx_t *tx)
 {
 	dsl_dataset_promote_arg_t *ddpa = arg;
 	dsl_pool_t *dp = dmu_tx_pool(tx);
 	dsl_dataset_t *hds;
 	struct promotenode *snap;
 	int err;
 	uint64_t unused;
 	uint64_t ss_mv_cnt;
 	size_t max_snap_len;
 	boolean_t conflicting_snaps;
 
 	err = promote_hold(ddpa, dp, FTAG);
 	if (err != 0)
 		return (err);
 
 	hds = ddpa->ddpa_clone;
 	max_snap_len = MAXNAMELEN - strlen(ddpa->ddpa_clonename) - 1;
 
 	if (dsl_dataset_phys(hds)->ds_flags & DS_FLAG_NOPROMOTE) {
 		promote_rele(ddpa, FTAG);
 		return (SET_ERROR(EXDEV));
 	}
 
 	snap = list_head(&ddpa->shared_snaps);
 	if (snap == NULL) {
 		err = SET_ERROR(ENOENT);
 		goto out;
 	}
 	dsl_dataset_t *const origin_ds = snap->ds;
 
 	/*
 	 * Encrypted clones share a DSL Crypto Key with their origin's dsl dir.
 	 * When doing a promote we must make sure the encryption root for
 	 * both the target and the target's origin does not change to avoid
 	 * needing to rewrap encryption keys
 	 */
 	err = dsl_dataset_promote_crypt_check(hds->ds_dir, origin_ds->ds_dir);
 	if (err != 0)
 		goto out;
 
 	/*
 	 * Compute and check the amount of space to transfer.  Since this is
 	 * so expensive, don't do the preliminary check.
 	 */
 	if (!dmu_tx_is_syncing(tx)) {
 		promote_rele(ddpa, FTAG);
 		return (0);
 	}
 
 	/* compute origin's new unique space */
 	snap = list_tail(&ddpa->clone_snaps);
 	ASSERT(snap != NULL);
 	ASSERT3U(dsl_dataset_phys(snap->ds)->ds_prev_snap_obj, ==,
 	    origin_ds->ds_object);
 	dsl_deadlist_space_range(&snap->ds->ds_deadlist,
 	    dsl_dataset_phys(origin_ds)->ds_prev_snap_txg, UINT64_MAX,
 	    &ddpa->unique, &unused, &unused);
 
 	/*
 	 * Walk the snapshots that we are moving
 	 *
 	 * Compute space to transfer.  Consider the incremental changes
 	 * to used by each snapshot:
 	 * (my used) = (prev's used) + (blocks born) - (blocks killed)
 	 * So each snapshot gave birth to:
 	 * (blocks born) = (my used) - (prev's used) + (blocks killed)
 	 * So a sequence would look like:
 	 * (uN - u(N-1) + kN) + ... + (u1 - u0 + k1) + (u0 - 0 + k0)
 	 * Which simplifies to:
 	 * uN + kN + kN-1 + ... + k1 + k0
 	 * Note however, if we stop before we reach the ORIGIN we get:
 	 * uN + kN + kN-1 + ... + kM - uM-1
 	 */
 	conflicting_snaps = B_FALSE;
 	ss_mv_cnt = 0;
 	ddpa->used = dsl_dataset_phys(origin_ds)->ds_referenced_bytes;
 	ddpa->comp = dsl_dataset_phys(origin_ds)->ds_compressed_bytes;
 	ddpa->uncomp = dsl_dataset_phys(origin_ds)->ds_uncompressed_bytes;
 	for (snap = list_head(&ddpa->shared_snaps); snap;
 	    snap = list_next(&ddpa->shared_snaps, snap)) {
 		uint64_t val, dlused, dlcomp, dluncomp;
 		dsl_dataset_t *ds = snap->ds;
 
 		ss_mv_cnt++;
 
 		/*
 		 * If there are long holds, we won't be able to evict
 		 * the objset.
 		 */
 		if (dsl_dataset_long_held(ds)) {
 			err = SET_ERROR(EBUSY);
 			goto out;
 		}
 
 		/* Check that the snapshot name does not conflict */
 		VERIFY0(dsl_dataset_get_snapname(ds));
 		if (strlen(ds->ds_snapname) >= max_snap_len) {
 			err = SET_ERROR(ENAMETOOLONG);
 			goto out;
 		}
 		err = dsl_dataset_snap_lookup(hds, ds->ds_snapname, &val);
 		if (err == 0) {
 			fnvlist_add_boolean(ddpa->err_ds,
 			    snap->ds->ds_snapname);
 			conflicting_snaps = B_TRUE;
 		} else if (err != ENOENT) {
 			goto out;
 		}
 
 		/* The very first snapshot does not have a deadlist */
 		if (dsl_dataset_phys(ds)->ds_prev_snap_obj == 0)
 			continue;
 
 		dsl_deadlist_space(&ds->ds_deadlist,
 		    &dlused, &dlcomp, &dluncomp);
 		ddpa->used += dlused;
 		ddpa->comp += dlcomp;
 		ddpa->uncomp += dluncomp;
 	}
 
 	/*
 	 * Check that bookmarks that are being transferred don't have
 	 * name conflicts.
 	 */
 	for (dsl_bookmark_node_t *dbn = avl_first(&origin_ds->ds_bookmarks);
 	    dbn != NULL && dbn->dbn_phys.zbm_creation_txg <=
 	    dsl_dataset_phys(origin_ds)->ds_creation_txg;
 	    dbn = AVL_NEXT(&origin_ds->ds_bookmarks, dbn)) {
 		if (strlen(dbn->dbn_name) >= max_snap_len) {
 			err = SET_ERROR(ENAMETOOLONG);
 			goto out;
 		}
 		zfs_bookmark_phys_t bm;
 		err = dsl_bookmark_lookup_impl(ddpa->ddpa_clone,
 		    dbn->dbn_name, &bm);
 
 		if (err == 0) {
 			fnvlist_add_boolean(ddpa->err_ds, dbn->dbn_name);
 			conflicting_snaps = B_TRUE;
 		} else if (err == ESRCH) {
 			err = 0;
 		}
 		if (err != 0) {
 			goto out;
 		}
 	}
 
 	/*
 	 * In order to return the full list of conflicting snapshots, we check
 	 * whether there was a conflict after traversing all of them.
 	 */
 	if (conflicting_snaps) {
 		err = SET_ERROR(EEXIST);
 		goto out;
 	}
 
 	/*
 	 * If we are a clone of a clone then we never reached ORIGIN,
 	 * so we need to subtract out the clone origin's used space.
 	 */
 	if (ddpa->origin_origin) {
 		ddpa->used -=
 		    dsl_dataset_phys(ddpa->origin_origin)->ds_referenced_bytes;
 		ddpa->comp -=
 		    dsl_dataset_phys(ddpa->origin_origin)->ds_compressed_bytes;
 		ddpa->uncomp -=
 		    dsl_dataset_phys(ddpa->origin_origin)->
 		    ds_uncompressed_bytes;
 	}
 
 	/* Check that there is enough space and limit headroom here */
 	err = dsl_dir_transfer_possible(origin_ds->ds_dir, hds->ds_dir,
 	    0, ss_mv_cnt, ddpa->used, ddpa->cr, ddpa->proc);
 	if (err != 0)
 		goto out;
 
 	/*
 	 * Compute the amounts of space that will be used by snapshots
 	 * after the promotion (for both origin and clone).  For each,
 	 * it is the amount of space that will be on all of their
 	 * deadlists (that was not born before their new origin).
 	 */
 	if (dsl_dir_phys(hds->ds_dir)->dd_flags & DD_FLAG_USED_BREAKDOWN) {
 		uint64_t space;
 
 		/*
 		 * Note, typically this will not be a clone of a clone,
 		 * so dd_origin_txg will be < TXG_INITIAL, so
 		 * these snaplist_space() -> dsl_deadlist_space_range()
 		 * calls will be fast because they do not have to
 		 * iterate over all bps.
 		 */
 		snap = list_head(&ddpa->origin_snaps);
 		if (snap == NULL) {
 			err = SET_ERROR(ENOENT);
 			goto out;
 		}
 		err = snaplist_space(&ddpa->shared_snaps,
 		    snap->ds->ds_dir->dd_origin_txg, &ddpa->cloneusedsnap);
 		if (err != 0)
 			goto out;
 
 		err = snaplist_space(&ddpa->clone_snaps,
 		    snap->ds->ds_dir->dd_origin_txg, &space);
 		if (err != 0)
 			goto out;
 		ddpa->cloneusedsnap += space;
 	}
 	if (dsl_dir_phys(origin_ds->ds_dir)->dd_flags &
 	    DD_FLAG_USED_BREAKDOWN) {
 		err = snaplist_space(&ddpa->origin_snaps,
 		    dsl_dataset_phys(origin_ds)->ds_creation_txg,
 		    &ddpa->originusedsnap);
 		if (err != 0)
 			goto out;
 	}
 
 out:
 	promote_rele(ddpa, FTAG);
 	return (err);
 }
 
 void
 dsl_dataset_promote_sync(void *arg, dmu_tx_t *tx)
 {
 	dsl_dataset_promote_arg_t *ddpa = arg;
 	dsl_pool_t *dp = dmu_tx_pool(tx);
 	dsl_dataset_t *hds;
 	struct promotenode *snap;
 	dsl_dataset_t *origin_ds;
 	dsl_dataset_t *origin_head;
 	dsl_dir_t *dd;
 	dsl_dir_t *odd = NULL;
 	uint64_t oldnext_obj;
 	int64_t delta;
 
 	ASSERT(nvlist_empty(ddpa->err_ds));
 
 	VERIFY0(promote_hold(ddpa, dp, FTAG));
 	hds = ddpa->ddpa_clone;
 
 	ASSERT0(dsl_dataset_phys(hds)->ds_flags & DS_FLAG_NOPROMOTE);
 
 	snap = list_head(&ddpa->shared_snaps);
 	origin_ds = snap->ds;
 	dd = hds->ds_dir;
 
 	snap = list_head(&ddpa->origin_snaps);
 	origin_head = snap->ds;
 
 	/*
 	 * We need to explicitly open odd, since origin_ds's dd will be
 	 * changing.
 	 */
 	VERIFY0(dsl_dir_hold_obj(dp, origin_ds->ds_dir->dd_object,
 	    NULL, FTAG, &odd));
 
 	dsl_dataset_promote_crypt_sync(hds->ds_dir, odd, tx);
 
 	/* change origin's next snap */
 	dmu_buf_will_dirty(origin_ds->ds_dbuf, tx);
 	oldnext_obj = dsl_dataset_phys(origin_ds)->ds_next_snap_obj;
 	snap = list_tail(&ddpa->clone_snaps);
 	ASSERT3U(dsl_dataset_phys(snap->ds)->ds_prev_snap_obj, ==,
 	    origin_ds->ds_object);
 	dsl_dataset_phys(origin_ds)->ds_next_snap_obj = snap->ds->ds_object;
 
 	/* change the origin's next clone */
 	if (dsl_dataset_phys(origin_ds)->ds_next_clones_obj) {
 		dsl_dataset_remove_from_next_clones(origin_ds,
 		    snap->ds->ds_object, tx);
 		VERIFY0(zap_add_int(dp->dp_meta_objset,
 		    dsl_dataset_phys(origin_ds)->ds_next_clones_obj,
 		    oldnext_obj, tx));
 	}
 
 	/* change origin */
 	dmu_buf_will_dirty(dd->dd_dbuf, tx);
 	ASSERT3U(dsl_dir_phys(dd)->dd_origin_obj, ==, origin_ds->ds_object);
 	dsl_dir_phys(dd)->dd_origin_obj = dsl_dir_phys(odd)->dd_origin_obj;
 	dd->dd_origin_txg = origin_head->ds_dir->dd_origin_txg;
 	dmu_buf_will_dirty(odd->dd_dbuf, tx);
 	dsl_dir_phys(odd)->dd_origin_obj = origin_ds->ds_object;
 	origin_head->ds_dir->dd_origin_txg =
 	    dsl_dataset_phys(origin_ds)->ds_creation_txg;
 
 	/* change dd_clone entries */
 	if (spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
 		VERIFY0(zap_remove_int(dp->dp_meta_objset,
 		    dsl_dir_phys(odd)->dd_clones, hds->ds_object, tx));
 		VERIFY0(zap_add_int(dp->dp_meta_objset,
 		    dsl_dir_phys(ddpa->origin_origin->ds_dir)->dd_clones,
 		    hds->ds_object, tx));
 
 		VERIFY0(zap_remove_int(dp->dp_meta_objset,
 		    dsl_dir_phys(ddpa->origin_origin->ds_dir)->dd_clones,
 		    origin_head->ds_object, tx));
 		if (dsl_dir_phys(dd)->dd_clones == 0) {
 			dsl_dir_phys(dd)->dd_clones =
 			    zap_create(dp->dp_meta_objset, DMU_OT_DSL_CLONES,
 			    DMU_OT_NONE, 0, tx);
 		}
 		VERIFY0(zap_add_int(dp->dp_meta_objset,
 		    dsl_dir_phys(dd)->dd_clones, origin_head->ds_object, tx));
 	}
 
 	/*
 	 * Move bookmarks to this dir.
 	 */
 	dsl_bookmark_node_t *dbn_next;
 	for (dsl_bookmark_node_t *dbn = avl_first(&origin_head->ds_bookmarks);
 	    dbn != NULL && dbn->dbn_phys.zbm_creation_txg <=
 	    dsl_dataset_phys(origin_ds)->ds_creation_txg;
 	    dbn = dbn_next) {
 		dbn_next = AVL_NEXT(&origin_head->ds_bookmarks, dbn);
 
 		avl_remove(&origin_head->ds_bookmarks, dbn);
 		VERIFY0(zap_remove(dp->dp_meta_objset,
 		    origin_head->ds_bookmarks_obj, dbn->dbn_name, tx));
 
 		dsl_bookmark_node_add(hds, dbn, tx);
 	}
 
 	dsl_bookmark_next_changed(hds, origin_ds, tx);
 
 	/* move snapshots to this dir */
 	for (snap = list_head(&ddpa->shared_snaps); snap;
 	    snap = list_next(&ddpa->shared_snaps, snap)) {
 		dsl_dataset_t *ds = snap->ds;
 
 		/*
 		 * Property callbacks are registered to a particular
 		 * dsl_dir.  Since ours is changing, evict the objset
 		 * so that they will be unregistered from the old dsl_dir.
 		 */
 		if (ds->ds_objset) {
 			dmu_objset_evict(ds->ds_objset);
 			ds->ds_objset = NULL;
 		}
 
 		/* move snap name entry */
 		VERIFY0(dsl_dataset_get_snapname(ds));
 		VERIFY0(dsl_dataset_snap_remove(origin_head,
 		    ds->ds_snapname, tx, B_TRUE));
 		VERIFY0(zap_add(dp->dp_meta_objset,
 		    dsl_dataset_phys(hds)->ds_snapnames_zapobj, ds->ds_snapname,
 		    8, 1, &ds->ds_object, tx));
 		dsl_fs_ss_count_adjust(hds->ds_dir, 1,
 		    DD_FIELD_SNAPSHOT_COUNT, tx);
 
 		/* change containing dsl_dir */
 		dmu_buf_will_dirty(ds->ds_dbuf, tx);
 		ASSERT3U(dsl_dataset_phys(ds)->ds_dir_obj, ==, odd->dd_object);
 		dsl_dataset_phys(ds)->ds_dir_obj = dd->dd_object;
 		ASSERT3P(ds->ds_dir, ==, odd);
 		dsl_dir_rele(ds->ds_dir, ds);
 		VERIFY0(dsl_dir_hold_obj(dp, dd->dd_object,
 		    NULL, ds, &ds->ds_dir));
 
 		/* move any clone references */
 		if (dsl_dataset_phys(ds)->ds_next_clones_obj &&
 		    spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
 			zap_cursor_t zc;
 			zap_attribute_t *za = zap_attribute_alloc();
 
 			for (zap_cursor_init(&zc, dp->dp_meta_objset,
 			    dsl_dataset_phys(ds)->ds_next_clones_obj);
 			    zap_cursor_retrieve(&zc, za) == 0;
 			    zap_cursor_advance(&zc)) {
 				dsl_dataset_t *cnds;
 				uint64_t o;
 
 				if (za->za_first_integer == oldnext_obj) {
 					/*
 					 * We've already moved the
 					 * origin's reference.
 					 */
 					continue;
 				}
 
 				VERIFY0(dsl_dataset_hold_obj(dp,
 				    za->za_first_integer, FTAG, &cnds));
 				o = dsl_dir_phys(cnds->ds_dir)->
 				    dd_head_dataset_obj;
 
 				VERIFY0(zap_remove_int(dp->dp_meta_objset,
 				    dsl_dir_phys(odd)->dd_clones, o, tx));
 				VERIFY0(zap_add_int(dp->dp_meta_objset,
 				    dsl_dir_phys(dd)->dd_clones, o, tx));
 				dsl_dataset_rele(cnds, FTAG);
 			}
 			zap_cursor_fini(&zc);
 			zap_attribute_free(za);
 		}
 
 		ASSERT(!dsl_prop_hascb(ds));
 	}
 
 	/*
 	 * Change space accounting.
 	 * Note, pa->*usedsnap and dd_used_breakdown[SNAP] will either
 	 * both be valid, or both be 0 (resulting in delta == 0).  This
 	 * is true for each of {clone,origin} independently.
 	 */
 
 	delta = ddpa->cloneusedsnap -
 	    dsl_dir_phys(dd)->dd_used_breakdown[DD_USED_SNAP];
 	ASSERT3S(delta, >=, 0);
 	ASSERT3U(ddpa->used, >=, delta);
 	dsl_dir_diduse_space(dd, DD_USED_SNAP, delta, 0, 0, tx);
 	dsl_dir_diduse_space(dd, DD_USED_HEAD,
 	    ddpa->used - delta, ddpa->comp, ddpa->uncomp, tx);
 
 	delta = ddpa->originusedsnap -
 	    dsl_dir_phys(odd)->dd_used_breakdown[DD_USED_SNAP];
 	ASSERT3S(delta, <=, 0);
 	ASSERT3U(ddpa->used, >=, -delta);
 	dsl_dir_diduse_space(odd, DD_USED_SNAP, delta, 0, 0, tx);
 	dsl_dir_diduse_space(odd, DD_USED_HEAD,
 	    -ddpa->used - delta, -ddpa->comp, -ddpa->uncomp, tx);
 
 	dsl_dataset_phys(origin_ds)->ds_unique_bytes = ddpa->unique;
 
 	/*
 	 * Since livelists are specific to a clone's origin txg, they
 	 * are no longer accurate. Destroy the livelist from the clone being
 	 * promoted. If the origin dataset is a clone, destroy its livelist
 	 * as well.
 	 */
 	dsl_dir_remove_livelist(dd, tx, B_TRUE);
 	dsl_dir_remove_livelist(odd, tx, B_TRUE);
 
 	/* log history record */
 	spa_history_log_internal_ds(hds, "promote", tx, " ");
 
 	dsl_dir_rele(odd, FTAG);
 
 	/*
 	 * Transfer common error blocks from old head to new head, before
 	 * calling promote_rele() on ddpa since we need to dereference
 	 * origin_head and hds.
 	 */
 	if (spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_HEAD_ERRLOG)) {
 		uint64_t old_head = origin_head->ds_object;
 		uint64_t new_head = hds->ds_object;
 		spa_swap_errlog(dp->dp_spa, new_head, old_head, tx);
 	}
 
 	promote_rele(ddpa, FTAG);
 }
 
 /*
  * Make a list of dsl_dataset_t's for the snapshots between first_obj
  * (exclusive) and last_obj (inclusive).  The list will be in reverse
  * order (last_obj will be the list_head()).  If first_obj == 0, do all
  * snapshots back to this dataset's origin.
  */
 static int
 snaplist_make(dsl_pool_t *dp,
     uint64_t first_obj, uint64_t last_obj, list_t *l, const void *tag)
 {
 	uint64_t obj = last_obj;
 
 	list_create(l, sizeof (struct promotenode),
 	    offsetof(struct promotenode, link));
 
 	while (obj != first_obj) {
 		dsl_dataset_t *ds;
 		struct promotenode *snap;
 		int err;
 
 		err = dsl_dataset_hold_obj(dp, obj, tag, &ds);
 		ASSERT(err != ENOENT);
 		if (err != 0)
 			return (err);
 
 		if (first_obj == 0)
 			first_obj = dsl_dir_phys(ds->ds_dir)->dd_origin_obj;
 
 		snap = kmem_alloc(sizeof (*snap), KM_SLEEP);
 		snap->ds = ds;
 		list_insert_tail(l, snap);
 		obj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
 	}
 
 	return (0);
 }
 
 static int
 snaplist_space(list_t *l, uint64_t mintxg, uint64_t *spacep)
 {
 	struct promotenode *snap;
 
 	*spacep = 0;
 	for (snap = list_head(l); snap; snap = list_next(l, snap)) {
 		uint64_t used, comp, uncomp;
 		dsl_deadlist_space_range(&snap->ds->ds_deadlist,
 		    mintxg, UINT64_MAX, &used, &comp, &uncomp);
 		*spacep += used;
 	}
 	return (0);
 }
 
 static void
 snaplist_destroy(list_t *l, const void *tag)
 {
 	struct promotenode *snap;
 
 	if (l == NULL || !list_link_active(&l->list_head))
 		return;
 
 	while ((snap = list_remove_tail(l)) != NULL) {
 		dsl_dataset_rele(snap->ds, tag);
 		kmem_free(snap, sizeof (*snap));
 	}
 	list_destroy(l);
 }
 
 static int
 promote_hold(dsl_dataset_promote_arg_t *ddpa, dsl_pool_t *dp, const void *tag)
 {
 	int error;
 	dsl_dir_t *dd;
 	struct promotenode *snap;
 
 	error = dsl_dataset_hold(dp, ddpa->ddpa_clonename, tag,
 	    &ddpa->ddpa_clone);
 	if (error != 0)
 		return (error);
 	dd = ddpa->ddpa_clone->ds_dir;
 
 	if (ddpa->ddpa_clone->ds_is_snapshot ||
 	    !dsl_dir_is_clone(dd)) {
 		dsl_dataset_rele(ddpa->ddpa_clone, tag);
 		return (SET_ERROR(EINVAL));
 	}
 
 	error = snaplist_make(dp, 0, dsl_dir_phys(dd)->dd_origin_obj,
 	    &ddpa->shared_snaps, tag);
 	if (error != 0)
 		goto out;
 
 	error = snaplist_make(dp, 0, ddpa->ddpa_clone->ds_object,
 	    &ddpa->clone_snaps, tag);
 	if (error != 0)
 		goto out;
 
 	snap = list_head(&ddpa->shared_snaps);
 	ASSERT3U(snap->ds->ds_object, ==, dsl_dir_phys(dd)->dd_origin_obj);
 	error = snaplist_make(dp, dsl_dir_phys(dd)->dd_origin_obj,
 	    dsl_dir_phys(snap->ds->ds_dir)->dd_head_dataset_obj,
 	    &ddpa->origin_snaps, tag);
 	if (error != 0)
 		goto out;
 
 	if (dsl_dir_phys(snap->ds->ds_dir)->dd_origin_obj != 0) {
 		error = dsl_dataset_hold_obj(dp,
 		    dsl_dir_phys(snap->ds->ds_dir)->dd_origin_obj,
 		    tag, &ddpa->origin_origin);
 		if (error != 0)
 			goto out;
 	}
 out:
 	if (error != 0)
 		promote_rele(ddpa, tag);
 	return (error);
 }
 
 static void
 promote_rele(dsl_dataset_promote_arg_t *ddpa, const void *tag)
 {
 	snaplist_destroy(&ddpa->shared_snaps, tag);
 	snaplist_destroy(&ddpa->clone_snaps, tag);
 	snaplist_destroy(&ddpa->origin_snaps, tag);
 	if (ddpa->origin_origin != NULL)
 		dsl_dataset_rele(ddpa->origin_origin, tag);
 	dsl_dataset_rele(ddpa->ddpa_clone, tag);
 }
 
 /*
  * Promote a clone.
  *
  * If it fails due to a conflicting snapshot name, "conflsnap" will be filled
  * in with the name.  (It must be at least ZFS_MAX_DATASET_NAME_LEN bytes long.)
  */
 int
 dsl_dataset_promote(const char *name, char *conflsnap)
 {
 	dsl_dataset_promote_arg_t ddpa = { 0 };
 	uint64_t numsnaps;
 	int error;
 	nvpair_t *snap_pair;
 	objset_t *os;
 
 	/*
 	 * We will modify space proportional to the number of
 	 * snapshots.  Compute numsnaps.
 	 */
 	error = dmu_objset_hold(name, FTAG, &os);
 	if (error != 0)
 		return (error);
 	error = zap_count(dmu_objset_pool(os)->dp_meta_objset,
 	    dsl_dataset_phys(dmu_objset_ds(os))->ds_snapnames_zapobj,
 	    &numsnaps);
 	dmu_objset_rele(os, FTAG);
 	if (error != 0)
 		return (error);
 
 	ddpa.ddpa_clonename = name;
 	ddpa.err_ds = fnvlist_alloc();
 	ddpa.cr = CRED();
 	ddpa.proc = curproc;
 
 	error = dsl_sync_task(name, dsl_dataset_promote_check,
 	    dsl_dataset_promote_sync, &ddpa,
 	    2 + numsnaps, ZFS_SPACE_CHECK_RESERVED);
 
 	/*
 	 * Return the first conflicting snapshot found.
 	 */
 	snap_pair = nvlist_next_nvpair(ddpa.err_ds, NULL);
 	if (snap_pair != NULL && conflsnap != NULL)
 		(void) strlcpy(conflsnap, nvpair_name(snap_pair),
 		    ZFS_MAX_DATASET_NAME_LEN);
 
 	fnvlist_free(ddpa.err_ds);
 	return (error);
 }
 
 int
 dsl_dataset_clone_swap_check_impl(dsl_dataset_t *clone,
     dsl_dataset_t *origin_head, boolean_t force, void *owner, dmu_tx_t *tx)
 {
 	/*
 	 * "slack" factor for received datasets with refquota set on them.
 	 * See the bottom of this function for details on its use.
 	 */
 	uint64_t refquota_slack = (uint64_t)DMU_MAX_ACCESS *
 	    spa_asize_inflation;
 	int64_t unused_refres_delta;
 
 	/* they should both be heads */
 	if (clone->ds_is_snapshot ||
 	    origin_head->ds_is_snapshot)
 		return (SET_ERROR(EINVAL));
 
 	/* if we are not forcing, the branch point should be just before them */
 	if (!force && clone->ds_prev != origin_head->ds_prev)
 		return (SET_ERROR(EINVAL));
 
 	/* clone should be the clone (unless they are unrelated) */
 	if (clone->ds_prev != NULL &&
 	    clone->ds_prev != clone->ds_dir->dd_pool->dp_origin_snap &&
 	    origin_head->ds_dir != clone->ds_prev->ds_dir)
 		return (SET_ERROR(EINVAL));
 
 	/* the clone should be a child of the origin */
 	if (clone->ds_dir->dd_parent != origin_head->ds_dir)
 		return (SET_ERROR(EINVAL));
 
 	/* origin_head shouldn't be modified unless 'force' */
 	if (!force &&
 	    dsl_dataset_modified_since_snap(origin_head, origin_head->ds_prev))
 		return (SET_ERROR(ETXTBSY));
 
 	/* origin_head should have no long holds (e.g. is not mounted) */
 	if (dsl_dataset_handoff_check(origin_head, owner, tx))
 		return (SET_ERROR(EBUSY));
 
 	/* check amount of any unconsumed refreservation */
 	unused_refres_delta =
 	    (int64_t)MIN(origin_head->ds_reserved,
 	    dsl_dataset_phys(origin_head)->ds_unique_bytes) -
 	    (int64_t)MIN(origin_head->ds_reserved,
 	    dsl_dataset_phys(clone)->ds_unique_bytes);
 
 	if (unused_refres_delta > 0 &&
 	    unused_refres_delta >
 	    dsl_dir_space_available(origin_head->ds_dir, NULL, 0, TRUE))
 		return (SET_ERROR(ENOSPC));
 
 	/*
 	 * The clone can't be too much over the head's refquota.
 	 *
 	 * To ensure that the entire refquota can be used, we allow one
 	 * transaction to exceed the refquota.  Therefore, this check
 	 * needs to also allow for the space referenced to be more than the
 	 * refquota.  The maximum amount of space that one transaction can use
 	 * on disk is DMU_MAX_ACCESS * spa_asize_inflation.  Allowing this
 	 * overage ensures that we are able to receive a filesystem that
 	 * exceeds the refquota on the source system.
 	 *
 	 * So that overage is the refquota_slack we use below.
 	 */
 	if (origin_head->ds_quota != 0 &&
 	    dsl_dataset_phys(clone)->ds_referenced_bytes >
 	    origin_head->ds_quota + refquota_slack)
 		return (SET_ERROR(EDQUOT));
 
 	return (0);
 }
 
 static void
 dsl_dataset_swap_remap_deadlists(dsl_dataset_t *clone,
     dsl_dataset_t *origin, dmu_tx_t *tx)
 {
 	uint64_t clone_remap_dl_obj, origin_remap_dl_obj;
 	dsl_pool_t *dp = dmu_tx_pool(tx);
 
 	ASSERT(dsl_pool_sync_context(dp));
 
 	clone_remap_dl_obj = dsl_dataset_get_remap_deadlist_object(clone);
 	origin_remap_dl_obj = dsl_dataset_get_remap_deadlist_object(origin);
 
 	if (clone_remap_dl_obj != 0) {
 		dsl_deadlist_close(&clone->ds_remap_deadlist);
 		dsl_dataset_unset_remap_deadlist_object(clone, tx);
 	}
 	if (origin_remap_dl_obj != 0) {
 		dsl_deadlist_close(&origin->ds_remap_deadlist);
 		dsl_dataset_unset_remap_deadlist_object(origin, tx);
 	}
 
 	if (clone_remap_dl_obj != 0) {
 		dsl_dataset_set_remap_deadlist_object(origin,
 		    clone_remap_dl_obj, tx);
 		dsl_deadlist_open(&origin->ds_remap_deadlist,
 		    dp->dp_meta_objset, clone_remap_dl_obj);
 	}
 	if (origin_remap_dl_obj != 0) {
 		dsl_dataset_set_remap_deadlist_object(clone,
 		    origin_remap_dl_obj, tx);
 		dsl_deadlist_open(&clone->ds_remap_deadlist,
 		    dp->dp_meta_objset, origin_remap_dl_obj);
 	}
 }
 
 void
 dsl_dataset_clone_swap_sync_impl(dsl_dataset_t *clone,
     dsl_dataset_t *origin_head, dmu_tx_t *tx)
 {
 	dsl_pool_t *dp = dmu_tx_pool(tx);
 	int64_t unused_refres_delta;
 
 	ASSERT(clone->ds_reserved == 0);
 	/*
 	 * NOTE: On DEBUG kernels there could be a race between this and
 	 * the check function if spa_asize_inflation is adjusted...
 	 */
 	ASSERT(origin_head->ds_quota == 0 ||
 	    dsl_dataset_phys(clone)->ds_unique_bytes <= origin_head->ds_quota +
 	    DMU_MAX_ACCESS * spa_asize_inflation);
 	ASSERT3P(clone->ds_prev, ==, origin_head->ds_prev);
 
 	dsl_dir_cancel_waiters(origin_head->ds_dir);
 
 	/*
 	 * Swap per-dataset feature flags.
 	 */
 	for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
 		if (!(spa_feature_table[f].fi_flags &
 		    ZFEATURE_FLAG_PER_DATASET)) {
 			ASSERT(!dsl_dataset_feature_is_active(clone, f));
 			ASSERT(!dsl_dataset_feature_is_active(origin_head, f));
 			continue;
 		}
 
 		boolean_t clone_inuse = dsl_dataset_feature_is_active(clone, f);
 		void *clone_feature = clone->ds_feature[f];
 		boolean_t origin_head_inuse =
 		    dsl_dataset_feature_is_active(origin_head, f);
 		void *origin_head_feature = origin_head->ds_feature[f];
 
 		if (clone_inuse)
 			dsl_dataset_deactivate_feature_impl(clone, f, tx);
 		if (origin_head_inuse)
 			dsl_dataset_deactivate_feature_impl(origin_head, f, tx);
 
 		if (clone_inuse) {
 			dsl_dataset_activate_feature(origin_head->ds_object, f,
 			    clone_feature, tx);
 			origin_head->ds_feature[f] = clone_feature;
 		}
 		if (origin_head_inuse) {
 			dsl_dataset_activate_feature(clone->ds_object, f,
 			    origin_head_feature, tx);
 			clone->ds_feature[f] = origin_head_feature;
 		}
 	}
 
 	dmu_buf_will_dirty(clone->ds_dbuf, tx);
 	dmu_buf_will_dirty(origin_head->ds_dbuf, tx);
 
 	if (clone->ds_objset != NULL) {
 		dmu_objset_evict(clone->ds_objset);
 		clone->ds_objset = NULL;
 	}
 
 	if (origin_head->ds_objset != NULL) {
 		dmu_objset_evict(origin_head->ds_objset);
 		origin_head->ds_objset = NULL;
 	}
 
 	unused_refres_delta =
 	    (int64_t)MIN(origin_head->ds_reserved,
 	    dsl_dataset_phys(origin_head)->ds_unique_bytes) -
 	    (int64_t)MIN(origin_head->ds_reserved,
 	    dsl_dataset_phys(clone)->ds_unique_bytes);
 
 	/*
 	 * Reset origin's unique bytes.
 	 */
 	{
 		dsl_dataset_t *origin = clone->ds_prev;
 		uint64_t comp, uncomp;
 
 		dmu_buf_will_dirty(origin->ds_dbuf, tx);
 		dsl_deadlist_space_range(&clone->ds_deadlist,
 		    dsl_dataset_phys(origin)->ds_prev_snap_txg, UINT64_MAX,
 		    &dsl_dataset_phys(origin)->ds_unique_bytes, &comp, &uncomp);
 	}
 
 	/* swap blkptrs */
 	{
 		rrw_enter(&clone->ds_bp_rwlock, RW_WRITER, FTAG);
 		rrw_enter(&origin_head->ds_bp_rwlock, RW_WRITER, FTAG);
 		blkptr_t tmp;
 		tmp = dsl_dataset_phys(origin_head)->ds_bp;
 		dsl_dataset_phys(origin_head)->ds_bp =
 		    dsl_dataset_phys(clone)->ds_bp;
 		dsl_dataset_phys(clone)->ds_bp = tmp;
 		rrw_exit(&origin_head->ds_bp_rwlock, FTAG);
 		rrw_exit(&clone->ds_bp_rwlock, FTAG);
 	}
 
 	/* set dd_*_bytes */
 	{
 		int64_t dused, dcomp, duncomp;
 		uint64_t cdl_used, cdl_comp, cdl_uncomp;
 		uint64_t odl_used, odl_comp, odl_uncomp;
 
 		ASSERT3U(dsl_dir_phys(clone->ds_dir)->
 		    dd_used_breakdown[DD_USED_SNAP], ==, 0);
 
 		dsl_deadlist_space(&clone->ds_deadlist,
 		    &cdl_used, &cdl_comp, &cdl_uncomp);
 		dsl_deadlist_space(&origin_head->ds_deadlist,
 		    &odl_used, &odl_comp, &odl_uncomp);
 
 		dused = dsl_dataset_phys(clone)->ds_referenced_bytes +
 		    cdl_used -
 		    (dsl_dataset_phys(origin_head)->ds_referenced_bytes +
 		    odl_used);
 		dcomp = dsl_dataset_phys(clone)->ds_compressed_bytes +
 		    cdl_comp -
 		    (dsl_dataset_phys(origin_head)->ds_compressed_bytes +
 		    odl_comp);
 		duncomp = dsl_dataset_phys(clone)->ds_uncompressed_bytes +
 		    cdl_uncomp -
 		    (dsl_dataset_phys(origin_head)->ds_uncompressed_bytes +
 		    odl_uncomp);
 
 		dsl_dir_diduse_space(origin_head->ds_dir, DD_USED_HEAD,
 		    dused, dcomp, duncomp, tx);
 		dsl_dir_diduse_space(clone->ds_dir, DD_USED_HEAD,
 		    -dused, -dcomp, -duncomp, tx);
 
 		/*
 		 * The difference in the space used by snapshots is the
 		 * difference in snapshot space due to the head's
 		 * deadlist (since that's the only thing that's
 		 * changing that affects the snapused).
 		 */
 		dsl_deadlist_space_range(&clone->ds_deadlist,
 		    origin_head->ds_dir->dd_origin_txg, UINT64_MAX,
 		    &cdl_used, &cdl_comp, &cdl_uncomp);
 		dsl_deadlist_space_range(&origin_head->ds_deadlist,
 		    origin_head->ds_dir->dd_origin_txg, UINT64_MAX,
 		    &odl_used, &odl_comp, &odl_uncomp);
 		dsl_dir_transfer_space(origin_head->ds_dir, cdl_used - odl_used,
 		    DD_USED_HEAD, DD_USED_SNAP, tx);
 	}
 
 	/* swap ds_*_bytes */
 	SWITCH64(dsl_dataset_phys(origin_head)->ds_referenced_bytes,
 	    dsl_dataset_phys(clone)->ds_referenced_bytes);
 	SWITCH64(dsl_dataset_phys(origin_head)->ds_compressed_bytes,
 	    dsl_dataset_phys(clone)->ds_compressed_bytes);
 	SWITCH64(dsl_dataset_phys(origin_head)->ds_uncompressed_bytes,
 	    dsl_dataset_phys(clone)->ds_uncompressed_bytes);
 	SWITCH64(dsl_dataset_phys(origin_head)->ds_unique_bytes,
 	    dsl_dataset_phys(clone)->ds_unique_bytes);
 
 	/* apply any parent delta for change in unconsumed refreservation */
 	dsl_dir_diduse_space(origin_head->ds_dir, DD_USED_REFRSRV,
 	    unused_refres_delta, 0, 0, tx);
 
 	/*
 	 * Swap deadlists.
 	 */
 	dsl_deadlist_close(&clone->ds_deadlist);
 	dsl_deadlist_close(&origin_head->ds_deadlist);
 	SWITCH64(dsl_dataset_phys(origin_head)->ds_deadlist_obj,
 	    dsl_dataset_phys(clone)->ds_deadlist_obj);
 	dsl_deadlist_open(&clone->ds_deadlist, dp->dp_meta_objset,
 	    dsl_dataset_phys(clone)->ds_deadlist_obj);
 	dsl_deadlist_open(&origin_head->ds_deadlist, dp->dp_meta_objset,
 	    dsl_dataset_phys(origin_head)->ds_deadlist_obj);
 	dsl_dataset_swap_remap_deadlists(clone, origin_head, tx);
 
 	/*
 	 * If there is a bookmark at the origin, its "next dataset" is
 	 * changing, so we need to reset its FBN.
 	 */
 	dsl_bookmark_next_changed(origin_head, origin_head->ds_prev, tx);
 
 	dsl_scan_ds_clone_swapped(origin_head, clone, tx);
 
 	/*
 	 * Destroy any livelists associated with the clone or the origin,
 	 * since after the swap the corresponding livelists are no longer
 	 * valid.
 	 */
 	dsl_dir_remove_livelist(clone->ds_dir, tx, B_TRUE);
 	dsl_dir_remove_livelist(origin_head->ds_dir, tx, B_TRUE);
 
 	spa_history_log_internal_ds(clone, "clone swap", tx,
 	    "parent=%s", origin_head->ds_dir->dd_myname);
 }
 
 /*
  * Given a pool name and a dataset object number in that pool,
  * return the name of that dataset.
  */
 int
 dsl_dsobj_to_dsname(char *pname, uint64_t obj, char *buf)
 {
 	dsl_pool_t *dp;
 	dsl_dataset_t *ds;
 	int error;
 
 	error = dsl_pool_hold(pname, FTAG, &dp);
 	if (error != 0)
 		return (error);
 
 	error = dsl_dataset_hold_obj(dp, obj, FTAG, &ds);
 	if (error == 0) {
 		dsl_dataset_name(ds, buf);
 		dsl_dataset_rele(ds, FTAG);
 	}
 	dsl_pool_rele(dp, FTAG);
 
 	return (error);
 }
 
 int
 dsl_dataset_check_quota(dsl_dataset_t *ds, boolean_t check_quota,
     uint64_t asize, uint64_t inflight, uint64_t *used, uint64_t *ref_rsrv)
 {
 	int error = 0;
 
 	ASSERT3S(asize, >, 0);
 
 	/*
 	 * *ref_rsrv is the portion of asize that will come from any
 	 * unconsumed refreservation space.
 	 */
 	*ref_rsrv = 0;
 
 	mutex_enter(&ds->ds_lock);
 	/*
 	 * Make a space adjustment for reserved bytes.
 	 */
 	if (ds->ds_reserved > dsl_dataset_phys(ds)->ds_unique_bytes) {
 		ASSERT3U(*used, >=,
 		    ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes);
 		*used -=
 		    (ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes);
 		*ref_rsrv =
 		    asize - MIN(asize, parent_delta(ds, asize + inflight));
 	}
 
 	if (!check_quota || ds->ds_quota == 0) {
 		mutex_exit(&ds->ds_lock);
 		return (0);
 	}
 	/*
 	 * If they are requesting more space, and our current estimate
 	 * is over quota, they get to try again unless the actual
 	 * on-disk is over quota and there are no pending changes (which
 	 * may free up space for us).
 	 */
 	if (dsl_dataset_phys(ds)->ds_referenced_bytes + inflight >=
 	    ds->ds_quota) {
 		if (inflight > 0 ||
 		    dsl_dataset_phys(ds)->ds_referenced_bytes < ds->ds_quota)
 			error = SET_ERROR(ERESTART);
 		else
 			error = SET_ERROR(EDQUOT);
 	}
 	mutex_exit(&ds->ds_lock);
 
 	return (error);
 }
 
 typedef struct dsl_dataset_set_qr_arg {
 	const char *ddsqra_name;
 	zprop_source_t ddsqra_source;
 	uint64_t ddsqra_value;
 } dsl_dataset_set_qr_arg_t;
 
 
 static int
 dsl_dataset_set_refquota_check(void *arg, dmu_tx_t *tx)
 {
 	dsl_dataset_set_qr_arg_t *ddsqra = arg;
 	dsl_pool_t *dp = dmu_tx_pool(tx);
 	dsl_dataset_t *ds;
 	int error;
 	uint64_t newval;
 
 	if (spa_version(dp->dp_spa) < SPA_VERSION_REFQUOTA)
 		return (SET_ERROR(ENOTSUP));
 
 	error = dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds);
 	if (error != 0)
 		return (error);
 
 	if (ds->ds_is_snapshot) {
 		dsl_dataset_rele(ds, FTAG);
 		return (SET_ERROR(EINVAL));
 	}
 
 	error = dsl_prop_predict(ds->ds_dir,
 	    zfs_prop_to_name(ZFS_PROP_REFQUOTA),
 	    ddsqra->ddsqra_source, ddsqra->ddsqra_value, &newval);
 	if (error != 0) {
 		dsl_dataset_rele(ds, FTAG);
 		return (error);
 	}
 
 	if (newval == 0) {
 		dsl_dataset_rele(ds, FTAG);
 		return (0);
 	}
 
 	if (newval < dsl_dataset_phys(ds)->ds_referenced_bytes ||
 	    newval < ds->ds_reserved) {
 		dsl_dataset_rele(ds, FTAG);
 		return (SET_ERROR(ENOSPC));
 	}
 
 	dsl_dataset_rele(ds, FTAG);
 	return (0);
 }
 
 static void
 dsl_dataset_set_refquota_sync(void *arg, dmu_tx_t *tx)
 {
 	dsl_dataset_set_qr_arg_t *ddsqra = arg;
 	dsl_pool_t *dp = dmu_tx_pool(tx);
 	dsl_dataset_t *ds = NULL;
 	uint64_t newval;
 
 	VERIFY0(dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds));
 
 	dsl_prop_set_sync_impl(ds,
 	    zfs_prop_to_name(ZFS_PROP_REFQUOTA),
 	    ddsqra->ddsqra_source, sizeof (ddsqra->ddsqra_value), 1,
 	    &ddsqra->ddsqra_value, tx);
 
 	VERIFY0(dsl_prop_get_int_ds(ds,
 	    zfs_prop_to_name(ZFS_PROP_REFQUOTA), &newval));
 
 	if (ds->ds_quota != newval) {
 		dmu_buf_will_dirty(ds->ds_dbuf, tx);
 		ds->ds_quota = newval;
 	}
 	dsl_dataset_rele(ds, FTAG);
 }
 
 int
 dsl_dataset_set_refquota(const char *dsname, zprop_source_t source,
     uint64_t refquota)
 {
 	dsl_dataset_set_qr_arg_t ddsqra;
 
 	ddsqra.ddsqra_name = dsname;
 	ddsqra.ddsqra_source = source;
 	ddsqra.ddsqra_value = refquota;
 
 	return (dsl_sync_task(dsname, dsl_dataset_set_refquota_check,
 	    dsl_dataset_set_refquota_sync, &ddsqra, 0,
 	    ZFS_SPACE_CHECK_EXTRA_RESERVED));
 }
 
 static int
 dsl_dataset_set_refreservation_check(void *arg, dmu_tx_t *tx)
 {
 	dsl_dataset_set_qr_arg_t *ddsqra = arg;
 	dsl_pool_t *dp = dmu_tx_pool(tx);
 	dsl_dataset_t *ds;
 	int error;
 	uint64_t newval, unique;
 
 	if (spa_version(dp->dp_spa) < SPA_VERSION_REFRESERVATION)
 		return (SET_ERROR(ENOTSUP));
 
 	error = dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds);
 	if (error != 0)
 		return (error);
 
 	if (ds->ds_is_snapshot) {
 		dsl_dataset_rele(ds, FTAG);
 		return (SET_ERROR(EINVAL));
 	}
 
 	error = dsl_prop_predict(ds->ds_dir,
 	    zfs_prop_to_name(ZFS_PROP_REFRESERVATION),
 	    ddsqra->ddsqra_source, ddsqra->ddsqra_value, &newval);
 	if (error != 0) {
 		dsl_dataset_rele(ds, FTAG);
 		return (error);
 	}
 
 	/*
 	 * If we are doing the preliminary check in open context, the
 	 * space estimates may be inaccurate.
 	 */
 	if (!dmu_tx_is_syncing(tx)) {
 		dsl_dataset_rele(ds, FTAG);
 		return (0);
 	}
 
 	mutex_enter(&ds->ds_lock);
 	if (!DS_UNIQUE_IS_ACCURATE(ds))
 		dsl_dataset_recalc_head_uniq(ds);
 	unique = dsl_dataset_phys(ds)->ds_unique_bytes;
 	mutex_exit(&ds->ds_lock);
 
 	if (MAX(unique, newval) > MAX(unique, ds->ds_reserved)) {
 		uint64_t delta = MAX(unique, newval) -
 		    MAX(unique, ds->ds_reserved);
 
 		if (delta >
 		    dsl_dir_space_available(ds->ds_dir, NULL, 0, B_TRUE) ||
 		    (ds->ds_quota > 0 && newval > ds->ds_quota)) {
 			dsl_dataset_rele(ds, FTAG);
 			return (SET_ERROR(ENOSPC));
 		}
 	}
 
 	dsl_dataset_rele(ds, FTAG);
 	return (0);
 }
 
 void
 dsl_dataset_set_refreservation_sync_impl(dsl_dataset_t *ds,
     zprop_source_t source, uint64_t value, dmu_tx_t *tx)
 {
 	uint64_t newval;
 	uint64_t unique;
 	int64_t delta;
 
 	dsl_prop_set_sync_impl(ds, zfs_prop_to_name(ZFS_PROP_REFRESERVATION),
 	    source, sizeof (value), 1, &value, tx);
 
 	VERIFY0(dsl_prop_get_int_ds(ds,
 	    zfs_prop_to_name(ZFS_PROP_REFRESERVATION), &newval));
 
 	dmu_buf_will_dirty(ds->ds_dbuf, tx);
 	mutex_enter(&ds->ds_dir->dd_lock);
 	mutex_enter(&ds->ds_lock);
 	ASSERT(DS_UNIQUE_IS_ACCURATE(ds));
 	unique = dsl_dataset_phys(ds)->ds_unique_bytes;
 	delta = MAX(0, (int64_t)(newval - unique)) -
 	    MAX(0, (int64_t)(ds->ds_reserved - unique));
 	ds->ds_reserved = newval;
 	mutex_exit(&ds->ds_lock);
 
 	dsl_dir_diduse_space(ds->ds_dir, DD_USED_REFRSRV, delta, 0, 0, tx);
 	mutex_exit(&ds->ds_dir->dd_lock);
 }
 
 static void
 dsl_dataset_set_refreservation_sync(void *arg, dmu_tx_t *tx)
 {
 	dsl_dataset_set_qr_arg_t *ddsqra = arg;
 	dsl_pool_t *dp = dmu_tx_pool(tx);
 	dsl_dataset_t *ds = NULL;
 
 	VERIFY0(dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds));
 	dsl_dataset_set_refreservation_sync_impl(ds,
 	    ddsqra->ddsqra_source, ddsqra->ddsqra_value, tx);
 	dsl_dataset_rele(ds, FTAG);
 }
 
 int
 dsl_dataset_set_refreservation(const char *dsname, zprop_source_t source,
     uint64_t refreservation)
 {
 	dsl_dataset_set_qr_arg_t ddsqra;
 
 	ddsqra.ddsqra_name = dsname;
 	ddsqra.ddsqra_source = source;
 	ddsqra.ddsqra_value = refreservation;
 
 	return (dsl_sync_task(dsname, dsl_dataset_set_refreservation_check,
 	    dsl_dataset_set_refreservation_sync, &ddsqra, 0,
 	    ZFS_SPACE_CHECK_EXTRA_RESERVED));
 }
 
 typedef struct dsl_dataset_set_compression_arg {
 	const char *ddsca_name;
 	zprop_source_t ddsca_source;
 	uint64_t ddsca_value;
 } dsl_dataset_set_compression_arg_t;
 
 static int
 dsl_dataset_set_compression_check(void *arg, dmu_tx_t *tx)
 {
 	dsl_dataset_set_compression_arg_t *ddsca = arg;
 	dsl_pool_t *dp = dmu_tx_pool(tx);
 
 	uint64_t compval = ZIO_COMPRESS_ALGO(ddsca->ddsca_value);
 	spa_feature_t f = zio_compress_to_feature(compval);
 
 	if (f == SPA_FEATURE_NONE)
 		return (SET_ERROR(EINVAL));
 
 	if (!spa_feature_is_enabled(dp->dp_spa, f))
 		return (SET_ERROR(ENOTSUP));
 
 	return (0);
 }
 
 static void
 dsl_dataset_set_compression_sync(void *arg, dmu_tx_t *tx)
 {
 	dsl_dataset_set_compression_arg_t *ddsca = arg;
 	dsl_pool_t *dp = dmu_tx_pool(tx);
 	dsl_dataset_t *ds = NULL;
 
 	uint64_t compval = ZIO_COMPRESS_ALGO(ddsca->ddsca_value);
 	spa_feature_t f = zio_compress_to_feature(compval);
 	ASSERT3S(f, !=, SPA_FEATURE_NONE);
 	ASSERT3S(spa_feature_table[f].fi_type, ==, ZFEATURE_TYPE_BOOLEAN);
 
 	VERIFY0(dsl_dataset_hold(dp, ddsca->ddsca_name, FTAG, &ds));
 	if (zfeature_active(f, ds->ds_feature[f]) != B_TRUE) {
 		ds->ds_feature_activation[f] = (void *)B_TRUE;
 		dsl_dataset_activate_feature(ds->ds_object, f,
 		    ds->ds_feature_activation[f], tx);
 		ds->ds_feature[f] = ds->ds_feature_activation[f];
 	}
 	dsl_dataset_rele(ds, FTAG);
 }
 
 int
 dsl_dataset_set_compression(const char *dsname, zprop_source_t source,
     uint64_t compression)
 {
 	dsl_dataset_set_compression_arg_t ddsca;
 
 	/*
 	 * The sync task is only required for zstd in order to activate
 	 * the feature flag when the property is first set.
 	 */
 	if (ZIO_COMPRESS_ALGO(compression) != ZIO_COMPRESS_ZSTD)
 		return (0);
 
 	ddsca.ddsca_name = dsname;
 	ddsca.ddsca_source = source;
 	ddsca.ddsca_value = compression;
 
 	return (dsl_sync_task(dsname, dsl_dataset_set_compression_check,
 	    dsl_dataset_set_compression_sync, &ddsca, 0,
 	    ZFS_SPACE_CHECK_EXTRA_RESERVED));
 }
 
 /*
  * Return (in *usedp) the amount of space referenced by "new" that was not
  * referenced at the time the bookmark corresponds to.  "New" may be a
  * snapshot or a head.  The bookmark must be before new, in
  * new's filesystem (or its origin) -- caller verifies this.
  *
  * The written space is calculated by considering two components:  First, we
  * ignore any freed space, and calculate the written as new's used space
  * minus old's used space.  Next, we add in the amount of space that was freed
  * between the two time points, thus reducing new's used space relative to
  * old's. Specifically, this is the space that was born before
  * zbm_creation_txg, and freed before new (ie. on new's deadlist or a
  * previous deadlist).
  *
  * space freed                         [---------------------]
  * snapshots                       ---O-------O--------O-------O------
  *                                         bookmark           new
  *
  * Note, the bookmark's zbm_*_bytes_refd must be valid, but if the HAS_FBN
  * flag is not set, we will calculate the freed_before_next based on the
  * next snapshot's deadlist, rather than using zbm_*_freed_before_next_snap.
  */
 static int
 dsl_dataset_space_written_impl(zfs_bookmark_phys_t *bmp,
     dsl_dataset_t *new, uint64_t *usedp, uint64_t *compp, uint64_t *uncompp)
 {
 	int err = 0;
 	dsl_pool_t *dp = new->ds_dir->dd_pool;
 
 	ASSERT(dsl_pool_config_held(dp));
 	if (dsl_dataset_is_snapshot(new)) {
 		ASSERT3U(bmp->zbm_creation_txg, <,
 		    dsl_dataset_phys(new)->ds_creation_txg);
 	}
 
 	*usedp = 0;
 	*usedp += dsl_dataset_phys(new)->ds_referenced_bytes;
 	*usedp -= bmp->zbm_referenced_bytes_refd;
 
 	*compp = 0;
 	*compp += dsl_dataset_phys(new)->ds_compressed_bytes;
 	*compp -= bmp->zbm_compressed_bytes_refd;
 
 	*uncompp = 0;
 	*uncompp += dsl_dataset_phys(new)->ds_uncompressed_bytes;
 	*uncompp -= bmp->zbm_uncompressed_bytes_refd;
 
 	dsl_dataset_t *snap = new;
 
 	while (dsl_dataset_phys(snap)->ds_prev_snap_txg >
 	    bmp->zbm_creation_txg) {
 		uint64_t used, comp, uncomp;
 
 		dsl_deadlist_space_range(&snap->ds_deadlist,
 		    0, bmp->zbm_creation_txg,
 		    &used, &comp, &uncomp);
 		*usedp += used;
 		*compp += comp;
 		*uncompp += uncomp;
 
 		uint64_t snapobj = dsl_dataset_phys(snap)->ds_prev_snap_obj;
 		if (snap != new)
 			dsl_dataset_rele(snap, FTAG);
 		err = dsl_dataset_hold_obj(dp, snapobj, FTAG, &snap);
 		if (err != 0)
 			break;
 	}
 
 	/*
 	 * We might not have the FBN if we are calculating written from
 	 * a snapshot (because we didn't know the correct "next" snapshot
 	 * until now).
 	 */
 	if (bmp->zbm_flags & ZBM_FLAG_HAS_FBN) {
 		*usedp += bmp->zbm_referenced_freed_before_next_snap;
 		*compp += bmp->zbm_compressed_freed_before_next_snap;
 		*uncompp += bmp->zbm_uncompressed_freed_before_next_snap;
 	} else {
 		ASSERT3U(dsl_dataset_phys(snap)->ds_prev_snap_txg, ==,
 		    bmp->zbm_creation_txg);
 		uint64_t used, comp, uncomp;
 		dsl_deadlist_space(&snap->ds_deadlist, &used, &comp, &uncomp);
 		*usedp += used;
 		*compp += comp;
 		*uncompp += uncomp;
 	}
 	if (snap != new)
 		dsl_dataset_rele(snap, FTAG);
 	return (err);
 }
 
 /*
  * Return (in *usedp) the amount of space written in new that was not
  * present at the time the bookmark corresponds to.  New may be a
  * snapshot or the head.  Old must be a bookmark before new, in
  * new's filesystem (or its origin) -- caller verifies this.
  */
 int
 dsl_dataset_space_written_bookmark(zfs_bookmark_phys_t *bmp,
     dsl_dataset_t *new, uint64_t *usedp, uint64_t *compp, uint64_t *uncompp)
 {
 	if (!(bmp->zbm_flags & ZBM_FLAG_HAS_FBN))
 		return (SET_ERROR(ENOTSUP));
 	return (dsl_dataset_space_written_impl(bmp, new,
 	    usedp, compp, uncompp));
 }
 
 /*
  * Return (in *usedp) the amount of space written in new that is not
  * present in oldsnap.  New may be a snapshot or the head.  Old must be
  * a snapshot before new, in new's filesystem (or its origin).  If not then
  * fail and return EINVAL.
  */
 int
 dsl_dataset_space_written(dsl_dataset_t *oldsnap, dsl_dataset_t *new,
     uint64_t *usedp, uint64_t *compp, uint64_t *uncompp)
 {
 	if (!dsl_dataset_is_before(new, oldsnap, 0))
 		return (SET_ERROR(EINVAL));
 
 	zfs_bookmark_phys_t zbm = { 0 };
 	dsl_dataset_phys_t *dsp = dsl_dataset_phys(oldsnap);
 	zbm.zbm_guid = dsp->ds_guid;
 	zbm.zbm_creation_txg = dsp->ds_creation_txg;
 	zbm.zbm_creation_time = dsp->ds_creation_time;
 	zbm.zbm_referenced_bytes_refd = dsp->ds_referenced_bytes;
 	zbm.zbm_compressed_bytes_refd = dsp->ds_compressed_bytes;
 	zbm.zbm_uncompressed_bytes_refd = dsp->ds_uncompressed_bytes;
 
 	/*
 	 * If oldsnap is the origin (or origin's origin, ...) of new,
 	 * we can't easily calculate the effective FBN.  Therefore,
 	 * we do not set ZBM_FLAG_HAS_FBN, so that the _impl will calculate
 	 * it relative to the correct "next": the next snapshot towards "new",
 	 * rather than the next snapshot in oldsnap's dsl_dir.
 	 */
 	return (dsl_dataset_space_written_impl(&zbm, new,
 	    usedp, compp, uncompp));
 }
 
 /*
  * Return (in *usedp) the amount of space that will be reclaimed if firstsnap,
  * lastsnap, and all snapshots in between are deleted.
  *
  * blocks that would be freed            [---------------------------]
  * snapshots                       ---O-------O--------O-------O--------O
  *                                        firstsnap        lastsnap
  *
  * This is the set of blocks that were born after the snap before firstsnap,
  * (birth > firstsnap->prev_snap_txg) and died before the snap after the
  * last snap (ie, is on lastsnap->ds_next->ds_deadlist or an earlier deadlist).
  * We calculate this by iterating over the relevant deadlists (from the snap
  * after lastsnap, backward to the snap after firstsnap), summing up the
  * space on the deadlist that was born after the snap before firstsnap.
  */
 int
 dsl_dataset_space_wouldfree(dsl_dataset_t *firstsnap,
     dsl_dataset_t *lastsnap,
     uint64_t *usedp, uint64_t *compp, uint64_t *uncompp)
 {
 	int err = 0;
 	uint64_t snapobj;
 	dsl_pool_t *dp = firstsnap->ds_dir->dd_pool;
 
 	ASSERT(firstsnap->ds_is_snapshot);
 	ASSERT(lastsnap->ds_is_snapshot);
 
 	/*
 	 * Check that the snapshots are in the same dsl_dir, and firstsnap
 	 * is before lastsnap.
 	 */
 	if (firstsnap->ds_dir != lastsnap->ds_dir ||
 	    dsl_dataset_phys(firstsnap)->ds_creation_txg >
 	    dsl_dataset_phys(lastsnap)->ds_creation_txg)
 		return (SET_ERROR(EINVAL));
 
 	*usedp = *compp = *uncompp = 0;
 
 	snapobj = dsl_dataset_phys(lastsnap)->ds_next_snap_obj;
 	while (snapobj != firstsnap->ds_object) {
 		dsl_dataset_t *ds;
 		uint64_t used, comp, uncomp;
 
 		err = dsl_dataset_hold_obj(dp, snapobj, FTAG, &ds);
 		if (err != 0)
 			break;
 
 		dsl_deadlist_space_range(&ds->ds_deadlist,
 		    dsl_dataset_phys(firstsnap)->ds_prev_snap_txg, UINT64_MAX,
 		    &used, &comp, &uncomp);
 		*usedp += used;
 		*compp += comp;
 		*uncompp += uncomp;
 
 		snapobj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
 		ASSERT3U(snapobj, !=, 0);
 		dsl_dataset_rele(ds, FTAG);
 	}
 	return (err);
 }
 
 /*
  * Return TRUE if 'earlier' is an earlier snapshot in 'later's timeline.
  * For example, they could both be snapshots of the same filesystem, and
  * 'earlier' is before 'later'.  Or 'earlier' could be the origin of
  * 'later's filesystem.  Or 'earlier' could be an older snapshot in the origin's
  * filesystem.  Or 'earlier' could be the origin's origin.
  *
  * If non-zero, earlier_txg is used instead of earlier's ds_creation_txg.
  */
 boolean_t
 dsl_dataset_is_before(dsl_dataset_t *later, dsl_dataset_t *earlier,
     uint64_t earlier_txg)
 {
 	dsl_pool_t *dp = later->ds_dir->dd_pool;
 	int error;
 	boolean_t ret;
 
 	ASSERT(dsl_pool_config_held(dp));
 	ASSERT(earlier->ds_is_snapshot || earlier_txg != 0);
 
 	if (earlier_txg == 0)
 		earlier_txg = dsl_dataset_phys(earlier)->ds_creation_txg;
 
 	if (later->ds_is_snapshot &&
 	    earlier_txg >= dsl_dataset_phys(later)->ds_creation_txg)
 		return (B_FALSE);
 
 	if (later->ds_dir == earlier->ds_dir)
 		return (B_TRUE);
 
 	/*
 	 * We check dd_origin_obj explicitly here rather than using
 	 * dsl_dir_is_clone() so that we will return TRUE if "earlier"
 	 * is $ORIGIN@$ORIGIN.  dsl_dataset_space_written() depends on
 	 * this behavior.
 	 */
 	if (dsl_dir_phys(later->ds_dir)->dd_origin_obj == 0)
 		return (B_FALSE);
 
 	dsl_dataset_t *origin;
 	error = dsl_dataset_hold_obj(dp,
 	    dsl_dir_phys(later->ds_dir)->dd_origin_obj, FTAG, &origin);
 	if (error != 0)
 		return (B_FALSE);
 	if (dsl_dataset_phys(origin)->ds_creation_txg == earlier_txg &&
 	    origin->ds_dir == earlier->ds_dir) {
 		dsl_dataset_rele(origin, FTAG);
 		return (B_TRUE);
 	}
 	ret = dsl_dataset_is_before(origin, earlier, earlier_txg);
 	dsl_dataset_rele(origin, FTAG);
 	return (ret);
 }
 
 void
 dsl_dataset_zapify(dsl_dataset_t *ds, dmu_tx_t *tx)
 {
 	objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
 	dmu_object_zapify(mos, ds->ds_object, DMU_OT_DSL_DATASET, tx);
 }
 
 boolean_t
 dsl_dataset_is_zapified(dsl_dataset_t *ds)
 {
 	dmu_object_info_t doi;
 
 	dmu_object_info_from_db(ds->ds_dbuf, &doi);
 	return (doi.doi_type == DMU_OTN_ZAP_METADATA);
 }
 
 boolean_t
 dsl_dataset_has_resume_receive_state(dsl_dataset_t *ds)
 {
 	return (dsl_dataset_is_zapified(ds) &&
 	    zap_contains(ds->ds_dir->dd_pool->dp_meta_objset,
 	    ds->ds_object, DS_FIELD_RESUME_TOGUID) == 0);
 }
 
 uint64_t
 dsl_dataset_get_remap_deadlist_object(dsl_dataset_t *ds)
 {
 	uint64_t remap_deadlist_obj;
 	int err;
 
 	if (!dsl_dataset_is_zapified(ds))
 		return (0);
 
 	err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, ds->ds_object,
 	    DS_FIELD_REMAP_DEADLIST, sizeof (remap_deadlist_obj), 1,
 	    &remap_deadlist_obj);
 
 	if (err != 0) {
 		VERIFY3S(err, ==, ENOENT);
 		return (0);
 	}
 
 	ASSERT(remap_deadlist_obj != 0);
 	return (remap_deadlist_obj);
 }
 
 boolean_t
 dsl_dataset_remap_deadlist_exists(dsl_dataset_t *ds)
 {
 	EQUIV(dsl_deadlist_is_open(&ds->ds_remap_deadlist),
 	    dsl_dataset_get_remap_deadlist_object(ds) != 0);
 	return (dsl_deadlist_is_open(&ds->ds_remap_deadlist));
 }
 
 static void
 dsl_dataset_set_remap_deadlist_object(dsl_dataset_t *ds, uint64_t obj,
     dmu_tx_t *tx)
 {
 	ASSERT(obj != 0);
 	dsl_dataset_zapify(ds, tx);
 	VERIFY0(zap_add(ds->ds_dir->dd_pool->dp_meta_objset, ds->ds_object,
 	    DS_FIELD_REMAP_DEADLIST, sizeof (obj), 1, &obj, tx));
 }
 
 static void
 dsl_dataset_unset_remap_deadlist_object(dsl_dataset_t *ds, dmu_tx_t *tx)
 {
 	VERIFY0(zap_remove(ds->ds_dir->dd_pool->dp_meta_objset,
 	    ds->ds_object, DS_FIELD_REMAP_DEADLIST, tx));
 }
 
 void
 dsl_dataset_destroy_remap_deadlist(dsl_dataset_t *ds, dmu_tx_t *tx)
 {
 	uint64_t remap_deadlist_object;
 	spa_t *spa = ds->ds_dir->dd_pool->dp_spa;
 
 	ASSERT(dmu_tx_is_syncing(tx));
 	ASSERT(dsl_dataset_remap_deadlist_exists(ds));
 
 	remap_deadlist_object = ds->ds_remap_deadlist.dl_object;
 	dsl_deadlist_close(&ds->ds_remap_deadlist);
 	dsl_deadlist_free(spa_meta_objset(spa), remap_deadlist_object, tx);
 	dsl_dataset_unset_remap_deadlist_object(ds, tx);
 	spa_feature_decr(spa, SPA_FEATURE_OBSOLETE_COUNTS, tx);
 }
 
 void
 dsl_dataset_create_remap_deadlist(dsl_dataset_t *ds, dmu_tx_t *tx)
 {
 	uint64_t remap_deadlist_obj;
 	spa_t *spa = ds->ds_dir->dd_pool->dp_spa;
 
 	ASSERT(dmu_tx_is_syncing(tx));
 	ASSERT(MUTEX_HELD(&ds->ds_remap_deadlist_lock));
 	/*
 	 * Currently we only create remap deadlists when there are indirect
 	 * vdevs with referenced mappings.
 	 */
 	ASSERT(spa_feature_is_active(spa, SPA_FEATURE_DEVICE_REMOVAL));
 
 	remap_deadlist_obj = dsl_deadlist_clone(
 	    &ds->ds_deadlist, UINT64_MAX,
 	    dsl_dataset_phys(ds)->ds_prev_snap_obj, tx);
 	dsl_dataset_set_remap_deadlist_object(ds,
 	    remap_deadlist_obj, tx);
 	dsl_deadlist_open(&ds->ds_remap_deadlist, spa_meta_objset(spa),
 	    remap_deadlist_obj);
 	spa_feature_incr(spa, SPA_FEATURE_OBSOLETE_COUNTS, tx);
 }
 
 void
 dsl_dataset_activate_redaction(dsl_dataset_t *ds, uint64_t *redact_snaps,
     uint64_t num_redact_snaps, dmu_tx_t *tx)
 {
 	uint64_t dsobj = ds->ds_object;
 	struct feature_type_uint64_array_arg *ftuaa =
 	    kmem_zalloc(sizeof (*ftuaa), KM_SLEEP);
 	ftuaa->length = (int64_t)num_redact_snaps;
 	if (num_redact_snaps > 0) {
 		ftuaa->array = kmem_alloc(num_redact_snaps * sizeof (uint64_t),
 		    KM_SLEEP);
 		memcpy(ftuaa->array, redact_snaps, num_redact_snaps *
 		    sizeof (uint64_t));
 	}
 	dsl_dataset_activate_feature(dsobj, SPA_FEATURE_REDACTED_DATASETS,
 	    ftuaa, tx);
 	ds->ds_feature[SPA_FEATURE_REDACTED_DATASETS] = ftuaa;
 }
 
 /*
  * Find and return (in *oldest_dsobj) the oldest snapshot of the dsobj
  * dataset whose birth time is >= min_txg.
  */
 int
 dsl_dataset_oldest_snapshot(spa_t *spa, uint64_t head_ds, uint64_t min_txg,
     uint64_t *oldest_dsobj)
 {
 	dsl_dataset_t *ds;
 	dsl_pool_t *dp = spa->spa_dsl_pool;
 
 	int error = dsl_dataset_hold_obj(dp, head_ds, FTAG, &ds);
 	if (error != 0)
 		return (error);
 
 	uint64_t prev_obj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
 	uint64_t prev_obj_txg = dsl_dataset_phys(ds)->ds_prev_snap_txg;
 
 	while (prev_obj != 0 && min_txg < prev_obj_txg) {
 		dsl_dataset_rele(ds, FTAG);
 		if ((error = dsl_dataset_hold_obj(dp, prev_obj,
 		    FTAG, &ds)) != 0)
 			return (error);
 		prev_obj_txg = dsl_dataset_phys(ds)->ds_prev_snap_txg;
 		prev_obj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
 	}
 	*oldest_dsobj = ds->ds_object;
 	dsl_dataset_rele(ds, FTAG);
 	return (0);
 }
 
 ZFS_MODULE_PARAM(zfs, zfs_, max_recordsize, UINT, ZMOD_RW,
 	"Max allowed record size");
 
 ZFS_MODULE_PARAM(zfs, zfs_, allow_redacted_dataset_mount, INT, ZMOD_RW,
 	"Allow mounting of redacted datasets");
 
 ZFS_MODULE_PARAM(zfs, zfs_, snapshot_history_enabled, INT, ZMOD_RW,
 	"Include snapshot events in pool history/events");
 
 EXPORT_SYMBOL(dsl_dataset_hold);
 EXPORT_SYMBOL(dsl_dataset_hold_flags);
 EXPORT_SYMBOL(dsl_dataset_hold_obj);
 EXPORT_SYMBOL(dsl_dataset_hold_obj_flags);
 EXPORT_SYMBOL(dsl_dataset_own);
 EXPORT_SYMBOL(dsl_dataset_own_obj);
 EXPORT_SYMBOL(dsl_dataset_name);
 EXPORT_SYMBOL(dsl_dataset_rele);
 EXPORT_SYMBOL(dsl_dataset_rele_flags);
 EXPORT_SYMBOL(dsl_dataset_disown);
 EXPORT_SYMBOL(dsl_dataset_tryown);
 EXPORT_SYMBOL(dsl_dataset_create_sync);
 EXPORT_SYMBOL(dsl_dataset_create_sync_dd);
 EXPORT_SYMBOL(dsl_dataset_snapshot_check);
 EXPORT_SYMBOL(dsl_dataset_snapshot_sync);
 EXPORT_SYMBOL(dsl_dataset_promote);
 EXPORT_SYMBOL(dsl_dataset_user_hold);
 EXPORT_SYMBOL(dsl_dataset_user_release);
 EXPORT_SYMBOL(dsl_dataset_get_holds);
 EXPORT_SYMBOL(dsl_dataset_get_blkptr);
 EXPORT_SYMBOL(dsl_dataset_get_spa);
 EXPORT_SYMBOL(dsl_dataset_modified_since_snap);
 EXPORT_SYMBOL(dsl_dataset_space_written);
 EXPORT_SYMBOL(dsl_dataset_space_wouldfree);
 EXPORT_SYMBOL(dsl_dataset_sync);
 EXPORT_SYMBOL(dsl_dataset_block_born);
 EXPORT_SYMBOL(dsl_dataset_block_kill);
 EXPORT_SYMBOL(dsl_dataset_dirty);
 EXPORT_SYMBOL(dsl_dataset_stats);
 EXPORT_SYMBOL(dsl_dataset_fast_stat);
 EXPORT_SYMBOL(dsl_dataset_space);
 EXPORT_SYMBOL(dsl_dataset_fsid_guid);
 EXPORT_SYMBOL(dsl_dsobj_to_dsname);
 EXPORT_SYMBOL(dsl_dataset_check_quota);
 EXPORT_SYMBOL(dsl_dataset_clone_swap_check_impl);
 EXPORT_SYMBOL(dsl_dataset_clone_swap_sync_impl);
diff --git a/sys/contrib/openzfs/module/zfs/vdev_draid.c b/sys/contrib/openzfs/module/zfs/vdev_draid.c
index 13bb33cc6871..419c8ac5bb28 100644
--- a/sys/contrib/openzfs/module/zfs/vdev_draid.c
+++ b/sys/contrib/openzfs/module/zfs/vdev_draid.c
@@ -1,2821 +1,2821 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 /*
  * Copyright (c) 2018 Intel Corporation.
  * Copyright (c) 2020 by Lawrence Livermore National Security, LLC.
  */
 
 #include <sys/zfs_context.h>
 #include <sys/spa.h>
 #include <sys/spa_impl.h>
 #include <sys/vdev_impl.h>
 #include <sys/vdev_draid.h>
 #include <sys/vdev_raidz.h>
 #include <sys/vdev_rebuild.h>
 #include <sys/abd.h>
 #include <sys/zio.h>
 #include <sys/nvpair.h>
 #include <sys/zio_checksum.h>
 #include <sys/fs/zfs.h>
 #include <sys/fm/fs/zfs.h>
 #include <zfs_fletcher.h>
 
 #ifdef ZFS_DEBUG
 #include <sys/vdev.h>	/* For vdev_xlate() in vdev_draid_io_verify() */
 #endif
 
 /*
  * dRAID is a distributed spare implementation for ZFS. A dRAID vdev is
  * comprised of multiple raidz redundancy groups which are spread over the
  * dRAID children. To ensure an even distribution, and avoid hot spots, a
  * permutation mapping is applied to the order of the dRAID children.
  * This mixing effectively distributes the parity columns evenly over all
  * of the disks in the dRAID.
  *
  * This is beneficial because it means when resilvering all of the disks
  * can participate thereby increasing the available IOPs and bandwidth.
  * Furthermore, by reserving a small fraction of each child's total capacity
  * virtual distributed spare disks can be created. These spares similarly
  * benefit from the performance gains of spanning all of the children. The
  * consequence of which is that resilvering to a distributed spare can
  * substantially reduce the time required to restore full parity to pool
  * with a failed disks.
  *
  * === dRAID group layout ===
  *
  * First, let's define a "row" in the configuration to be a 16M chunk from
  * each physical drive at the same offset. This is the minimum allowable
  * size since it must be possible to store a full 16M block when there is
  * only a single data column. Next, we define a "group" to be a set of
  * sequential disks containing both the parity and data columns. We allow
  * groups to span multiple rows in order to align any group size to any
  * number of physical drives. Finally, a "slice" is comprised of the rows
  * which contain the target number of groups. The permutation mappings
  * are applied in a round robin fashion to each slice.
  *
  * Given D+P drives in a group (including parity drives) and C-S physical
  * drives (not including the spare drives), we can distribute the groups
  * across R rows without remainder by selecting the least common multiple
  * of D+P and C-S as the number of groups; i.e. ngroups = LCM(D+P, C-S).
  *
  * In the example below, there are C=14 physical drives in the configuration
  * with S=2 drives worth of spare capacity. Each group has a width of 9
  * which includes D=8 data and P=1 parity drive. There are 4 groups and
  * 3 rows per slice.  Each group has a size of 144M (16M * 9) and a slice
  * size is 576M (144M * 4). When allocating from a dRAID each group is
  * filled before moving on to the next as show in slice0 below.
  *
  *             data disks (8 data + 1 parity)          spares (2)
  *     +===+===+===+===+===+===+===+===+===+===+===+===+===+===+
  *  ^  | 2 | 6 | 1 | 11| 4 | 0 | 7 | 10| 8 | 9 | 13| 5 | 12| 3 | device map 0
  *  |  +===+===+===+===+===+===+===+===+===+===+===+===+===+===+
  *  |  |              group 0              |  group 1..|       |
  *  |  +-----------------------------------+-----------+-------|
  *  |  | 0   1   2   3   4   5   6   7   8 | 36  37  38|       |  r
  *  |  | 9   10  11  12  13  14  15  16  17| 45  46  47|       |  o
  *  |  | 18  19  20  21  22  23  24  25  26| 54  55  56|       |  w
  *     | 27  28  29  30  31  32  33  34  35| 63  64  65|       |  0
  *  s  +-----------------------+-----------------------+-------+
  *  l  |       ..group 1       |        group 2..      |       |
  *  i  +-----------------------+-----------------------+-------+
  *  c  | 39  40  41  42  43  44| 72  73  74  75  76  77|       |  r
  *  e  | 48  49  50  51  52  53| 81  82  83  84  85  86|       |  o
  *  0  | 57  58  59  60  61  62| 90  91  92  93  94  95|       |  w
  *     | 66  67  68  69  70  71| 99 100 101 102 103 104|       |  1
  *  |  +-----------+-----------+-----------------------+-------+
  *  |  |..group 2  |            group 3                |       |
  *  |  +-----------+-----------+-----------------------+-------+
  *  |  | 78  79  80|108 109 110 111 112 113 114 115 116|       |  r
  *  |  | 87  88  89|117 118 119 120 121 122 123 124 125|       |  o
  *  |  | 96  97  98|126 127 128 129 130 131 132 133 134|       |  w
  *  v  |105 106 107|135 136 137 138 139 140 141 142 143|       |  2
  *     +===+===+===+===+===+===+===+===+===+===+===+===+===+===+
  *     | 9 | 11| 12| 2 | 4 | 1 | 3 | 0 | 10| 13| 8 | 5 | 6 | 7 | device map 1
  *  s  +===+===+===+===+===+===+===+===+===+===+===+===+===+===+
  *  l  |              group 4              |  group 5..|       | row 3
  *  i  +-----------------------+-----------+-----------+-------|
  *  c  |       ..group 5       |        group 6..      |       | row 4
  *  e  +-----------+-----------+-----------------------+-------+
  *  1  |..group 6  |            group 7                |       | row 5
  *     +===+===+===+===+===+===+===+===+===+===+===+===+===+===+
  *     | 3 | 5 | 10| 8 | 6 | 11| 12| 0 | 2 | 4 | 7 | 1 | 9 | 13| device map 2
  *  s  +===+===+===+===+===+===+===+===+===+===+===+===+===+===+
  *  l  |              group 8              |  group 9..|       | row 6
  *  i  +-----------------------------------------------+-------|
  *  c  |       ..group 9       |        group 10..     |       | row 7
  *  e  +-----------------------+-----------------------+-------+
  *  2  |..group 10 |            group 11               |       | row 8
  *     +-----------+-----------------------------------+-------+
  *
  * This layout has several advantages over requiring that each row contain
  * a whole number of groups.
  *
  * 1. The group count is not a relevant parameter when defining a dRAID
  *    layout. Only the group width is needed, and *all* groups will have
  *    the desired size.
  *
  * 2. All possible group widths (<= physical disk count) can be supported.
  *
  * 3. The logic within vdev_draid.c is simplified when the group width is
  *    the same for all groups (although some of the logic around computing
  *    permutation numbers and drive offsets is more complicated).
  *
  * N.B. The following array describes all valid dRAID permutation maps.
  * Each row is used to generate a permutation map for a different number
  * of children from a unique seed. The seeds were generated and carefully
  * evaluated by the 'draid' utility in order to provide balanced mappings.
  * In addition to the seed a checksum of the in-memory mapping is stored
  * for verification.
  *
  * The imbalance ratio of a given failure (e.g. 5 disks wide, child 3 failed,
  * with a given permutation map) is the ratio of the amounts of I/O that will
  * be sent to the least and most busy disks when resilvering. The average
  * imbalance ratio (of a given number of disks and permutation map) is the
  * average of the ratios of all possible single and double disk failures.
  *
  * In order to achieve a low imbalance ratio the number of permutations in
  * the mapping must be significantly larger than the number of children.
  * For dRAID the number of permutations has been limited to 512 to minimize
  * the map size. This does result in a gradually increasing imbalance ratio
  * as seen in the table below. Increasing the number of permutations for
  * larger child counts would reduce the imbalance ratio. However, in practice
  * when there are a large number of children each child is responsible for
  * fewer total IOs so it's less of a concern.
  *
  * Note these values are hard coded and must never be changed.  Existing
  * pools depend on the same mapping always being generated in order to
  * read and write from the correct locations.  Any change would make
  * existing pools completely inaccessible.
  */
 static const draid_map_t draid_maps[VDEV_DRAID_MAX_MAPS] = {
 	{   2, 256, 0x89ef3dabbcc7de37, 0x00000000433d433d },	/* 1.000 */
 	{   3, 256, 0x89a57f3de98121b4, 0x00000000bcd8b7b5 },	/* 1.000 */
 	{   4, 256, 0xc9ea9ec82340c885, 0x00000001819d7c69 },	/* 1.000 */
 	{   5, 256, 0xf46733b7f4d47dfd, 0x00000002a1648d74 },	/* 1.010 */
 	{   6, 256, 0x88c3c62d8585b362, 0x00000003d3b0c2c4 },	/* 1.031 */
 	{   7, 256, 0x3a65d809b4d1b9d5, 0x000000055c4183ee },	/* 1.043 */
 	{   8, 256, 0xe98930e3c5d2e90a, 0x00000006edfb0329 },	/* 1.059 */
 	{   9, 256, 0x5a5430036b982ccb, 0x00000008ceaf6934 },	/* 1.056 */
 	{  10, 256, 0x92bf389e9eadac74, 0x0000000b26668c09 },	/* 1.072 */
 	{  11, 256, 0x74ccebf1dcf3ae80, 0x0000000dd691358c },	/* 1.083 */
 	{  12, 256, 0x8847e41a1a9f5671, 0x00000010a0c63c8e },	/* 1.097 */
 	{  13, 256, 0x7481b56debf0e637, 0x0000001424121fe4 },	/* 1.100 */
 	{  14, 256, 0x559b8c44065f8967, 0x00000016ab2ff079 },	/* 1.121 */
 	{  15, 256, 0x34c49545a2ee7f01, 0x0000001a6028efd6 },	/* 1.103 */
 	{  16, 256, 0xb85f4fa81a7698f7, 0x0000001e95ff5e66 },	/* 1.111 */
 	{  17, 256, 0x6353e47b7e47aba0, 0x00000021a81fa0fe },	/* 1.133 */
 	{  18, 256, 0xaa549746b1cbb81c, 0x00000026f02494c9 },	/* 1.131 */
 	{  19, 256, 0x892e343f2f31d690, 0x00000029eb392835 },	/* 1.130 */
 	{  20, 256, 0x76914824db98cc3f, 0x0000003004f31a7c },	/* 1.141 */
 	{  21, 256, 0x4b3cbabf9cfb1d0f, 0x00000036363a2408 },	/* 1.139 */
 	{  22, 256, 0xf45c77abb4f035d4, 0x00000038dd0f3e84 },	/* 1.150 */
 	{  23, 256, 0x5e18bd7f3fd4baf4, 0x0000003f0660391f },	/* 1.174 */
 	{  24, 256, 0xa7b3a4d285d6503b, 0x000000443dfc9ff6 },	/* 1.168 */
 	{  25, 256, 0x56ac7dd967521f5a, 0x0000004b03a87eb7 },	/* 1.180 */
 	{  26, 256, 0x3a42dfda4eb880f7, 0x000000522c719bba },	/* 1.226 */
 	{  27, 256, 0xd200d2fc6b54bf60, 0x0000005760b4fdf5 },	/* 1.228 */
 	{  28, 256, 0xc52605bbd486c546, 0x0000005e00d8f74c },	/* 1.217 */
 	{  29, 256, 0xc761779e63cd762f, 0x00000067be3cd85c },	/* 1.239 */
 	{  30, 256, 0xca577b1e07f85ca5, 0x0000006f5517f3e4 },	/* 1.238 */
 	{  31, 256, 0xfd50a593c518b3d4, 0x0000007370e7778f },	/* 1.273 */
 	{  32, 512, 0xc6c87ba5b042650b, 0x000000f7eb08a156 },	/* 1.191 */
 	{  33, 512, 0xc3880d0c9d458304, 0x0000010734b5d160 },	/* 1.199 */
 	{  34, 512, 0xe920927e4d8b2c97, 0x00000118c1edbce0 },	/* 1.195 */
 	{  35, 512, 0x8da7fcda87bde316, 0x0000012a3e9f9110 },	/* 1.201 */
 	{  36, 512, 0xcf09937491514a29, 0x0000013bd6a24bef },	/* 1.194 */
 	{  37, 512, 0x9b5abbf345cbd7cc, 0x0000014b9d90fac3 },	/* 1.237 */
 	{  38, 512, 0x506312a44668d6a9, 0x0000015e1b5f6148 },	/* 1.242 */
 	{  39, 512, 0x71659ede62b4755f, 0x00000173ef029bcd },	/* 1.231 */
 	{  40, 512, 0xa7fde73fb74cf2d7, 0x000001866fb72748 },	/* 1.233 */
 	{  41, 512, 0x19e8b461a1dea1d3, 0x000001a046f76b23 },	/* 1.271 */
 	{  42, 512, 0x031c9b868cc3e976, 0x000001afa64c49d3 },	/* 1.263 */
 	{  43, 512, 0xbaa5125faa781854, 0x000001c76789e278 },	/* 1.270 */
 	{  44, 512, 0x4ed55052550d721b, 0x000001d800ccd8eb },	/* 1.281 */
 	{  45, 512, 0x0fd63ddbdff90677, 0x000001f08ad59ed2 },	/* 1.282 */
 	{  46, 512, 0x36d66546de7fdd6f, 0x000002016f09574b },	/* 1.286 */
 	{  47, 512, 0x99f997e7eafb69d7, 0x0000021e42e47cb6 },	/* 1.329 */
 	{  48, 512, 0xbecd9c2571312c5d, 0x000002320fe2872b },	/* 1.286 */
 	{  49, 512, 0xd97371329e488a32, 0x0000024cd73f2ca7 },	/* 1.322 */
 	{  50, 512, 0x30e9b136670749ee, 0x000002681c83b0e0 },	/* 1.335 */
 	{  51, 512, 0x11ad6bc8f47aaeb4, 0x0000027e9261b5d5 },	/* 1.305 */
 	{  52, 512, 0x68e445300af432c1, 0x0000029aa0eb7dbf },	/* 1.330 */
 	{  53, 512, 0x910fb561657ea98c, 0x000002b3dca04853 },	/* 1.365 */
 	{  54, 512, 0xd619693d8ce5e7a5, 0x000002cc280e9c97 },	/* 1.334 */
 	{  55, 512, 0x24e281f564dbb60a, 0x000002e9fa842713 },	/* 1.364 */
 	{  56, 512, 0x947a7d3bdaab44c5, 0x000003046680f72e },	/* 1.374 */
 	{  57, 512, 0x2d44fec9c093e0de, 0x00000324198ba810 },	/* 1.363 */
 	{  58, 512, 0x87743c272d29bb4c, 0x0000033ec48c9ac9 },	/* 1.401 */
 	{  59, 512, 0x96aa3b6f67f5d923, 0x0000034faead902c },	/* 1.392 */
 	{  60, 512, 0x94a4f1faf520b0d3, 0x0000037d713ab005 },	/* 1.360 */
 	{  61, 512, 0xb13ed3a272f711a2, 0x00000397368f3cbd },	/* 1.396 */
 	{  62, 512, 0x3b1b11805fa4a64a, 0x000003b8a5e2840c },	/* 1.453 */
 	{  63, 512, 0x4c74caad9172ba71, 0x000003d4be280290 },	/* 1.437 */
 	{  64, 512, 0x035ff643923dd29e, 0x000003fad6c355e1 },	/* 1.402 */
 	{  65, 512, 0x768e9171b11abd3c, 0x0000040eb07fed20 },	/* 1.459 */
 	{  66, 512, 0x75880e6f78a13ddd, 0x000004433d6acf14 },	/* 1.423 */
 	{  67, 512, 0x910b9714f698a877, 0x00000451ea65d5db },	/* 1.447 */
 	{  68, 512, 0x87f5db6f9fdcf5c7, 0x000004732169e3f7 },	/* 1.450 */
 	{  69, 512, 0x836d4968fbaa3706, 0x000004954068a380 },	/* 1.455 */
 	{  70, 512, 0xc567d73a036421ab, 0x000004bd7cb7bd3d },	/* 1.463 */
 	{  71, 512, 0x619df40f240b8fed, 0x000004e376c2e972 },	/* 1.463 */
 	{  72, 512, 0x42763a680d5bed8e, 0x000005084275c680 },	/* 1.452 */
 	{  73, 512, 0x5866f064b3230431, 0x0000052906f2c9ab },	/* 1.498 */
 	{  74, 512, 0x9fa08548b1621a44, 0x0000054708019247 },	/* 1.526 */
 	{  75, 512, 0xb6053078ce0fc303, 0x00000572cc5c72b0 },	/* 1.491 */
 	{  76, 512, 0x4a7aad7bf3890923, 0x0000058e987bc8e9 },	/* 1.470 */
 	{  77, 512, 0xe165613fd75b5a53, 0x000005c20473a211 },	/* 1.527 */
 	{  78, 512, 0x3ff154ac878163a6, 0x000005d659194bf3 },	/* 1.509 */
 	{  79, 512, 0x24b93ade0aa8a532, 0x0000060a201c4f8e },	/* 1.569 */
 	{  80, 512, 0xc18e2d14cd9bb554, 0x0000062c55cfe48c },	/* 1.555 */
 	{  81, 512, 0x98cc78302feb58b6, 0x0000066656a07194 },	/* 1.509 */
 	{  82, 512, 0xc6c5fd5a2abc0543, 0x0000067cff94fbf8 },	/* 1.596 */
 	{  83, 512, 0xa7962f514acbba21, 0x000006ab7b5afa2e },	/* 1.568 */
 	{  84, 512, 0xba02545069ddc6dc, 0x000006d19861364f },	/* 1.541 */
 	{  85, 512, 0x447c73192c35073e, 0x000006fce315ce35 },	/* 1.623 */
 	{  86, 512, 0x48beef9e2d42b0c2, 0x00000720a8e38b6b },	/* 1.620 */
 	{  87, 512, 0x4874cf98541a35e0, 0x00000758382a2273 },	/* 1.597 */
 	{  88, 512, 0xad4cf8333a31127a, 0x00000781e1651b1b },	/* 1.575 */
 	{  89, 512, 0x47ae4859d57888c1, 0x000007b27edbe5bc },	/* 1.627 */
 	{  90, 512, 0x06f7723cfe5d1891, 0x000007dc2a96d8eb },	/* 1.596 */
 	{  91, 512, 0xd4e44218d660576d, 0x0000080ac46f02d5 },	/* 1.622 */
 	{  92, 512, 0x7066702b0d5be1f2, 0x00000832c96d154e },	/* 1.695 */
 	{  93, 512, 0x011209b4f9e11fb9, 0x0000085eefda104c },	/* 1.605 */
 	{  94, 512, 0x47ffba30a0b35708, 0x00000899badc32dc },	/* 1.625 */
 	{  95, 512, 0x1a95a6ac4538aaa8, 0x000008b6b69a42b2 },	/* 1.687 */
 	{  96, 512, 0xbda2b239bb2008eb, 0x000008f22d2de38a },	/* 1.621 */
 	{  97, 512, 0x7ffa0bea90355c6c, 0x0000092e5b23b816 },	/* 1.699 */
 	{  98, 512, 0x1d56ba34be426795, 0x0000094f482e5d1b },	/* 1.688 */
 	{  99, 512, 0x0aa89d45c502e93d, 0x00000977d94a98ce },	/* 1.642 */
 	{ 100, 512, 0x54369449f6857774, 0x000009c06c9b34cc },	/* 1.683 */
 	{ 101, 512, 0xf7d4dd8445b46765, 0x000009e5dc542259 },	/* 1.755 */
 	{ 102, 512, 0xfa8866312f169469, 0x00000a16b54eae93 },	/* 1.692 */
 	{ 103, 512, 0xd8a5aea08aef3ff9, 0x00000a381d2cbfe7 },	/* 1.747 */
 	{ 104, 512, 0x66bcd2c3d5f9ef0e, 0x00000a8191817be7 },	/* 1.751 */
 	{ 105, 512, 0x3fb13a47a012ec81, 0x00000ab562b9a254 },	/* 1.751 */
 	{ 106, 512, 0x43100f01c9e5e3ca, 0x00000aeee84c185f },	/* 1.726 */
 	{ 107, 512, 0xca09c50ccee2d054, 0x00000b1c359c047d },	/* 1.788 */
 	{ 108, 512, 0xd7176732ac503f9b, 0x00000b578bc52a73 },	/* 1.740 */
 	{ 109, 512, 0xed206e51f8d9422d, 0x00000b8083e0d960 },	/* 1.780 */
 	{ 110, 512, 0x17ead5dc6ba0dcd6, 0x00000bcfb1a32ca8 },	/* 1.836 */
 	{ 111, 512, 0x5f1dc21e38a969eb, 0x00000c0171becdd6 },	/* 1.778 */
 	{ 112, 512, 0xddaa973de33ec528, 0x00000c3edaba4b95 },	/* 1.831 */
 	{ 113, 512, 0x2a5eccd7735a3630, 0x00000c630664e7df },	/* 1.825 */
 	{ 114, 512, 0xafcccee5c0b71446, 0x00000cb65392f6e4 },	/* 1.826 */
 	{ 115, 512, 0x8fa30c5e7b147e27, 0x00000cd4db391e55 },	/* 1.843 */
 	{ 116, 512, 0x5afe0711fdfafd82, 0x00000d08cb4ec35d },	/* 1.826 */
 	{ 117, 512, 0x533a6090238afd4c, 0x00000d336f115d1b },	/* 1.803 */
 	{ 118, 512, 0x90cf11b595e39a84, 0x00000d8e041c2048 },	/* 1.857 */
 	{ 119, 512, 0x0d61a3b809444009, 0x00000dcb798afe35 },	/* 1.877 */
 	{ 120, 512, 0x7f34da0f54b0d114, 0x00000df3922664e1 },	/* 1.849 */
 	{ 121, 512, 0xa52258d5b72f6551, 0x00000e4d37a9872d },	/* 1.867 */
 	{ 122, 512, 0xc1de54d7672878db, 0x00000e6583a94cf6 },	/* 1.978 */
 	{ 123, 512, 0x1d03354316a414ab, 0x00000ebffc50308d },	/* 1.947 */
 	{ 124, 512, 0xcebdcc377665412c, 0x00000edee1997cea },	/* 1.865 */
 	{ 125, 512, 0x4ddd4c04b1a12344, 0x00000f21d64b373f },	/* 1.881 */
 	{ 126, 512, 0x64fc8f94e3973658, 0x00000f8f87a8896b },	/* 1.882 */
 	{ 127, 512, 0x68765f78034a334e, 0x00000fb8fe62197e },	/* 1.867 */
 	{ 128, 512, 0xaf36b871a303e816, 0x00000fec6f3afb1e },	/* 1.972 */
 	{ 129, 512, 0x2a4cbf73866c3a28, 0x00001027febfe4e5 },	/* 1.896 */
 	{ 130, 512, 0x9cb128aacdcd3b2f, 0x0000106aa8ac569d },	/* 1.965 */
 	{ 131, 512, 0x5511d41c55869124, 0x000010bbd755ddf1 },	/* 1.963 */
 	{ 132, 512, 0x42f92461937f284a, 0x000010fb8bceb3b5 },	/* 1.925 */
 	{ 133, 512, 0xe2d89a1cf6f1f287, 0x0000114cf5331e34 },	/* 1.862 */
 	{ 134, 512, 0xdc631a038956200e, 0x0000116428d2adc5 },	/* 2.042 */
 	{ 135, 512, 0xb2e5ac222cd236be, 0x000011ca88e4d4d2 },	/* 1.935 */
 	{ 136, 512, 0xbc7d8236655d88e7, 0x000011e39cb94e66 },	/* 2.005 */
 	{ 137, 512, 0x073e02d88d2d8e75, 0x0000123136c7933c },	/* 2.041 */
 	{ 138, 512, 0x3ddb9c3873166be0, 0x00001280e4ec6d52 },	/* 1.997 */
 	{ 139, 512, 0x7d3b1a845420e1b5, 0x000012c2e7cd6a44 },	/* 1.996 */
 	{ 140, 512, 0x60102308aa7b2a6c, 0x000012fc490e6c7d },	/* 2.053 */
 	{ 141, 512, 0xdb22bb2f9eb894aa, 0x00001343f5a85a1a },	/* 1.971 */
 	{ 142, 512, 0xd853f879a13b1606, 0x000013bb7d5f9048 },	/* 2.018 */
 	{ 143, 512, 0x001620a03f804b1d, 0x000013e74cc794fd },	/* 1.961 */
 	{ 144, 512, 0xfdb52dda76fbf667, 0x00001442d2f22480 },	/* 2.046 */
 	{ 145, 512, 0xa9160110f66e24ff, 0x0000144b899f9dbb },	/* 1.968 */
 	{ 146, 512, 0x77306a30379ae03b, 0x000014cb98eb1f81 },	/* 2.143 */
 	{ 147, 512, 0x14f5985d2752319d, 0x000014feab821fc9 },	/* 2.064 */
 	{ 148, 512, 0xa4b8ff11de7863f8, 0x0000154a0e60b9c9 },	/* 2.023 */
 	{ 149, 512, 0x44b345426455c1b3, 0x000015999c3c569c },	/* 2.136 */
 	{ 150, 512, 0x272677826049b46c, 0x000015c9697f4b92 },	/* 2.063 */
 	{ 151, 512, 0x2f9216e2cd74fe40, 0x0000162b1f7bbd39 },	/* 1.974 */
 	{ 152, 512, 0x706ae3e763ad8771, 0x00001661371c55e1 },	/* 2.210 */
 	{ 153, 512, 0xf7fd345307c2480e, 0x000016e251f28b6a },	/* 2.006 */
 	{ 154, 512, 0x6e94e3d26b3139eb, 0x000016f2429bb8c6 },	/* 2.193 */
 	{ 155, 512, 0x5458bbfbb781fcba, 0x0000173efdeca1b9 },	/* 2.163 */
 	{ 156, 512, 0xa80e2afeccd93b33, 0x000017bfdcb78adc },	/* 2.046 */
 	{ 157, 512, 0x1e4ccbb22796cf9d, 0x00001826fdcc39c9 },	/* 2.084 */
 	{ 158, 512, 0x8fba4b676aaa3663, 0x00001841a1379480 },	/* 2.264 */
 	{ 159, 512, 0xf82b843814b315fa, 0x000018886e19b8a3 },	/* 2.074 */
 	{ 160, 512, 0x7f21e920ecf753a3, 0x0000191812ca0ea7 },	/* 2.282 */
 	{ 161, 512, 0x48bb8ea2c4caa620, 0x0000192f310faccf },	/* 2.148 */
 	{ 162, 512, 0x5cdb652b4952c91b, 0x0000199e1d7437c7 },	/* 2.355 */
 	{ 163, 512, 0x6ac1ba6f78c06cd4, 0x000019cd11f82c70 },	/* 2.164 */
 	{ 164, 512, 0x9faf5f9ca2669a56, 0x00001a18d5431f6a },	/* 2.393 */
 	{ 165, 512, 0xaa57e9383eb01194, 0x00001a9e7d253d85 },	/* 2.178 */
 	{ 166, 512, 0x896967bf495c34d2, 0x00001afb8319b9fc },	/* 2.334 */
 	{ 167, 512, 0xdfad5f05de225f1b, 0x00001b3a59c3093b },	/* 2.266 */
 	{ 168, 512, 0xfd299a99f9f2abdd, 0x00001bb6f1a10799 },	/* 2.304 */
 	{ 169, 512, 0xdda239e798fe9fd4, 0x00001bfae0c9692d },	/* 2.218 */
 	{ 170, 512, 0x5fca670414a32c3e, 0x00001c22129dbcff },	/* 2.377 */
 	{ 171, 512, 0x1bb8934314b087de, 0x00001c955db36cd0 },	/* 2.155 */
 	{ 172, 512, 0xd96394b4b082200d, 0x00001cfc8619b7e6 },	/* 2.404 */
 	{ 173, 512, 0xb612a7735b1c8cbc, 0x00001d303acdd585 },	/* 2.205 */
 	{ 174, 512, 0x28e7430fe5875fe1, 0x00001d7ed5b3697d },	/* 2.359 */
 	{ 175, 512, 0x5038e89efdd981b9, 0x00001dc40ec35c59 },	/* 2.158 */
 	{ 176, 512, 0x075fd78f1d14db7c, 0x00001e31c83b4a2b },	/* 2.614 */
 	{ 177, 512, 0xc50fafdb5021be15, 0x00001e7cdac82fbc },	/* 2.239 */
 	{ 178, 512, 0xe6dc7572ce7b91c7, 0x00001edd8bb454fc },	/* 2.493 */
 	{ 179, 512, 0x21f7843e7beda537, 0x00001f3a8e019d6c },	/* 2.327 */
 	{ 180, 512, 0xc83385e20b43ec82, 0x00001f70735ec137 },	/* 2.231 */
 	{ 181, 512, 0xca818217dddb21fd, 0x0000201ca44c5a3c },	/* 2.237 */
 	{ 182, 512, 0xe6035defea48f933, 0x00002038e3346658 },	/* 2.691 */
 	{ 183, 512, 0x47262a4f953dac5a, 0x000020c2e554314e },	/* 2.170 */
 	{ 184, 512, 0xe24c7246260873ea, 0x000021197e618d64 },	/* 2.600 */
 	{ 185, 512, 0xeef6b57c9b58e9e1, 0x0000217ea48ecddc },	/* 2.391 */
 	{ 186, 512, 0x2becd3346e386142, 0x000021c496d4a5f9 },	/* 2.677 */
 	{ 187, 512, 0x63c6207bdf3b40a3, 0x0000220e0f2eec0c },	/* 2.410 */
 	{ 188, 512, 0x3056ce8989767d4b, 0x0000228eb76cd137 },	/* 2.776 */
 	{ 189, 512, 0x91af61c307cee780, 0x000022e17e2ea501 },	/* 2.266 */
 	{ 190, 512, 0xda359da225f6d54f, 0x00002358a2debc19 },	/* 2.717 */
 	{ 191, 512, 0x0a5f7a2a55607ba0, 0x0000238a79dac18c },	/* 2.474 */
 	{ 192, 512, 0x27bb75bf5224638a, 0x00002403a58e2351 },	/* 2.673 */
 	{ 193, 512, 0x1ebfdb94630f5d0f, 0x00002492a10cb339 },	/* 2.420 */
 	{ 194, 512, 0x6eae5e51d9c5f6fb, 0x000024ce4bf98715 },	/* 2.898 */
 	{ 195, 512, 0x08d903b4daedc2e0, 0x0000250d1e15886c },	/* 2.363 */
 	{ 196, 512, 0xc722a2f7fa7cd686, 0x0000258a99ed0c9e },	/* 2.747 */
 	{ 197, 512, 0x8f71faf0e54e361d, 0x000025dee11976f5 },	/* 2.531 */
 	{ 198, 512, 0x87f64695c91a54e7, 0x0000264e00a43da0 },	/* 2.707 */
 	{ 199, 512, 0xc719cbac2c336b92, 0x000026d327277ac1 },	/* 2.315 */
 	{ 200, 512, 0xe7e647afaf771ade, 0x000027523a5c44bf },	/* 3.012 */
 	{ 201, 512, 0x12d4b5c38ce8c946, 0x0000273898432545 },	/* 2.378 */
 	{ 202, 512, 0xf2e0cd4067bdc94a, 0x000027e47bb2c935 },	/* 2.969 */
 	{ 203, 512, 0x21b79f14d6d947d3, 0x0000281e64977f0d },	/* 2.594 */
 	{ 204, 512, 0x515093f952f18cd6, 0x0000289691a473fd },	/* 2.763 */
 	{ 205, 512, 0xd47b160a1b1022c8, 0x00002903e8b52411 },	/* 2.457 */
 	{ 206, 512, 0xc02fc96684715a16, 0x0000297515608601 },	/* 3.057 */
 	{ 207, 512, 0xef51e68efba72ed0, 0x000029ef73604804 },	/* 2.590 */
 	{ 208, 512, 0x9e3be6e5448b4f33, 0x00002a2846ed074b },	/* 3.047 */
 	{ 209, 512, 0x81d446c6d5fec063, 0x00002a92ca693455 },	/* 2.676 */
 	{ 210, 512, 0xff215de8224e57d5, 0x00002b2271fe3729 },	/* 2.993 */
 	{ 211, 512, 0xe2524d9ba8f69796, 0x00002b64b99c3ba2 },	/* 2.457 */
 	{ 212, 512, 0xf6b28e26097b7e4b, 0x00002bd768b6e068 },	/* 3.182 */
 	{ 213, 512, 0x893a487f30ce1644, 0x00002c67f722b4b2 },	/* 2.563 */
 	{ 214, 512, 0x386566c3fc9871df, 0x00002cc1cf8b4037 },	/* 3.025 */
 	{ 215, 512, 0x1e0ed78edf1f558a, 0x00002d3948d36c7f },	/* 2.730 */
 	{ 216, 512, 0xe3bc20c31e61f113, 0x00002d6d6b12e025 },	/* 3.036 */
 	{ 217, 512, 0xd6c3ad2e23021882, 0x00002deff7572241 },	/* 2.722 */
 	{ 218, 512, 0xb4a9f95cf0f69c5a, 0x00002e67d537aa36 },	/* 3.356 */
 	{ 219, 512, 0x6e98ed6f6c38e82f, 0x00002e9720626789 },	/* 2.697 */
 	{ 220, 512, 0x2e01edba33fddac7, 0x00002f407c6b0198 },	/* 2.979 */
 	{ 221, 512, 0x559d02e1f5f57ccc, 0x00002fb6a5ab4f24 },	/* 2.858 */
 	{ 222, 512, 0xac18f5a916adcd8e, 0x0000304ae1c5c57e },	/* 3.258 */
 	{ 223, 512, 0x15789fbaddb86f4b, 0x0000306f6e019c78 },	/* 2.693 */
 	{ 224, 512, 0xf4a9c36d5bc4c408, 0x000030da40434213 },	/* 3.259 */
 	{ 225, 512, 0xf640f90fd2727f44, 0x00003189ed37b90c },	/* 2.733 */
 	{ 226, 512, 0xb5313d390d61884a, 0x000031e152616b37 },	/* 3.235 */
 	{ 227, 512, 0x4bae6b3ce9160939, 0x0000321f40aeac42 },	/* 2.983 */
 	{ 228, 512, 0x838c34480f1a66a1, 0x000032f389c0f78e },	/* 3.308 */
 	{ 229, 512, 0xb1c4a52c8e3d6060, 0x0000330062a40284 },	/* 2.715 */
 	{ 230, 512, 0xe0f1110c6d0ed822, 0x0000338be435644f },	/* 3.540 */
 	{ 231, 512, 0x9f1a8ccdcea68d4b, 0x000034045a4e97e1 },	/* 2.779 */
 	{ 232, 512, 0x3261ed62223f3099, 0x000034702cfc401c },	/* 3.084 */
 	{ 233, 512, 0xf2191e2311022d65, 0x00003509dd19c9fc },	/* 2.987 */
 	{ 234, 512, 0xf102a395c2033abc, 0x000035654dc96fae },	/* 3.341 */
 	{ 235, 512, 0x11fe378f027906b6, 0x000035b5193b0264 },	/* 2.793 */
 	{ 236, 512, 0xf777f2c026b337aa, 0x000036704f5d9297 },	/* 3.518 */
 	{ 237, 512, 0x1b04e9c2ee143f32, 0x000036dfbb7af218 },	/* 2.962 */
 	{ 238, 512, 0x2fcec95266f9352c, 0x00003785c8df24a9 },	/* 3.196 */
 	{ 239, 512, 0xfe2b0e47e427dd85, 0x000037cbdf5da729 },	/* 2.914 */
 	{ 240, 512, 0x72b49bf2225f6c6d, 0x0000382227c15855 },	/* 3.408 */
 	{ 241, 512, 0x50486b43df7df9c7, 0x0000389b88be6453 },	/* 2.903 */
 	{ 242, 512, 0x5192a3e53181c8ab, 0x000038ddf3d67263 },	/* 3.778 */
 	{ 243, 512, 0xe9f5d8365296fd5e, 0x0000399f1c6c9e9c },	/* 3.026 */
 	{ 244, 512, 0xc740263f0301efa8, 0x00003a147146512d },	/* 3.347 */
 	{ 245, 512, 0x23cd0f2b5671e67d, 0x00003ab10bcc0d9d },	/* 3.212 */
 	{ 246, 512, 0x002ccc7e5cd41390, 0x00003ad6cd14a6c0 },	/* 3.482 */
 	{ 247, 512, 0x9aafb3c02544b31b, 0x00003b8cb8779fb0 },	/* 3.146 */
 	{ 248, 512, 0x72ba07a78b121999, 0x00003c24142a5a3f },	/* 3.626 */
 	{ 249, 512, 0x3d784aa58edfc7b4, 0x00003cd084817d99 },	/* 2.952 */
 	{ 250, 512, 0xaab750424d8004af, 0x00003d506a8e098e },	/* 3.463 */
 	{ 251, 512, 0x84403fcf8e6b5ca2, 0x00003d4c54c2aec4 },	/* 3.131 */
 	{ 252, 512, 0x71eb7455ec98e207, 0x00003e655715cf2c },	/* 3.538 */
 	{ 253, 512, 0xd752b4f19301595b, 0x00003ecd7b2ca5ac },	/* 2.974 */
 	{ 254, 512, 0xc4674129750499de, 0x00003e99e86d3e95 },	/* 3.843 */
 	{ 255, 512, 0x9772baff5cd12ef5, 0x00003f895c019841 },	/* 3.088 */
 };
 
 /*
  * Verify the map is valid. Each device index must appear exactly
  * once in every row, and the permutation array checksum must match.
  */
 static int
 verify_perms(uint8_t *perms, uint64_t children, uint64_t nperms,
     uint64_t checksum)
 {
 	int countssz = sizeof (uint16_t) * children;
 	uint16_t *counts = kmem_zalloc(countssz, KM_SLEEP);
 
 	for (int i = 0; i < nperms; i++) {
 		for (int j = 0; j < children; j++) {
 			uint8_t val = perms[(i * children) + j];
 
 			if (val >= children || counts[val] != i) {
 				kmem_free(counts, countssz);
 				return (EINVAL);
 			}
 
 			counts[val]++;
 		}
 	}
 
 	if (checksum != 0) {
 		int permssz = sizeof (uint8_t) * children * nperms;
 		zio_cksum_t cksum;
 
 		fletcher_4_native_varsize(perms, permssz, &cksum);
 
 		if (checksum != cksum.zc_word[0]) {
 			kmem_free(counts, countssz);
 			return (ECKSUM);
 		}
 	}
 
 	kmem_free(counts, countssz);
 
 	return (0);
 }
 
 /*
  * Generate the permutation array for the draid_map_t.  These maps control
  * the placement of all data in a dRAID.  Therefore it's critical that the
  * seed always generates the same mapping.  We provide our own pseudo-random
  * number generator for this purpose.
  */
 int
 vdev_draid_generate_perms(const draid_map_t *map, uint8_t **permsp)
 {
 	VERIFY3U(map->dm_children, >=, VDEV_DRAID_MIN_CHILDREN);
 	VERIFY3U(map->dm_children, <=, VDEV_DRAID_MAX_CHILDREN);
 	VERIFY3U(map->dm_seed, !=, 0);
 	VERIFY3U(map->dm_nperms, !=, 0);
 	VERIFY3P(map->dm_perms, ==, NULL);
 
 #ifdef _KERNEL
 	/*
 	 * The kernel code always provides both a map_seed and checksum.
 	 * Only the tests/zfs-tests/cmd/draid/draid.c utility will provide
 	 * a zero checksum when generating new candidate maps.
 	 */
 	VERIFY3U(map->dm_checksum, !=, 0);
 #endif
 	uint64_t children = map->dm_children;
 	uint64_t nperms = map->dm_nperms;
 	int rowsz = sizeof (uint8_t) * children;
 	int permssz = rowsz * nperms;
 	uint8_t *perms;
 
 	/* Allocate the permutation array */
 	perms = vmem_alloc(permssz, KM_SLEEP);
 
 	/* Setup an initial row with a known pattern */
 	uint8_t *initial_row = kmem_alloc(rowsz, KM_SLEEP);
 	for (int i = 0; i < children; i++)
 		initial_row[i] = i;
 
 	uint64_t draid_seed[2] = { VDEV_DRAID_SEED, map->dm_seed };
 	uint8_t *current_row, *previous_row = initial_row;
 
 	/*
 	 * Perform a Fisher-Yates shuffle of each row using the previous
 	 * row as the starting point.  An initial_row with known pattern
 	 * is used as the input for the first row.
 	 */
 	for (int i = 0; i < nperms; i++) {
 		current_row = &perms[i * children];
 		memcpy(current_row, previous_row, rowsz);
 
 		for (int j = children - 1; j > 0; j--) {
 			uint64_t k = vdev_draid_rand(draid_seed) % (j + 1);
 			uint8_t val = current_row[j];
 			current_row[j] = current_row[k];
 			current_row[k] = val;
 		}
 
 		previous_row = current_row;
 	}
 
 	kmem_free(initial_row, rowsz);
 
 	int error = verify_perms(perms, children, nperms, map->dm_checksum);
 	if (error) {
 		vmem_free(perms, permssz);
 		return (error);
 	}
 
 	*permsp = perms;
 
 	return (0);
 }
 
 /*
  * Lookup the fixed draid_map_t for the requested number of children.
  */
 int
 vdev_draid_lookup_map(uint64_t children, const draid_map_t **mapp)
 {
 	for (int i = 0; i < VDEV_DRAID_MAX_MAPS; i++) {
 		if (draid_maps[i].dm_children == children) {
 			*mapp = &draid_maps[i];
 			return (0);
 		}
 	}
 
 	return (ENOENT);
 }
 
 /*
  * Lookup the permutation array and iteration id for the provided offset.
  */
 static void
 vdev_draid_get_perm(vdev_draid_config_t *vdc, uint64_t pindex,
     uint8_t **base, uint64_t *iter)
 {
 	uint64_t ncols = vdc->vdc_children;
 	uint64_t poff = pindex % (vdc->vdc_nperms * ncols);
 
 	*base = vdc->vdc_perms + (poff / ncols) * ncols;
 	*iter = poff % ncols;
 }
 
 static inline uint64_t
 vdev_draid_permute_id(vdev_draid_config_t *vdc,
     uint8_t *base, uint64_t iter, uint64_t index)
 {
 	return ((base[index] + iter) % vdc->vdc_children);
 }
 
 /*
  * Return the asize which is the psize rounded up to a full group width.
  * i.e. vdev_draid_psize_to_asize().
  */
 static uint64_t
 vdev_draid_asize(vdev_t *vd, uint64_t psize, uint64_t txg)
 {
 	(void) txg;
 	vdev_draid_config_t *vdc = vd->vdev_tsd;
 	uint64_t ashift = vd->vdev_ashift;
 
 	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);
 
 	uint64_t rows = ((psize - 1) / (vdc->vdc_ndata << ashift)) + 1;
 	uint64_t asize = (rows * vdc->vdc_groupwidth) << ashift;
 
 	ASSERT3U(asize, !=, 0);
 	ASSERT3U(asize % (vdc->vdc_groupwidth), ==, 0);
 
 	return (asize);
 }
 
 /*
  * Deflate the asize to the psize, this includes stripping parity.
  */
 uint64_t
 vdev_draid_asize_to_psize(vdev_t *vd, uint64_t asize)
 {
 	vdev_draid_config_t *vdc = vd->vdev_tsd;
 
 	ASSERT0(asize % vdc->vdc_groupwidth);
 
 	return ((asize / vdc->vdc_groupwidth) * vdc->vdc_ndata);
 }
 
 /*
  * Convert a logical offset to the corresponding group number.
  */
 static uint64_t
 vdev_draid_offset_to_group(vdev_t *vd, uint64_t offset)
 {
 	vdev_draid_config_t *vdc = vd->vdev_tsd;
 
 	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);
 
 	return (offset / vdc->vdc_groupsz);
 }
 
 /*
  * Convert a group number to the logical starting offset for that group.
  */
 static uint64_t
 vdev_draid_group_to_offset(vdev_t *vd, uint64_t group)
 {
 	vdev_draid_config_t *vdc = vd->vdev_tsd;
 
 	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);
 
 	return (group * vdc->vdc_groupsz);
 }
 
 /*
  * Full stripe writes.  When writing, all columns (D+P) are required.  Parity
  * is calculated over all the columns, including empty zero filled sectors,
  * and each is written to disk.  While only the data columns are needed for
  * a normal read, all of the columns are required for reconstruction when
  * performing a sequential resilver.
  *
  * For "big columns" it's sufficient to map the correct range of the zio ABD.
  * Partial columns require allocating a gang ABD in order to zero fill the
  * empty sectors.  When the column is empty a zero filled sector must be
  * mapped.  In all cases the data ABDs must be the same size as the parity
  * ABDs (e.g. rc->rc_size == parity_size).
  */
 static void
 vdev_draid_map_alloc_write(zio_t *zio, uint64_t abd_offset, raidz_row_t *rr)
 {
 	uint64_t skip_size = 1ULL << zio->io_vd->vdev_top->vdev_ashift;
 	uint64_t parity_size = rr->rr_col[0].rc_size;
 	uint64_t abd_off = abd_offset;
 
 	ASSERT3U(zio->io_type, ==, ZIO_TYPE_WRITE);
 	ASSERT3U(parity_size, ==, abd_get_size(rr->rr_col[0].rc_abd));
 
 	for (uint64_t c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 
 		if (rc->rc_size == 0) {
 			/* empty data column (small write), add a skip sector */
 			ASSERT3U(skip_size, ==, parity_size);
 			rc->rc_abd = abd_get_zeros(skip_size);
 		} else if (rc->rc_size == parity_size) {
 			/* this is a "big column" */
 			rc->rc_abd = abd_get_offset_struct(&rc->rc_abdstruct,
 			    zio->io_abd, abd_off, rc->rc_size);
 		} else {
 			/* short data column, add a skip sector */
 			ASSERT3U(rc->rc_size + skip_size, ==, parity_size);
 			rc->rc_abd = abd_alloc_gang();
 			abd_gang_add(rc->rc_abd, abd_get_offset_size(
 			    zio->io_abd, abd_off, rc->rc_size), B_TRUE);
 			abd_gang_add(rc->rc_abd, abd_get_zeros(skip_size),
 			    B_TRUE);
 		}
 
 		ASSERT3U(abd_get_size(rc->rc_abd), ==, parity_size);
 
 		abd_off += rc->rc_size;
 		rc->rc_size = parity_size;
 	}
 
 	IMPLY(abd_offset != 0, abd_off == zio->io_size);
 }
 
 /*
  * Scrub/resilver reads.  In order to store the contents of the skip sectors
  * an additional ABD is allocated.  The columns are handled in the same way
  * as a full stripe write except instead of using the zero ABD the newly
  * allocated skip ABD is used to back the skip sectors.  In all cases the
  * data ABD must be the same size as the parity ABDs.
  */
 static void
 vdev_draid_map_alloc_scrub(zio_t *zio, uint64_t abd_offset, raidz_row_t *rr)
 {
 	uint64_t skip_size = 1ULL << zio->io_vd->vdev_top->vdev_ashift;
 	uint64_t parity_size = rr->rr_col[0].rc_size;
 	uint64_t abd_off = abd_offset;
 	uint64_t skip_off = 0;
 
 	ASSERT3U(zio->io_type, ==, ZIO_TYPE_READ);
 	ASSERT3P(rr->rr_abd_empty, ==, NULL);
 
 	if (rr->rr_nempty > 0) {
 		rr->rr_abd_empty = abd_alloc_linear(rr->rr_nempty * skip_size,
 		    B_FALSE);
 	}
 
 	for (uint64_t c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 
 		if (rc->rc_size == 0) {
 			/* empty data column (small read), add a skip sector */
 			ASSERT3U(skip_size, ==, parity_size);
 			ASSERT3U(rr->rr_nempty, !=, 0);
 			rc->rc_abd = abd_get_offset_size(rr->rr_abd_empty,
 			    skip_off, skip_size);
 			skip_off += skip_size;
 		} else if (rc->rc_size == parity_size) {
 			/* this is a "big column" */
 			rc->rc_abd = abd_get_offset_struct(&rc->rc_abdstruct,
 			    zio->io_abd, abd_off, rc->rc_size);
 		} else {
 			/* short data column, add a skip sector */
 			ASSERT3U(rc->rc_size + skip_size, ==, parity_size);
 			ASSERT3U(rr->rr_nempty, !=, 0);
 			rc->rc_abd = abd_alloc_gang();
 			abd_gang_add(rc->rc_abd, abd_get_offset_size(
 			    zio->io_abd, abd_off, rc->rc_size), B_TRUE);
 			abd_gang_add(rc->rc_abd, abd_get_offset_size(
 			    rr->rr_abd_empty, skip_off, skip_size), B_TRUE);
 			skip_off += skip_size;
 		}
 
 		uint64_t abd_size = abd_get_size(rc->rc_abd);
 		ASSERT3U(abd_size, ==, abd_get_size(rr->rr_col[0].rc_abd));
 
 		/*
 		 * Increase rc_size so the skip ABD is included in subsequent
 		 * parity calculations.
 		 */
 		abd_off += rc->rc_size;
 		rc->rc_size = abd_size;
 	}
 
 	IMPLY(abd_offset != 0, abd_off == zio->io_size);
 	ASSERT3U(skip_off, ==, rr->rr_nempty * skip_size);
 }
 
 /*
  * Normal reads.  In this common case only the columns containing data
  * are read in to the zio ABDs.  Neither the parity columns or empty skip
  * sectors are read unless the checksum fails verification.  In which case
  * vdev_raidz_read_all() will call vdev_draid_map_alloc_empty() to expand
  * the raid map in order to allow reconstruction using the parity data and
  * skip sectors.
  */
 static void
 vdev_draid_map_alloc_read(zio_t *zio, uint64_t abd_offset, raidz_row_t *rr)
 {
 	uint64_t abd_off = abd_offset;
 
 	ASSERT3U(zio->io_type, ==, ZIO_TYPE_READ);
 
 	for (uint64_t c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 
 		if (rc->rc_size > 0) {
 			rc->rc_abd = abd_get_offset_struct(&rc->rc_abdstruct,
 			    zio->io_abd, abd_off, rc->rc_size);
 			abd_off += rc->rc_size;
 		}
 	}
 
 	IMPLY(abd_offset != 0, abd_off == zio->io_size);
 }
 
 /*
  * Converts a normal "read" raidz_row_t to a "scrub" raidz_row_t. The key
  * difference is that an ABD is allocated to back skip sectors so they may
  * be read in to memory, verified, and repaired if needed.
  */
 void
 vdev_draid_map_alloc_empty(zio_t *zio, raidz_row_t *rr)
 {
 	uint64_t skip_size = 1ULL << zio->io_vd->vdev_top->vdev_ashift;
 	uint64_t parity_size = rr->rr_col[0].rc_size;
 	uint64_t skip_off = 0;
 
 	ASSERT3U(zio->io_type, ==, ZIO_TYPE_READ);
 	ASSERT3P(rr->rr_abd_empty, ==, NULL);
 
 	if (rr->rr_nempty > 0) {
 		rr->rr_abd_empty = abd_alloc_linear(rr->rr_nempty * skip_size,
 		    B_FALSE);
 	}
 
 	for (uint64_t c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 
 		if (rc->rc_size == 0) {
 			/* empty data column (small read), add a skip sector */
 			ASSERT3U(skip_size, ==, parity_size);
 			ASSERT3U(rr->rr_nempty, !=, 0);
 			ASSERT3P(rc->rc_abd, ==, NULL);
 			rc->rc_abd = abd_get_offset_size(rr->rr_abd_empty,
 			    skip_off, skip_size);
 			skip_off += skip_size;
 		} else if (rc->rc_size == parity_size) {
 			/* this is a "big column", nothing to add */
 			ASSERT3P(rc->rc_abd, !=, NULL);
 		} else {
 			/*
 			 * short data column, add a skip sector and clear
 			 * rc_tried to force the entire column to be re-read
 			 * thereby including the missing skip sector data
 			 * which is needed for reconstruction.
 			 */
 			ASSERT3U(rc->rc_size + skip_size, ==, parity_size);
 			ASSERT3U(rr->rr_nempty, !=, 0);
 			ASSERT3P(rc->rc_abd, !=, NULL);
 			ASSERT(!abd_is_gang(rc->rc_abd));
 			abd_t *read_abd = rc->rc_abd;
 			rc->rc_abd = abd_alloc_gang();
 			abd_gang_add(rc->rc_abd, read_abd, B_TRUE);
 			abd_gang_add(rc->rc_abd, abd_get_offset_size(
 			    rr->rr_abd_empty, skip_off, skip_size), B_TRUE);
 			skip_off += skip_size;
 			rc->rc_tried = 0;
 		}
 
 		/*
 		 * Increase rc_size so the empty ABD is included in subsequent
 		 * parity calculations.
 		 */
 		rc->rc_size = parity_size;
 	}
 
 	ASSERT3U(skip_off, ==, rr->rr_nempty * skip_size);
 }
 
 /*
  * Verify that all empty sectors are zero filled before using them to
  * calculate parity.  Otherwise, silent corruption in an empty sector will
  * result in bad parity being generated.  That bad parity will then be
  * considered authoritative and overwrite the good parity on disk.  This
  * is possible because the checksum is only calculated over the data,
  * thus it cannot be used to detect damage in empty sectors.
  */
 int
 vdev_draid_map_verify_empty(zio_t *zio, raidz_row_t *rr)
 {
 	uint64_t skip_size = 1ULL << zio->io_vd->vdev_top->vdev_ashift;
 	uint64_t parity_size = rr->rr_col[0].rc_size;
 	uint64_t skip_off = parity_size - skip_size;
 	uint64_t empty_off = 0;
 	int ret = 0;
 
 	ASSERT3U(zio->io_type, ==, ZIO_TYPE_READ);
 	ASSERT3P(rr->rr_abd_empty, !=, NULL);
 	ASSERT3U(rr->rr_bigcols, >, 0);
 
 	void *zero_buf = kmem_zalloc(skip_size, KM_SLEEP);
 
 	for (int c = rr->rr_bigcols; c < rr->rr_cols; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 
 		ASSERT3P(rc->rc_abd, !=, NULL);
 		ASSERT3U(rc->rc_size, ==, parity_size);
 
 		if (abd_cmp_buf_off(rc->rc_abd, zero_buf, skip_off,
 		    skip_size) != 0) {
 			vdev_raidz_checksum_error(zio, rc, rc->rc_abd);
 			abd_zero_off(rc->rc_abd, skip_off, skip_size);
 			rc->rc_error = SET_ERROR(ECKSUM);
 			ret++;
 		}
 
 		empty_off += skip_size;
 	}
 
 	ASSERT3U(empty_off, ==, abd_get_size(rr->rr_abd_empty));
 
 	kmem_free(zero_buf, skip_size);
 
 	return (ret);
 }
 
 /*
  * Given a logical address within a dRAID configuration, return the physical
  * address on the first drive in the group that this address maps to
  * (at position 'start' in permutation number 'perm').
  */
 static uint64_t
 vdev_draid_logical_to_physical(vdev_t *vd, uint64_t logical_offset,
     uint64_t *perm, uint64_t *start)
 {
 	vdev_draid_config_t *vdc = vd->vdev_tsd;
 
 	/* b is the dRAID (parent) sector offset. */
 	uint64_t ashift = vd->vdev_top->vdev_ashift;
 	uint64_t b_offset = logical_offset >> ashift;
 
 	/*
 	 * The height of a row in units of the vdev's minimum sector size.
 	 * This is the amount of data written to each disk of each group
 	 * in a given permutation.
 	 */
 	uint64_t rowheight_sectors = VDEV_DRAID_ROWHEIGHT >> ashift;
 
 	/*
 	 * We cycle through a disk permutation every groupsz * ngroups chunk
 	 * of address space. Note that ngroups * groupsz must be a multiple
 	 * of the number of data drives (ndisks) in order to guarantee
 	 * alignment. So, for example, if our row height is 16MB, our group
 	 * size is 10, and there are 13 data drives in the draid, then ngroups
 	 * will be 13, we will change permutation every 2.08GB and each
 	 * disk will have 160MB of data per chunk.
 	 */
 	uint64_t groupwidth = vdc->vdc_groupwidth;
 	uint64_t ngroups = vdc->vdc_ngroups;
 	uint64_t ndisks = vdc->vdc_ndisks;
 
 	/*
 	 * groupstart is where the group this IO will land in "starts" in
 	 * the permutation array.
 	 */
 	uint64_t group = logical_offset / vdc->vdc_groupsz;
 	uint64_t groupstart = (group * groupwidth) % ndisks;
 	ASSERT3U(groupstart + groupwidth, <=, ndisks + groupstart);
 	*start = groupstart;
 
 	/* b_offset is the sector offset within a group chunk */
 	b_offset = b_offset % (rowheight_sectors * groupwidth);
 	ASSERT0(b_offset % groupwidth);
 
 	/*
 	 * Find the starting byte offset on each child vdev:
 	 * - within a permutation there are ngroups groups spread over the
 	 *   rows, where each row covers a slice portion of the disk
 	 * - each permutation has (groupwidth * ngroups) / ndisks rows
 	 * - so each permutation covers rows * slice portion of the disk
 	 * - so we need to find the row where this IO group target begins
 	 */
 	*perm = group / ngroups;
 	uint64_t row = (*perm * ((groupwidth * ngroups) / ndisks)) +
 	    (((group % ngroups) * groupwidth) / ndisks);
 
 	return (((rowheight_sectors * row) +
 	    (b_offset / groupwidth)) << ashift);
 }
 
 static uint64_t
 vdev_draid_map_alloc_row(zio_t *zio, raidz_row_t **rrp, uint64_t io_offset,
     uint64_t abd_offset, uint64_t abd_size)
 {
 	vdev_t *vd = zio->io_vd;
 	vdev_draid_config_t *vdc = vd->vdev_tsd;
 	uint64_t ashift = vd->vdev_top->vdev_ashift;
 	uint64_t io_size = abd_size;
 	uint64_t io_asize = vdev_draid_asize(vd, io_size, 0);
 	uint64_t group = vdev_draid_offset_to_group(vd, io_offset);
 	uint64_t start_offset = vdev_draid_group_to_offset(vd, group + 1);
 
 	/*
 	 * Limit the io_size to the space remaining in the group.  A second
 	 * row in the raidz_map_t is created for the remainder.
 	 */
 	if (io_offset + io_asize > start_offset) {
 		io_size = vdev_draid_asize_to_psize(vd,
 		    start_offset - io_offset);
 	}
 
 	/*
 	 * At most a block may span the logical end of one group and the start
 	 * of the next group. Therefore, at the end of a group the io_size must
 	 * span the group width evenly and the remainder must be aligned to the
 	 * start of the next group.
 	 */
 	IMPLY(abd_offset == 0 && io_size < zio->io_size,
 	    (io_asize >> ashift) % vdc->vdc_groupwidth == 0);
 	IMPLY(abd_offset != 0,
 	    vdev_draid_group_to_offset(vd, group) == io_offset);
 
 	/* Lookup starting byte offset on each child vdev */
 	uint64_t groupstart, perm;
 	uint64_t physical_offset = vdev_draid_logical_to_physical(vd,
 	    io_offset, &perm, &groupstart);
 
 	/*
 	 * If there is less than groupwidth drives available after the group
 	 * start, the group is going to wrap onto the next row. 'wrap' is the
 	 * group disk number that starts on the next row.
 	 */
 	uint64_t ndisks = vdc->vdc_ndisks;
 	uint64_t groupwidth = vdc->vdc_groupwidth;
 	uint64_t wrap = groupwidth;
 
 	if (groupstart + groupwidth > ndisks)
 		wrap = ndisks - groupstart;
 
 	/* The io size in units of the vdev's minimum sector size. */
 	const uint64_t psize = io_size >> ashift;
 
 	/*
 	 * "Quotient": The number of data sectors for this stripe on all but
 	 * the "big column" child vdevs that also contain "remainder" data.
 	 */
 	uint64_t q = psize / vdc->vdc_ndata;
 
 	/*
 	 * "Remainder": The number of partial stripe data sectors in this I/O.
 	 * This will add a sector to some, but not all, child vdevs.
 	 */
 	uint64_t r = psize - q * vdc->vdc_ndata;
 
 	/* The number of "big columns" - those which contain remainder data. */
 	uint64_t bc = (r == 0 ? 0 : r + vdc->vdc_nparity);
 	ASSERT3U(bc, <, groupwidth);
 
 	/* The total number of data and parity sectors for this I/O. */
 	uint64_t tot = psize + (vdc->vdc_nparity * (q + (r == 0 ? 0 : 1)));
 
 	ASSERT3U(vdc->vdc_nparity, >, 0);
 
-	raidz_row_t *rr = vdev_raidz_row_alloc(groupwidth);
+	raidz_row_t *rr = vdev_raidz_row_alloc(groupwidth, zio);
 	rr->rr_bigcols = bc;
 	rr->rr_firstdatacol = vdc->vdc_nparity;
 #ifdef ZFS_DEBUG
 	rr->rr_offset = io_offset;
 	rr->rr_size = io_size;
 #endif
 	*rrp = rr;
 
 	uint8_t *base;
 	uint64_t iter, asize = 0;
 	vdev_draid_get_perm(vdc, perm, &base, &iter);
 	for (uint64_t i = 0; i < groupwidth; i++) {
 		raidz_col_t *rc = &rr->rr_col[i];
 		uint64_t c = (groupstart + i) % ndisks;
 
 		/* increment the offset if we wrap to the next row */
 		if (i == wrap)
 			physical_offset += VDEV_DRAID_ROWHEIGHT;
 
 		rc->rc_devidx = vdev_draid_permute_id(vdc, base, iter, c);
 		rc->rc_offset = physical_offset;
 
 		if (q == 0 && i >= bc)
 			rc->rc_size = 0;
 		else if (i < bc)
 			rc->rc_size = (q + 1) << ashift;
 		else
 			rc->rc_size = q << ashift;
 
 		asize += rc->rc_size;
 	}
 
 	ASSERT3U(asize, ==, tot << ashift);
 	rr->rr_nempty = roundup(tot, groupwidth) - tot;
 	IMPLY(bc > 0, rr->rr_nempty == groupwidth - bc);
 
 	/* Allocate buffers for the parity columns */
 	for (uint64_t c = 0; c < rr->rr_firstdatacol; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 		rc->rc_abd = abd_alloc_linear(rc->rc_size, B_FALSE);
 	}
 
 	/*
 	 * Map buffers for data columns and allocate/map buffers for skip
 	 * sectors.  There are three distinct cases for dRAID which are
 	 * required to support sequential rebuild.
 	 */
 	if (zio->io_type == ZIO_TYPE_WRITE) {
 		vdev_draid_map_alloc_write(zio, abd_offset, rr);
 	} else if ((rr->rr_nempty > 0) &&
 	    (zio->io_flags & (ZIO_FLAG_SCRUB | ZIO_FLAG_RESILVER))) {
 		vdev_draid_map_alloc_scrub(zio, abd_offset, rr);
 	} else {
 		ASSERT3U(zio->io_type, ==, ZIO_TYPE_READ);
 		vdev_draid_map_alloc_read(zio, abd_offset, rr);
 	}
 
 	return (io_size);
 }
 
 /*
  * Allocate the raidz mapping to be applied to the dRAID I/O.  The parity
  * calculations for dRAID are identical to raidz however there are a few
  * differences in the layout.
  *
  * - dRAID always allocates a full stripe width. Any extra sectors due
  *   this padding are zero filled and written to disk. They will be read
  *   back during a scrub or repair operation since they are included in
  *   the parity calculation. This property enables sequential resilvering.
  *
  * - When the block at the logical offset spans redundancy groups then two
  *   rows are allocated in the raidz_map_t. One row resides at the end of
  *   the first group and the other at the start of the following group.
  */
 static raidz_map_t *
 vdev_draid_map_alloc(zio_t *zio)
 {
 	raidz_row_t *rr[2];
 	uint64_t abd_offset = 0;
 	uint64_t abd_size = zio->io_size;
 	uint64_t io_offset = zio->io_offset;
 	uint64_t size;
 	int nrows = 1;
 
 	size = vdev_draid_map_alloc_row(zio, &rr[0], io_offset,
 	    abd_offset, abd_size);
 	if (size < abd_size) {
 		vdev_t *vd = zio->io_vd;
 
 		io_offset += vdev_draid_asize(vd, size, 0);
 		abd_offset += size;
 		abd_size -= size;
 		nrows++;
 
 		ASSERT3U(io_offset, ==, vdev_draid_group_to_offset(
 		    vd, vdev_draid_offset_to_group(vd, io_offset)));
 		ASSERT3U(abd_offset, <, zio->io_size);
 		ASSERT3U(abd_size, !=, 0);
 
 		size = vdev_draid_map_alloc_row(zio, &rr[1],
 		    io_offset, abd_offset, abd_size);
 		VERIFY3U(size, ==, abd_size);
 	}
 
 	raidz_map_t *rm;
 	rm = kmem_zalloc(offsetof(raidz_map_t, rm_row[nrows]), KM_SLEEP);
 	rm->rm_ops = vdev_raidz_math_get_ops();
 	rm->rm_nrows = nrows;
 	rm->rm_row[0] = rr[0];
 	if (nrows == 2)
 		rm->rm_row[1] = rr[1];
 	return (rm);
 }
 
 /*
  * Given an offset into a dRAID return the next group width aligned offset
  * which can be used to start an allocation.
  */
 static uint64_t
 vdev_draid_get_astart(vdev_t *vd, const uint64_t start)
 {
 	vdev_draid_config_t *vdc = vd->vdev_tsd;
 
 	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);
 
 	return (roundup(start, vdc->vdc_groupwidth << vd->vdev_ashift));
 }
 
 /*
  * Allocatable space for dRAID is (children - nspares) * sizeof(smallest child)
  * rounded down to the last full slice.  So each child must provide at least
  * 1 / (children - nspares) of its asize.
  */
 static uint64_t
 vdev_draid_min_asize(vdev_t *vd)
 {
 	vdev_draid_config_t *vdc = vd->vdev_tsd;
 
 	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);
 
 	return (VDEV_DRAID_REFLOW_RESERVE +
 	    (vd->vdev_min_asize + vdc->vdc_ndisks - 1) / (vdc->vdc_ndisks));
 }
 
 /*
  * When using dRAID the minimum allocation size is determined by the number
  * of data disks in the redundancy group.  Full stripes are always used.
  */
 static uint64_t
 vdev_draid_min_alloc(vdev_t *vd)
 {
 	vdev_draid_config_t *vdc = vd->vdev_tsd;
 
 	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);
 
 	return (vdc->vdc_ndata << vd->vdev_ashift);
 }
 
 /*
  * Returns true if the txg range does not exist on any leaf vdev.
  *
  * A dRAID spare does not fit into the DTL model. While it has child vdevs
  * there is no redundancy among them, and the effective child vdev is
  * determined by offset. Essentially we do a vdev_dtl_reassess() on the
  * fly by replacing a dRAID spare with the child vdev under the offset.
  * Note that it is a recursive process because the child vdev can be
  * another dRAID spare and so on.
  */
 boolean_t
 vdev_draid_missing(vdev_t *vd, uint64_t physical_offset, uint64_t txg,
     uint64_t size)
 {
 	if (vd->vdev_ops == &vdev_spare_ops ||
 	    vd->vdev_ops == &vdev_replacing_ops) {
 		/*
 		 * Check all of the readable children, if any child
 		 * contains the txg range the data it is not missing.
 		 */
 		for (int c = 0; c < vd->vdev_children; c++) {
 			vdev_t *cvd = vd->vdev_child[c];
 
 			if (!vdev_readable(cvd))
 				continue;
 
 			if (!vdev_draid_missing(cvd, physical_offset,
 			    txg, size))
 				return (B_FALSE);
 		}
 
 		return (B_TRUE);
 	}
 
 	if (vd->vdev_ops == &vdev_draid_spare_ops) {
 		/*
 		 * When sequentially resilvering we don't have a proper
 		 * txg range so instead we must presume all txgs are
 		 * missing on this vdev until the resilver completes.
 		 */
 		if (vd->vdev_rebuild_txg != 0)
 			return (B_TRUE);
 
 		/*
 		 * DTL_MISSING is set for all prior txgs when a resilver
 		 * is started in spa_vdev_attach().
 		 */
 		if (vdev_dtl_contains(vd, DTL_MISSING, txg, size))
 			return (B_TRUE);
 
 		/*
 		 * Consult the DTL on the relevant vdev. Either a vdev
 		 * leaf or spare/replace mirror child may be returned so
 		 * we must recursively call vdev_draid_missing_impl().
 		 */
 		vd = vdev_draid_spare_get_child(vd, physical_offset);
 		if (vd == NULL)
 			return (B_TRUE);
 
 		return (vdev_draid_missing(vd, physical_offset,
 		    txg, size));
 	}
 
 	return (vdev_dtl_contains(vd, DTL_MISSING, txg, size));
 }
 
 /*
  * Returns true if the txg is only partially replicated on the leaf vdevs.
  */
 static boolean_t
 vdev_draid_partial(vdev_t *vd, uint64_t physical_offset, uint64_t txg,
     uint64_t size)
 {
 	if (vd->vdev_ops == &vdev_spare_ops ||
 	    vd->vdev_ops == &vdev_replacing_ops) {
 		/*
 		 * Check all of the readable children, if any child is
 		 * missing the txg range then it is partially replicated.
 		 */
 		for (int c = 0; c < vd->vdev_children; c++) {
 			vdev_t *cvd = vd->vdev_child[c];
 
 			if (!vdev_readable(cvd))
 				continue;
 
 			if (vdev_draid_partial(cvd, physical_offset, txg, size))
 				return (B_TRUE);
 		}
 
 		return (B_FALSE);
 	}
 
 	if (vd->vdev_ops == &vdev_draid_spare_ops) {
 		/*
 		 * When sequentially resilvering we don't have a proper
 		 * txg range so instead we must presume all txgs are
 		 * missing on this vdev until the resilver completes.
 		 */
 		if (vd->vdev_rebuild_txg != 0)
 			return (B_TRUE);
 
 		/*
 		 * DTL_MISSING is set for all prior txgs when a resilver
 		 * is started in spa_vdev_attach().
 		 */
 		if (vdev_dtl_contains(vd, DTL_MISSING, txg, size))
 			return (B_TRUE);
 
 		/*
 		 * Consult the DTL on the relevant vdev. Either a vdev
 		 * leaf or spare/replace mirror child may be returned so
 		 * we must recursively call vdev_draid_missing_impl().
 		 */
 		vd = vdev_draid_spare_get_child(vd, physical_offset);
 		if (vd == NULL)
 			return (B_TRUE);
 
 		return (vdev_draid_partial(vd, physical_offset, txg, size));
 	}
 
 	return (vdev_dtl_contains(vd, DTL_MISSING, txg, size));
 }
 
 /*
  * Determine if the vdev is readable at the given offset.
  */
 boolean_t
 vdev_draid_readable(vdev_t *vd, uint64_t physical_offset)
 {
 	if (vd->vdev_ops == &vdev_draid_spare_ops) {
 		vd = vdev_draid_spare_get_child(vd, physical_offset);
 		if (vd == NULL)
 			return (B_FALSE);
 	}
 
 	if (vd->vdev_ops == &vdev_spare_ops ||
 	    vd->vdev_ops == &vdev_replacing_ops) {
 
 		for (int c = 0; c < vd->vdev_children; c++) {
 			vdev_t *cvd = vd->vdev_child[c];
 
 			if (!vdev_readable(cvd))
 				continue;
 
 			if (vdev_draid_readable(cvd, physical_offset))
 				return (B_TRUE);
 		}
 
 		return (B_FALSE);
 	}
 
 	return (vdev_readable(vd));
 }
 
 /*
  * Returns the first distributed spare found under the provided vdev tree.
  */
 static vdev_t *
 vdev_draid_find_spare(vdev_t *vd)
 {
 	if (vd->vdev_ops == &vdev_draid_spare_ops)
 		return (vd);
 
 	for (int c = 0; c < vd->vdev_children; c++) {
 		vdev_t *svd = vdev_draid_find_spare(vd->vdev_child[c]);
 		if (svd != NULL)
 			return (svd);
 	}
 
 	return (NULL);
 }
 
 /*
  * Returns B_TRUE if the passed in vdev is currently "faulted".
  * Faulted, in this context, means that the vdev represents a
  * replacing or sparing vdev tree.
  */
 static boolean_t
 vdev_draid_faulted(vdev_t *vd, uint64_t physical_offset)
 {
 	if (vd->vdev_ops == &vdev_draid_spare_ops) {
 		vd = vdev_draid_spare_get_child(vd, physical_offset);
 		if (vd == NULL)
 			return (B_FALSE);
 
 		/*
 		 * After resolving the distributed spare to a leaf vdev
 		 * check the parent to determine if it's "faulted".
 		 */
 		vd = vd->vdev_parent;
 	}
 
 	return (vd->vdev_ops == &vdev_replacing_ops ||
 	    vd->vdev_ops == &vdev_spare_ops);
 }
 
 /*
  * Determine if the dRAID block at the logical offset is degraded.
  * Used by sequential resilver.
  */
 static boolean_t
 vdev_draid_group_degraded(vdev_t *vd, uint64_t offset)
 {
 	vdev_draid_config_t *vdc = vd->vdev_tsd;
 
 	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);
 	ASSERT3U(vdev_draid_get_astart(vd, offset), ==, offset);
 
 	uint64_t groupstart, perm;
 	uint64_t physical_offset = vdev_draid_logical_to_physical(vd,
 	    offset, &perm, &groupstart);
 
 	uint8_t *base;
 	uint64_t iter;
 	vdev_draid_get_perm(vdc, perm, &base, &iter);
 
 	for (uint64_t i = 0; i < vdc->vdc_groupwidth; i++) {
 		uint64_t c = (groupstart + i) % vdc->vdc_ndisks;
 		uint64_t cid = vdev_draid_permute_id(vdc, base, iter, c);
 		vdev_t *cvd = vd->vdev_child[cid];
 
 		/* Group contains a faulted vdev. */
 		if (vdev_draid_faulted(cvd, physical_offset))
 			return (B_TRUE);
 
 		/*
 		 * Always check groups with active distributed spares
 		 * because any vdev failure in the pool will affect them.
 		 */
 		if (vdev_draid_find_spare(cvd) != NULL)
 			return (B_TRUE);
 	}
 
 	return (B_FALSE);
 }
 
 /*
  * Determine if the txg is missing.  Used by healing resilver.
  */
 static boolean_t
 vdev_draid_group_missing(vdev_t *vd, uint64_t offset, uint64_t txg,
     uint64_t size)
 {
 	vdev_draid_config_t *vdc = vd->vdev_tsd;
 
 	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);
 	ASSERT3U(vdev_draid_get_astart(vd, offset), ==, offset);
 
 	uint64_t groupstart, perm;
 	uint64_t physical_offset = vdev_draid_logical_to_physical(vd,
 	    offset, &perm, &groupstart);
 
 	uint8_t *base;
 	uint64_t iter;
 	vdev_draid_get_perm(vdc, perm, &base, &iter);
 
 	for (uint64_t i = 0; i < vdc->vdc_groupwidth; i++) {
 		uint64_t c = (groupstart + i) % vdc->vdc_ndisks;
 		uint64_t cid = vdev_draid_permute_id(vdc, base, iter, c);
 		vdev_t *cvd = vd->vdev_child[cid];
 
 		/* Transaction group is known to be partially replicated. */
 		if (vdev_draid_partial(cvd, physical_offset, txg, size))
 			return (B_TRUE);
 
 		/*
 		 * Always check groups with active distributed spares
 		 * because any vdev failure in the pool will affect them.
 		 */
 		if (vdev_draid_find_spare(cvd) != NULL)
 			return (B_TRUE);
 	}
 
 	return (B_FALSE);
 }
 
 /*
  * Find the smallest child asize and largest sector size to calculate the
  * available capacity.  Distributed spares are ignored since their capacity
  * is also based of the minimum child size in the top-level dRAID.
  */
 static void
 vdev_draid_calculate_asize(vdev_t *vd, uint64_t *asizep, uint64_t *max_asizep,
     uint64_t *logical_ashiftp, uint64_t *physical_ashiftp)
 {
 	uint64_t logical_ashift = 0, physical_ashift = 0;
 	uint64_t asize = 0, max_asize = 0;
 
 	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);
 
 	for (int c = 0; c < vd->vdev_children; c++) {
 		vdev_t *cvd = vd->vdev_child[c];
 
 		if (cvd->vdev_ops == &vdev_draid_spare_ops)
 			continue;
 
 		asize = MIN(asize - 1, cvd->vdev_asize - 1) + 1;
 		max_asize = MIN(max_asize - 1, cvd->vdev_max_asize - 1) + 1;
 		logical_ashift = MAX(logical_ashift, cvd->vdev_ashift);
 	}
 	for (int c = 0; c < vd->vdev_children; c++) {
 		vdev_t *cvd = vd->vdev_child[c];
 
 		if (cvd->vdev_ops == &vdev_draid_spare_ops)
 			continue;
 		physical_ashift = vdev_best_ashift(logical_ashift,
 		    physical_ashift, cvd->vdev_physical_ashift);
 	}
 
 	*asizep = asize;
 	*max_asizep = max_asize;
 	*logical_ashiftp = logical_ashift;
 	*physical_ashiftp = physical_ashift;
 }
 
 /*
  * Open spare vdevs.
  */
 static boolean_t
 vdev_draid_open_spares(vdev_t *vd)
 {
 	return (vd->vdev_ops == &vdev_draid_spare_ops ||
 	    vd->vdev_ops == &vdev_replacing_ops ||
 	    vd->vdev_ops == &vdev_spare_ops);
 }
 
 /*
  * Open all children, excluding spares.
  */
 static boolean_t
 vdev_draid_open_children(vdev_t *vd)
 {
 	return (!vdev_draid_open_spares(vd));
 }
 
 /*
  * Open a top-level dRAID vdev.
  */
 static int
 vdev_draid_open(vdev_t *vd, uint64_t *asize, uint64_t *max_asize,
     uint64_t *logical_ashift, uint64_t *physical_ashift)
 {
 	vdev_draid_config_t *vdc =  vd->vdev_tsd;
 	uint64_t nparity = vdc->vdc_nparity;
 	int open_errors = 0;
 
 	if (nparity > VDEV_DRAID_MAXPARITY ||
 	    vd->vdev_children < nparity + 1) {
 		vd->vdev_stat.vs_aux = VDEV_AUX_BAD_LABEL;
 		return (SET_ERROR(EINVAL));
 	}
 
 	/*
 	 * First open the normal children then the distributed spares.  This
 	 * ordering is important to ensure the distributed spares calculate
 	 * the correct psize in the event that the dRAID vdevs were expanded.
 	 */
 	vdev_open_children_subset(vd, vdev_draid_open_children);
 	vdev_open_children_subset(vd, vdev_draid_open_spares);
 
 	/* Verify enough of the children are available to continue. */
 	for (int c = 0; c < vd->vdev_children; c++) {
 		if (vd->vdev_child[c]->vdev_open_error != 0) {
 			if ((++open_errors) > nparity) {
 				vd->vdev_stat.vs_aux = VDEV_AUX_NO_REPLICAS;
 				return (SET_ERROR(ENXIO));
 			}
 		}
 	}
 
 	/*
 	 * Allocatable capacity is the sum of the space on all children less
 	 * the number of distributed spares rounded down to last full row
 	 * and then to the last full group. An additional 32MB of scratch
 	 * space is reserved at the end of each child for use by the dRAID
 	 * expansion feature.
 	 */
 	uint64_t child_asize, child_max_asize;
 	vdev_draid_calculate_asize(vd, &child_asize, &child_max_asize,
 	    logical_ashift, physical_ashift);
 
 	/*
 	 * Should be unreachable since the minimum child size is 64MB, but
 	 * we want to make sure an underflow absolutely cannot occur here.
 	 */
 	if (child_asize < VDEV_DRAID_REFLOW_RESERVE ||
 	    child_max_asize < VDEV_DRAID_REFLOW_RESERVE) {
 		return (SET_ERROR(ENXIO));
 	}
 
 	child_asize = ((child_asize - VDEV_DRAID_REFLOW_RESERVE) /
 	    VDEV_DRAID_ROWHEIGHT) * VDEV_DRAID_ROWHEIGHT;
 	child_max_asize = ((child_max_asize - VDEV_DRAID_REFLOW_RESERVE) /
 	    VDEV_DRAID_ROWHEIGHT) * VDEV_DRAID_ROWHEIGHT;
 
 	*asize = (((child_asize * vdc->vdc_ndisks) / vdc->vdc_groupsz) *
 	    vdc->vdc_groupsz);
 	*max_asize = (((child_max_asize * vdc->vdc_ndisks) / vdc->vdc_groupsz) *
 	    vdc->vdc_groupsz);
 
 	return (0);
 }
 
 /*
  * Close a top-level dRAID vdev.
  */
 static void
 vdev_draid_close(vdev_t *vd)
 {
 	for (int c = 0; c < vd->vdev_children; c++) {
 		if (vd->vdev_child[c] != NULL)
 			vdev_close(vd->vdev_child[c]);
 	}
 }
 
 /*
  * Return the maximum asize for a rebuild zio in the provided range
  * given the following constraints.  A dRAID chunks may not:
  *
  * - Exceed the maximum allowed block size (SPA_MAXBLOCKSIZE), or
  * - Span dRAID redundancy groups.
  */
 static uint64_t
 vdev_draid_rebuild_asize(vdev_t *vd, uint64_t start, uint64_t asize,
     uint64_t max_segment)
 {
 	vdev_draid_config_t *vdc = vd->vdev_tsd;
 
 	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);
 
 	uint64_t ashift = vd->vdev_ashift;
 	uint64_t ndata = vdc->vdc_ndata;
 	uint64_t psize = MIN(P2ROUNDUP(max_segment * ndata, 1 << ashift),
 	    SPA_MAXBLOCKSIZE);
 
 	ASSERT3U(vdev_draid_get_astart(vd, start), ==, start);
 	ASSERT3U(asize % (vdc->vdc_groupwidth << ashift), ==, 0);
 
 	/* Chunks must evenly span all data columns in the group. */
 	psize = (((psize >> ashift) / ndata) * ndata) << ashift;
 	uint64_t chunk_size = MIN(asize, vdev_psize_to_asize(vd, psize));
 
 	/* Reduce the chunk size to the group space remaining. */
 	uint64_t group = vdev_draid_offset_to_group(vd, start);
 	uint64_t left = vdev_draid_group_to_offset(vd, group + 1) - start;
 	chunk_size = MIN(chunk_size, left);
 
 	ASSERT3U(chunk_size % (vdc->vdc_groupwidth << ashift), ==, 0);
 	ASSERT3U(vdev_draid_offset_to_group(vd, start), ==,
 	    vdev_draid_offset_to_group(vd, start + chunk_size - 1));
 
 	return (chunk_size);
 }
 
 /*
  * Align the start of the metaslab to the group width and slightly reduce
  * its size to a multiple of the group width.  Since full stripe writes are
  * required by dRAID this space is unallocable.  Furthermore, aligning the
  * metaslab start is important for vdev initialize and TRIM which both operate
  * on metaslab boundaries which vdev_xlate() expects to be aligned.
  */
 static void
 vdev_draid_metaslab_init(vdev_t *vd, uint64_t *ms_start, uint64_t *ms_size)
 {
 	vdev_draid_config_t *vdc = vd->vdev_tsd;
 
 	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);
 
 	uint64_t sz = vdc->vdc_groupwidth << vd->vdev_ashift;
 	uint64_t astart = vdev_draid_get_astart(vd, *ms_start);
 	uint64_t asize = ((*ms_size - (astart - *ms_start)) / sz) * sz;
 
 	*ms_start = astart;
 	*ms_size = asize;
 
 	ASSERT0(*ms_start % sz);
 	ASSERT0(*ms_size % sz);
 }
 
 /*
  * Add virtual dRAID spares to the list of valid spares. In order to accomplish
  * this the existing array must be freed and reallocated with the additional
  * entries.
  */
 int
 vdev_draid_spare_create(nvlist_t *nvroot, vdev_t *vd, uint64_t *ndraidp,
     uint64_t next_vdev_id)
 {
 	uint64_t draid_nspares = 0;
 	uint64_t ndraid = 0;
 	int error;
 
 	for (uint64_t i = 0; i < vd->vdev_children; i++) {
 		vdev_t *cvd = vd->vdev_child[i];
 
 		if (cvd->vdev_ops == &vdev_draid_ops) {
 			vdev_draid_config_t *vdc = cvd->vdev_tsd;
 			draid_nspares += vdc->vdc_nspares;
 			ndraid++;
 		}
 	}
 
 	if (draid_nspares == 0) {
 		*ndraidp = ndraid;
 		return (0);
 	}
 
 	nvlist_t **old_spares, **new_spares;
 	uint_t old_nspares;
 	error = nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
 	    &old_spares, &old_nspares);
 	if (error)
 		old_nspares = 0;
 
 	/* Allocate memory and copy of the existing spares. */
 	new_spares = kmem_alloc(sizeof (nvlist_t *) *
 	    (draid_nspares + old_nspares), KM_SLEEP);
 	for (uint_t i = 0; i < old_nspares; i++)
 		new_spares[i] = fnvlist_dup(old_spares[i]);
 
 	/* Add new distributed spares to ZPOOL_CONFIG_SPARES. */
 	uint64_t n = old_nspares;
 	for (uint64_t vdev_id = 0; vdev_id < vd->vdev_children; vdev_id++) {
 		vdev_t *cvd = vd->vdev_child[vdev_id];
 		char path[64];
 
 		if (cvd->vdev_ops != &vdev_draid_ops)
 			continue;
 
 		vdev_draid_config_t *vdc = cvd->vdev_tsd;
 		uint64_t nspares = vdc->vdc_nspares;
 		uint64_t nparity = vdc->vdc_nparity;
 
 		for (uint64_t spare_id = 0; spare_id < nspares; spare_id++) {
 			memset(path, 0, sizeof (path));
 			(void) snprintf(path, sizeof (path) - 1,
 			    "%s%llu-%llu-%llu", VDEV_TYPE_DRAID,
 			    (u_longlong_t)nparity,
 			    (u_longlong_t)next_vdev_id + vdev_id,
 			    (u_longlong_t)spare_id);
 
 			nvlist_t *spare = fnvlist_alloc();
 			fnvlist_add_string(spare, ZPOOL_CONFIG_PATH, path);
 			fnvlist_add_string(spare, ZPOOL_CONFIG_TYPE,
 			    VDEV_TYPE_DRAID_SPARE);
 			fnvlist_add_uint64(spare, ZPOOL_CONFIG_TOP_GUID,
 			    cvd->vdev_guid);
 			fnvlist_add_uint64(spare, ZPOOL_CONFIG_SPARE_ID,
 			    spare_id);
 			fnvlist_add_uint64(spare, ZPOOL_CONFIG_IS_LOG, 0);
 			fnvlist_add_uint64(spare, ZPOOL_CONFIG_IS_SPARE, 1);
 			fnvlist_add_uint64(spare, ZPOOL_CONFIG_WHOLE_DISK, 1);
 			fnvlist_add_uint64(spare, ZPOOL_CONFIG_ASHIFT,
 			    cvd->vdev_ashift);
 
 			new_spares[n] = spare;
 			n++;
 		}
 	}
 
 	if (n > 0) {
 		(void) nvlist_remove_all(nvroot, ZPOOL_CONFIG_SPARES);
 		fnvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
 		    (const nvlist_t **)new_spares, n);
 	}
 
 	for (int i = 0; i < n; i++)
 		nvlist_free(new_spares[i]);
 
 	kmem_free(new_spares, sizeof (*new_spares) * n);
 	*ndraidp = ndraid;
 
 	return (0);
 }
 
 /*
  * Determine if any portion of the provided block resides on a child vdev
  * with a dirty DTL and therefore needs to be resilvered.
  */
 static boolean_t
 vdev_draid_need_resilver(vdev_t *vd, const dva_t *dva, size_t psize,
     uint64_t phys_birth)
 {
 	uint64_t offset = DVA_GET_OFFSET(dva);
 	uint64_t asize = vdev_draid_asize(vd, psize, 0);
 
 	if (phys_birth == TXG_UNKNOWN) {
 		/*
 		 * Sequential resilver.  There is no meaningful phys_birth
 		 * for this block, we can only determine if block resides
 		 * in a degraded group in which case it must be resilvered.
 		 */
 		ASSERT3U(vdev_draid_offset_to_group(vd, offset), ==,
 		    vdev_draid_offset_to_group(vd, offset + asize - 1));
 
 		return (vdev_draid_group_degraded(vd, offset));
 	} else {
 		/*
 		 * Healing resilver.  TXGs not in DTL_PARTIAL are intact,
 		 * as are blocks in non-degraded groups.
 		 */
 		if (!vdev_dtl_contains(vd, DTL_PARTIAL, phys_birth, 1))
 			return (B_FALSE);
 
 		if (vdev_draid_group_missing(vd, offset, phys_birth, 1))
 			return (B_TRUE);
 
 		/* The block may span groups in which case check both. */
 		if (vdev_draid_offset_to_group(vd, offset) !=
 		    vdev_draid_offset_to_group(vd, offset + asize - 1)) {
 			if (vdev_draid_group_missing(vd,
 			    offset + asize, phys_birth, 1))
 				return (B_TRUE);
 		}
 
 		return (B_FALSE);
 	}
 }
 
 static boolean_t
 vdev_draid_rebuilding(vdev_t *vd)
 {
 	if (vd->vdev_ops->vdev_op_leaf && vd->vdev_rebuild_txg)
 		return (B_TRUE);
 
 	for (int i = 0; i < vd->vdev_children; i++) {
 		if (vdev_draid_rebuilding(vd->vdev_child[i])) {
 			return (B_TRUE);
 		}
 	}
 
 	return (B_FALSE);
 }
 
 static void
 vdev_draid_io_verify(vdev_t *vd, raidz_row_t *rr, int col)
 {
 #ifdef ZFS_DEBUG
 	range_seg64_t logical_rs, physical_rs, remain_rs;
 	logical_rs.rs_start = rr->rr_offset;
 	logical_rs.rs_end = logical_rs.rs_start +
 	    vdev_draid_asize(vd, rr->rr_size, 0);
 
 	raidz_col_t *rc = &rr->rr_col[col];
 	vdev_t *cvd = vd->vdev_child[rc->rc_devidx];
 
 	vdev_xlate(cvd, &logical_rs, &physical_rs, &remain_rs);
 	ASSERT(vdev_xlate_is_empty(&remain_rs));
 	ASSERT3U(rc->rc_offset, ==, physical_rs.rs_start);
 	ASSERT3U(rc->rc_offset, <, physical_rs.rs_end);
 	ASSERT3U(rc->rc_offset + rc->rc_size, ==, physical_rs.rs_end);
 #endif
 }
 
 /*
  * For write operations:
  * 1. Generate the parity data
  * 2. Create child zio write operations to each column's vdev, for both
  *    data and parity.  A gang ABD is allocated by vdev_draid_map_alloc()
  *    if a skip sector needs to be added to a column.
  */
 static void
 vdev_draid_io_start_write(zio_t *zio, raidz_row_t *rr)
 {
 	vdev_t *vd = zio->io_vd;
 	raidz_map_t *rm = zio->io_vsd;
 
 	vdev_raidz_generate_parity_row(rm, rr);
 
 	for (int c = 0; c < rr->rr_cols; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 
 		/*
 		 * Empty columns are zero filled and included in the parity
 		 * calculation and therefore must be written.
 		 */
 		ASSERT3U(rc->rc_size, !=, 0);
 
 		/* Verify physical to logical translation */
 		vdev_draid_io_verify(vd, rr, c);
 
 		zio_nowait(zio_vdev_child_io(zio, NULL,
 		    vd->vdev_child[rc->rc_devidx], rc->rc_offset,
 		    rc->rc_abd, rc->rc_size, zio->io_type, zio->io_priority,
 		    0, vdev_raidz_child_done, rc));
 	}
 }
 
 /*
  * For read operations:
  * 1. The vdev_draid_map_alloc() function will create a minimal raidz
  *    mapping for the read based on the zio->io_flags.  There are two
  *    possible mappings either 1) a normal read, or 2) a scrub/resilver.
  * 2. Create the zio read operations.  This will include all parity
  *    columns and skip sectors for a scrub/resilver.
  */
 static void
 vdev_draid_io_start_read(zio_t *zio, raidz_row_t *rr)
 {
 	vdev_t *vd = zio->io_vd;
 
 	/* Sequential rebuild must do IO at redundancy group boundary. */
 	IMPLY(zio->io_priority == ZIO_PRIORITY_REBUILD, rr->rr_nempty == 0);
 
 	/*
 	 * Iterate over the columns in reverse order so that we hit the parity
 	 * last.  Any errors along the way will force us to read the parity.
 	 * For scrub/resilver IOs which verify skip sectors, a gang ABD will
 	 * have been allocated to store them and rc->rc_size is increased.
 	 */
 	for (int c = rr->rr_cols - 1; c >= 0; c--) {
 		raidz_col_t *rc = &rr->rr_col[c];
 		vdev_t *cvd = vd->vdev_child[rc->rc_devidx];
 
 		if (!vdev_draid_readable(cvd, rc->rc_offset)) {
 			if (c >= rr->rr_firstdatacol)
 				rr->rr_missingdata++;
 			else
 				rr->rr_missingparity++;
 			rc->rc_error = SET_ERROR(ENXIO);
 			rc->rc_tried = 1;
 			rc->rc_skipped = 1;
 			continue;
 		}
 
 		if (vdev_draid_missing(cvd, rc->rc_offset, zio->io_txg, 1)) {
 			if (c >= rr->rr_firstdatacol)
 				rr->rr_missingdata++;
 			else
 				rr->rr_missingparity++;
 			rc->rc_error = SET_ERROR(ESTALE);
 			rc->rc_skipped = 1;
 			continue;
 		}
 
 		/*
 		 * Empty columns may be read during vdev_draid_io_done().
 		 * Only skip them after the readable and missing checks
 		 * verify they are available.
 		 */
 		if (rc->rc_size == 0) {
 			rc->rc_skipped = 1;
 			continue;
 		}
 
 		if (zio->io_flags & ZIO_FLAG_RESILVER) {
 			vdev_t *svd;
 
 			/*
 			 * Sequential rebuilds need to always consider the data
 			 * on the child being rebuilt to be stale.  This is
 			 * important when all columns are available to aid
 			 * known reconstruction in identifing which columns
 			 * contain incorrect data.
 			 *
 			 * Furthermore, all repairs need to be constrained to
 			 * the devices being rebuilt because without a checksum
 			 * we cannot verify the data is actually correct and
 			 * performing an incorrect repair could result in
 			 * locking in damage and making the data unrecoverable.
 			 */
 			if (zio->io_priority == ZIO_PRIORITY_REBUILD) {
 				if (vdev_draid_rebuilding(cvd)) {
 					if (c >= rr->rr_firstdatacol)
 						rr->rr_missingdata++;
 					else
 						rr->rr_missingparity++;
 					rc->rc_error = SET_ERROR(ESTALE);
 					rc->rc_skipped = 1;
 					rc->rc_allow_repair = 1;
 					continue;
 				} else {
 					rc->rc_allow_repair = 0;
 				}
 			} else {
 				rc->rc_allow_repair = 1;
 			}
 
 			/*
 			 * If this child is a distributed spare then the
 			 * offset might reside on the vdev being replaced.
 			 * In which case this data must be written to the
 			 * new device.  Failure to do so would result in
 			 * checksum errors when the old device is detached
 			 * and the pool is scrubbed.
 			 */
 			if ((svd = vdev_draid_find_spare(cvd)) != NULL) {
 				svd = vdev_draid_spare_get_child(svd,
 				    rc->rc_offset);
 				if (svd && (svd->vdev_ops == &vdev_spare_ops ||
 				    svd->vdev_ops == &vdev_replacing_ops)) {
 					rc->rc_force_repair = 1;
 
 					if (vdev_draid_rebuilding(svd))
 						rc->rc_allow_repair = 1;
 				}
 			}
 
 			/*
 			 * Always issue a repair IO to this child when its
 			 * a spare or replacing vdev with an active rebuild.
 			 */
 			if ((cvd->vdev_ops == &vdev_spare_ops ||
 			    cvd->vdev_ops == &vdev_replacing_ops) &&
 			    vdev_draid_rebuilding(cvd)) {
 				rc->rc_force_repair = 1;
 				rc->rc_allow_repair = 1;
 			}
 		}
 	}
 
 	/*
 	 * Either a parity or data column is missing this means a repair
 	 * may be attempted by vdev_draid_io_done().  Expand the raid map
 	 * to read in empty columns which are needed along with the parity
 	 * during reconstruction.
 	 */
 	if ((rr->rr_missingdata > 0 || rr->rr_missingparity > 0) &&
 	    rr->rr_nempty > 0 && rr->rr_abd_empty == NULL) {
 		vdev_draid_map_alloc_empty(zio, rr);
 	}
 
 	for (int c = rr->rr_cols - 1; c >= 0; c--) {
 		raidz_col_t *rc = &rr->rr_col[c];
 		vdev_t *cvd = vd->vdev_child[rc->rc_devidx];
 
 		if (rc->rc_error || rc->rc_size == 0)
 			continue;
 
 		if (c >= rr->rr_firstdatacol || rr->rr_missingdata > 0 ||
 		    (zio->io_flags & (ZIO_FLAG_SCRUB | ZIO_FLAG_RESILVER))) {
 			zio_nowait(zio_vdev_child_io(zio, NULL, cvd,
 			    rc->rc_offset, rc->rc_abd, rc->rc_size,
 			    zio->io_type, zio->io_priority, 0,
 			    vdev_raidz_child_done, rc));
 		}
 	}
 }
 
 /*
  * Start an IO operation to a dRAID vdev.
  */
 static void
 vdev_draid_io_start(zio_t *zio)
 {
 	vdev_t *vd __maybe_unused = zio->io_vd;
 
 	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);
 	ASSERT3U(zio->io_offset, ==, vdev_draid_get_astart(vd, zio->io_offset));
 
 	raidz_map_t *rm = vdev_draid_map_alloc(zio);
 	zio->io_vsd = rm;
 	zio->io_vsd_ops = &vdev_raidz_vsd_ops;
 
 	if (zio->io_type == ZIO_TYPE_WRITE) {
 		for (int i = 0; i < rm->rm_nrows; i++) {
 			vdev_draid_io_start_write(zio, rm->rm_row[i]);
 		}
 	} else {
 		ASSERT(zio->io_type == ZIO_TYPE_READ);
 
 		for (int i = 0; i < rm->rm_nrows; i++) {
 			vdev_draid_io_start_read(zio, rm->rm_row[i]);
 		}
 	}
 
 	zio_execute(zio);
 }
 
 /*
  * Complete an IO operation on a dRAID vdev.  The raidz logic can be applied
  * to dRAID since the layout is fully described by the raidz_map_t.
  */
 static void
 vdev_draid_io_done(zio_t *zio)
 {
 	vdev_raidz_io_done(zio);
 }
 
 static void
 vdev_draid_state_change(vdev_t *vd, int faulted, int degraded)
 {
 	vdev_draid_config_t *vdc = vd->vdev_tsd;
 	ASSERT(vd->vdev_ops == &vdev_draid_ops);
 
 	if (faulted > vdc->vdc_nparity)
 		vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
 		    VDEV_AUX_NO_REPLICAS);
 	else if (degraded + faulted != 0)
 		vdev_set_state(vd, B_FALSE, VDEV_STATE_DEGRADED, VDEV_AUX_NONE);
 	else
 		vdev_set_state(vd, B_FALSE, VDEV_STATE_HEALTHY, VDEV_AUX_NONE);
 }
 
 static void
 vdev_draid_xlate(vdev_t *cvd, const range_seg64_t *logical_rs,
     range_seg64_t *physical_rs, range_seg64_t *remain_rs)
 {
 	vdev_t *raidvd = cvd->vdev_parent;
 	ASSERT(raidvd->vdev_ops == &vdev_draid_ops);
 
 	vdev_draid_config_t *vdc = raidvd->vdev_tsd;
 	uint64_t ashift = raidvd->vdev_top->vdev_ashift;
 
 	/* Make sure the offsets are block-aligned */
 	ASSERT0(logical_rs->rs_start % (1 << ashift));
 	ASSERT0(logical_rs->rs_end % (1 << ashift));
 
 	uint64_t logical_start = logical_rs->rs_start;
 	uint64_t logical_end = logical_rs->rs_end;
 
 	/*
 	 * Unaligned ranges must be skipped. All metaslabs are correctly
 	 * aligned so this should not happen, but this case is handled in
 	 * case it's needed by future callers.
 	 */
 	uint64_t astart = vdev_draid_get_astart(raidvd, logical_start);
 	if (astart != logical_start) {
 		physical_rs->rs_start = logical_start;
 		physical_rs->rs_end = logical_start;
 		remain_rs->rs_start = MIN(astart, logical_end);
 		remain_rs->rs_end = logical_end;
 		return;
 	}
 
 	/*
 	 * Unlike with mirrors and raidz a dRAID logical range can map
 	 * to multiple non-contiguous physical ranges. This is handled by
 	 * limiting the size of the logical range to a single group and
 	 * setting the remain argument such that it describes the remaining
 	 * unmapped logical range. This is stricter than absolutely
 	 * necessary but helps simplify the logic below.
 	 */
 	uint64_t group = vdev_draid_offset_to_group(raidvd, logical_start);
 	uint64_t nextstart = vdev_draid_group_to_offset(raidvd, group + 1);
 	if (logical_end > nextstart)
 		logical_end = nextstart;
 
 	/* Find the starting offset for each vdev in the group */
 	uint64_t perm, groupstart;
 	uint64_t start = vdev_draid_logical_to_physical(raidvd,
 	    logical_start, &perm, &groupstart);
 	uint64_t end = start;
 
 	uint8_t *base;
 	uint64_t iter, id;
 	vdev_draid_get_perm(vdc, perm, &base, &iter);
 
 	/*
 	 * Check if the passed child falls within the group.  If it does
 	 * update the start and end to reflect the physical range.
 	 * Otherwise, leave them unmodified which will result in an empty
 	 * (zero-length) physical range being returned.
 	 */
 	for (uint64_t i = 0; i < vdc->vdc_groupwidth; i++) {
 		uint64_t c = (groupstart + i) % vdc->vdc_ndisks;
 
 		if (c == 0 && i != 0) {
 			/* the group wrapped, increment the start */
 			start += VDEV_DRAID_ROWHEIGHT;
 			end = start;
 		}
 
 		id = vdev_draid_permute_id(vdc, base, iter, c);
 		if (id == cvd->vdev_id) {
 			uint64_t b_size = (logical_end >> ashift) -
 			    (logical_start >> ashift);
 			ASSERT3U(b_size, >, 0);
 			end = start + ((((b_size - 1) /
 			    vdc->vdc_groupwidth) + 1) << ashift);
 			break;
 		}
 	}
 	physical_rs->rs_start = start;
 	physical_rs->rs_end = end;
 
 	/*
 	 * Only top-level vdevs are allowed to set remain_rs because
 	 * when .vdev_op_xlate() is called for their children the full
 	 * logical range is not provided by vdev_xlate().
 	 */
 	remain_rs->rs_start = logical_end;
 	remain_rs->rs_end = logical_rs->rs_end;
 
 	ASSERT3U(physical_rs->rs_start, <=, logical_start);
 	ASSERT3U(physical_rs->rs_end - physical_rs->rs_start, <=,
 	    logical_end - logical_start);
 }
 
 /*
  * Add dRAID specific fields to the config nvlist.
  */
 static void
 vdev_draid_config_generate(vdev_t *vd, nvlist_t *nv)
 {
 	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);
 	vdev_draid_config_t *vdc = vd->vdev_tsd;
 
 	fnvlist_add_uint64(nv, ZPOOL_CONFIG_NPARITY, vdc->vdc_nparity);
 	fnvlist_add_uint64(nv, ZPOOL_CONFIG_DRAID_NDATA, vdc->vdc_ndata);
 	fnvlist_add_uint64(nv, ZPOOL_CONFIG_DRAID_NSPARES, vdc->vdc_nspares);
 	fnvlist_add_uint64(nv, ZPOOL_CONFIG_DRAID_NGROUPS, vdc->vdc_ngroups);
 }
 
 /*
  * Initialize private dRAID specific fields from the nvlist.
  */
 static int
 vdev_draid_init(spa_t *spa, nvlist_t *nv, void **tsd)
 {
 	(void) spa;
 	uint64_t ndata, nparity, nspares, ngroups;
 	int error;
 
 	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DRAID_NDATA, &ndata))
 		return (SET_ERROR(EINVAL));
 
 	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY, &nparity) ||
 	    nparity == 0 || nparity > VDEV_DRAID_MAXPARITY) {
 		return (SET_ERROR(EINVAL));
 	}
 
 	uint_t children;
 	nvlist_t **child;
 	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
 	    &child, &children) != 0 || children == 0 ||
 	    children > VDEV_DRAID_MAX_CHILDREN) {
 		return (SET_ERROR(EINVAL));
 	}
 
 	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DRAID_NSPARES, &nspares) ||
 	    nspares > 100 || nspares > (children - (ndata + nparity))) {
 		return (SET_ERROR(EINVAL));
 	}
 
 	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DRAID_NGROUPS, &ngroups) ||
 	    ngroups == 0 || ngroups > VDEV_DRAID_MAX_CHILDREN) {
 		return (SET_ERROR(EINVAL));
 	}
 
 	/*
 	 * Validate the minimum number of children exist per group for the
 	 * specified parity level (draid1 >= 2, draid2 >= 3, draid3 >= 4).
 	 */
 	if (children < (ndata + nparity + nspares))
 		return (SET_ERROR(EINVAL));
 
 	/*
 	 * Create the dRAID configuration using the pool nvlist configuration
 	 * and the fixed mapping for the correct number of children.
 	 */
 	vdev_draid_config_t *vdc;
 	const draid_map_t *map;
 
 	error = vdev_draid_lookup_map(children, &map);
 	if (error)
 		return (SET_ERROR(EINVAL));
 
 	vdc = kmem_zalloc(sizeof (*vdc), KM_SLEEP);
 	vdc->vdc_ndata = ndata;
 	vdc->vdc_nparity = nparity;
 	vdc->vdc_nspares = nspares;
 	vdc->vdc_children = children;
 	vdc->vdc_ngroups = ngroups;
 	vdc->vdc_nperms = map->dm_nperms;
 
 	error = vdev_draid_generate_perms(map, &vdc->vdc_perms);
 	if (error) {
 		kmem_free(vdc, sizeof (*vdc));
 		return (SET_ERROR(EINVAL));
 	}
 
 	/*
 	 * Derived constants.
 	 */
 	vdc->vdc_groupwidth = vdc->vdc_ndata + vdc->vdc_nparity;
 	vdc->vdc_ndisks = vdc->vdc_children - vdc->vdc_nspares;
 	vdc->vdc_groupsz = vdc->vdc_groupwidth * VDEV_DRAID_ROWHEIGHT;
 	vdc->vdc_devslicesz = (vdc->vdc_groupsz * vdc->vdc_ngroups) /
 	    vdc->vdc_ndisks;
 
 	ASSERT3U(vdc->vdc_groupwidth, >=, 2);
 	ASSERT3U(vdc->vdc_groupwidth, <=, vdc->vdc_ndisks);
 	ASSERT3U(vdc->vdc_groupsz, >=, 2 * VDEV_DRAID_ROWHEIGHT);
 	ASSERT3U(vdc->vdc_devslicesz, >=, VDEV_DRAID_ROWHEIGHT);
 	ASSERT3U(vdc->vdc_devslicesz % VDEV_DRAID_ROWHEIGHT, ==, 0);
 	ASSERT3U((vdc->vdc_groupwidth * vdc->vdc_ngroups) %
 	    vdc->vdc_ndisks, ==, 0);
 
 	*tsd = vdc;
 
 	return (0);
 }
 
 static void
 vdev_draid_fini(vdev_t *vd)
 {
 	vdev_draid_config_t *vdc = vd->vdev_tsd;
 
 	vmem_free(vdc->vdc_perms, sizeof (uint8_t) *
 	    vdc->vdc_children * vdc->vdc_nperms);
 	kmem_free(vdc, sizeof (*vdc));
 }
 
 static uint64_t
 vdev_draid_nparity(vdev_t *vd)
 {
 	vdev_draid_config_t *vdc = vd->vdev_tsd;
 
 	return (vdc->vdc_nparity);
 }
 
 static uint64_t
 vdev_draid_ndisks(vdev_t *vd)
 {
 	vdev_draid_config_t *vdc = vd->vdev_tsd;
 
 	return (vdc->vdc_ndisks);
 }
 
 vdev_ops_t vdev_draid_ops = {
 	.vdev_op_init = vdev_draid_init,
 	.vdev_op_fini = vdev_draid_fini,
 	.vdev_op_open = vdev_draid_open,
 	.vdev_op_close = vdev_draid_close,
 	.vdev_op_asize = vdev_draid_asize,
 	.vdev_op_min_asize = vdev_draid_min_asize,
 	.vdev_op_min_alloc = vdev_draid_min_alloc,
 	.vdev_op_io_start = vdev_draid_io_start,
 	.vdev_op_io_done = vdev_draid_io_done,
 	.vdev_op_state_change = vdev_draid_state_change,
 	.vdev_op_need_resilver = vdev_draid_need_resilver,
 	.vdev_op_hold = NULL,
 	.vdev_op_rele = NULL,
 	.vdev_op_remap = NULL,
 	.vdev_op_xlate = vdev_draid_xlate,
 	.vdev_op_rebuild_asize = vdev_draid_rebuild_asize,
 	.vdev_op_metaslab_init = vdev_draid_metaslab_init,
 	.vdev_op_config_generate = vdev_draid_config_generate,
 	.vdev_op_nparity = vdev_draid_nparity,
 	.vdev_op_ndisks = vdev_draid_ndisks,
 	.vdev_op_type = VDEV_TYPE_DRAID,
 	.vdev_op_leaf = B_FALSE,
 };
 
 
 /*
  * A dRAID distributed spare is a virtual leaf vdev which is included in the
  * parent dRAID configuration.  The last N columns of the dRAID permutation
  * table are used to determine on which dRAID children a specific offset
  * should be written.  These spare leaf vdevs can only be used to replace
  * faulted children in the same dRAID configuration.
  */
 
 /*
  * Distributed spare state.  All fields are set when the distributed spare is
  * first opened and are immutable.
  */
 typedef struct {
 	vdev_t *vds_draid_vdev;		/* top-level parent dRAID vdev */
 	uint64_t vds_top_guid;		/* top-level parent dRAID guid */
 	uint64_t vds_spare_id;		/* spare id (0 - vdc->vdc_nspares-1) */
 } vdev_draid_spare_t;
 
 /*
  * Returns the parent dRAID vdev to which the distributed spare belongs.
  * This may be safely called even when the vdev is not open.
  */
 vdev_t *
 vdev_draid_spare_get_parent(vdev_t *vd)
 {
 	vdev_draid_spare_t *vds = vd->vdev_tsd;
 
 	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_spare_ops);
 
 	if (vds->vds_draid_vdev != NULL)
 		return (vds->vds_draid_vdev);
 
 	return (vdev_lookup_by_guid(vd->vdev_spa->spa_root_vdev,
 	    vds->vds_top_guid));
 }
 
 /*
  * A dRAID space is active when it's the child of a vdev using the
  * vdev_spare_ops, vdev_replacing_ops or vdev_draid_ops.
  */
 static boolean_t
 vdev_draid_spare_is_active(vdev_t *vd)
 {
 	vdev_t *pvd = vd->vdev_parent;
 
 	if (pvd != NULL && (pvd->vdev_ops == &vdev_spare_ops ||
 	    pvd->vdev_ops == &vdev_replacing_ops ||
 	    pvd->vdev_ops == &vdev_draid_ops)) {
 		return (B_TRUE);
 	} else {
 		return (B_FALSE);
 	}
 }
 
 /*
  * Given a dRAID distribute spare vdev, returns the physical child vdev
  * on which the provided offset resides.  This may involve recursing through
  * multiple layers of distributed spares.  Note that offset is relative to
  * this vdev.
  */
 vdev_t *
 vdev_draid_spare_get_child(vdev_t *vd, uint64_t physical_offset)
 {
 	vdev_draid_spare_t *vds = vd->vdev_tsd;
 
 	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_spare_ops);
 
 	/* The vdev is closed */
 	if (vds->vds_draid_vdev == NULL)
 		return (NULL);
 
 	vdev_t *tvd = vds->vds_draid_vdev;
 	vdev_draid_config_t *vdc = tvd->vdev_tsd;
 
 	ASSERT3P(tvd->vdev_ops, ==, &vdev_draid_ops);
 	ASSERT3U(vds->vds_spare_id, <, vdc->vdc_nspares);
 
 	uint8_t *base;
 	uint64_t iter;
 	uint64_t perm = physical_offset / vdc->vdc_devslicesz;
 
 	vdev_draid_get_perm(vdc, perm, &base, &iter);
 
 	uint64_t cid = vdev_draid_permute_id(vdc, base, iter,
 	    (tvd->vdev_children - 1) - vds->vds_spare_id);
 	vdev_t *cvd = tvd->vdev_child[cid];
 
 	if (cvd->vdev_ops == &vdev_draid_spare_ops)
 		return (vdev_draid_spare_get_child(cvd, physical_offset));
 
 	return (cvd);
 }
 
 static void
 vdev_draid_spare_close(vdev_t *vd)
 {
 	vdev_draid_spare_t *vds = vd->vdev_tsd;
 	vds->vds_draid_vdev = NULL;
 }
 
 /*
  * Opening a dRAID spare device is done by looking up the associated dRAID
  * top-level vdev guid from the spare configuration.
  */
 static int
 vdev_draid_spare_open(vdev_t *vd, uint64_t *psize, uint64_t *max_psize,
     uint64_t *logical_ashift, uint64_t *physical_ashift)
 {
 	vdev_draid_spare_t *vds = vd->vdev_tsd;
 	vdev_t *rvd = vd->vdev_spa->spa_root_vdev;
 	uint64_t asize, max_asize;
 
 	vdev_t *tvd = vdev_lookup_by_guid(rvd, vds->vds_top_guid);
 	if (tvd == NULL) {
 		/*
 		 * When spa_vdev_add() is labeling new spares the
 		 * associated dRAID is not attached to the root vdev
 		 * nor does this spare have a parent.  Simulate a valid
 		 * device in order to allow the label to be initialized
 		 * and the distributed spare added to the configuration.
 		 */
 		if (vd->vdev_parent == NULL) {
 			*psize = *max_psize = SPA_MINDEVSIZE;
 			*logical_ashift = *physical_ashift = ASHIFT_MIN;
 			return (0);
 		}
 
 		return (SET_ERROR(EINVAL));
 	}
 
 	vdev_draid_config_t *vdc = tvd->vdev_tsd;
 	if (tvd->vdev_ops != &vdev_draid_ops || vdc == NULL)
 		return (SET_ERROR(EINVAL));
 
 	if (vds->vds_spare_id >= vdc->vdc_nspares)
 		return (SET_ERROR(EINVAL));
 
 	/*
 	 * Neither tvd->vdev_asize or tvd->vdev_max_asize can be used here
 	 * because the caller may be vdev_draid_open() in which case the
 	 * values are stale as they haven't yet been updated by vdev_open().
 	 * To avoid this always recalculate the dRAID asize and max_asize.
 	 */
 	vdev_draid_calculate_asize(tvd, &asize, &max_asize,
 	    logical_ashift, physical_ashift);
 
 	*psize = asize + VDEV_LABEL_START_SIZE + VDEV_LABEL_END_SIZE;
 	*max_psize = max_asize + VDEV_LABEL_START_SIZE + VDEV_LABEL_END_SIZE;
 
 	vds->vds_draid_vdev = tvd;
 
 	return (0);
 }
 
 /*
  * Completed distributed spare IO.  Store the result in the parent zio
  * as if it had performed the operation itself.  Only the first error is
  * preserved if there are multiple errors.
  */
 static void
 vdev_draid_spare_child_done(zio_t *zio)
 {
 	zio_t *pio = zio->io_private;
 
 	/*
 	 * IOs are issued to non-writable vdevs in order to keep their
 	 * DTLs accurate.  However, we don't want to propagate the
 	 * error in to the distributed spare's DTL.  When resilvering
 	 * vdev_draid_need_resilver() will consult the relevant DTL
 	 * to determine if the data is missing and must be repaired.
 	 */
 	if (!vdev_writeable(zio->io_vd))
 		return;
 
 	if (pio->io_error == 0)
 		pio->io_error = zio->io_error;
 }
 
 /*
  * Returns a valid label nvlist for the distributed spare vdev.  This is
  * used to bypass the IO pipeline to avoid the complexity of constructing
  * a complete label with valid checksum to return when read.
  */
 nvlist_t *
 vdev_draid_read_config_spare(vdev_t *vd)
 {
 	spa_t *spa = vd->vdev_spa;
 	spa_aux_vdev_t *sav = &spa->spa_spares;
 	uint64_t guid = vd->vdev_guid;
 
 	nvlist_t *nv = fnvlist_alloc();
 	fnvlist_add_uint64(nv, ZPOOL_CONFIG_IS_SPARE, 1);
 	fnvlist_add_uint64(nv, ZPOOL_CONFIG_CREATE_TXG, vd->vdev_crtxg);
 	fnvlist_add_uint64(nv, ZPOOL_CONFIG_VERSION, spa_version(spa));
 	fnvlist_add_string(nv, ZPOOL_CONFIG_POOL_NAME, spa_name(spa));
 	fnvlist_add_uint64(nv, ZPOOL_CONFIG_POOL_GUID, spa_guid(spa));
 	fnvlist_add_uint64(nv, ZPOOL_CONFIG_POOL_TXG, spa->spa_config_txg);
 	fnvlist_add_uint64(nv, ZPOOL_CONFIG_TOP_GUID, vd->vdev_top->vdev_guid);
 	fnvlist_add_uint64(nv, ZPOOL_CONFIG_POOL_STATE,
 	    vdev_draid_spare_is_active(vd) ?
 	    POOL_STATE_ACTIVE : POOL_STATE_SPARE);
 
 	/* Set the vdev guid based on the vdev list in sav_count. */
 	for (int i = 0; i < sav->sav_count; i++) {
 		if (sav->sav_vdevs[i]->vdev_ops == &vdev_draid_spare_ops &&
 		    strcmp(sav->sav_vdevs[i]->vdev_path, vd->vdev_path) == 0) {
 			guid = sav->sav_vdevs[i]->vdev_guid;
 			break;
 		}
 	}
 
 	fnvlist_add_uint64(nv, ZPOOL_CONFIG_GUID, guid);
 
 	return (nv);
 }
 
 /*
  * Handle any flush requested of the distributed spare. All children must be
  * flushed.
  */
 static int
 vdev_draid_spare_flush(zio_t *zio)
 {
 	vdev_t *vd = zio->io_vd;
 	int error = 0;
 
 	for (int c = 0; c < vd->vdev_children; c++) {
 		zio_nowait(zio_vdev_child_io(zio, NULL,
 		    vd->vdev_child[c], zio->io_offset, zio->io_abd,
 		    zio->io_size, zio->io_type, zio->io_priority, 0,
 		    vdev_draid_spare_child_done, zio));
 	}
 
 	return (error);
 }
 
 /*
  * Initiate an IO to the distributed spare.  For normal IOs this entails using
  * the zio->io_offset and permutation table to calculate which child dRAID vdev
  * is responsible for the data.  Then passing along the zio to that child to
  * perform the actual IO.  The label ranges are not stored on disk and require
  * some special handling which is described below.
  */
 static void
 vdev_draid_spare_io_start(zio_t *zio)
 {
 	vdev_t *cvd = NULL, *vd = zio->io_vd;
 	vdev_draid_spare_t *vds = vd->vdev_tsd;
 	uint64_t offset = zio->io_offset - VDEV_LABEL_START_SIZE;
 
 	/*
 	 * If the vdev is closed, it's likely in the REMOVED or FAULTED state.
 	 * Nothing to be done here but return failure.
 	 */
 	if (vds == NULL) {
 		zio->io_error = ENXIO;
 		zio_interrupt(zio);
 		return;
 	}
 
 	switch (zio->io_type) {
 	case ZIO_TYPE_FLUSH:
 		zio->io_error = vdev_draid_spare_flush(zio);
 		break;
 
 	case ZIO_TYPE_WRITE:
 		if (VDEV_OFFSET_IS_LABEL(vd, zio->io_offset)) {
 			/*
 			 * Accept probe IOs and config writers to simulate the
 			 * existence of an on disk label.  vdev_label_sync(),
 			 * vdev_uberblock_sync() and vdev_copy_uberblocks()
 			 * skip the distributed spares.  This only leaves
 			 * vdev_label_init() which is allowed to succeed to
 			 * avoid adding special cases the function.
 			 */
 			if (zio->io_flags & ZIO_FLAG_PROBE ||
 			    zio->io_flags & ZIO_FLAG_CONFIG_WRITER) {
 				zio->io_error = 0;
 			} else {
 				zio->io_error = SET_ERROR(EIO);
 			}
 		} else {
 			cvd = vdev_draid_spare_get_child(vd, offset);
 
 			if (cvd == NULL) {
 				zio->io_error = SET_ERROR(ENXIO);
 			} else {
 				zio_nowait(zio_vdev_child_io(zio, NULL, cvd,
 				    offset, zio->io_abd, zio->io_size,
 				    zio->io_type, zio->io_priority, 0,
 				    vdev_draid_spare_child_done, zio));
 			}
 		}
 		break;
 
 	case ZIO_TYPE_READ:
 		if (VDEV_OFFSET_IS_LABEL(vd, zio->io_offset)) {
 			/*
 			 * Accept probe IOs to simulate the existence of a
 			 * label.  vdev_label_read_config() bypasses the
 			 * pipeline to read the label configuration and
 			 * vdev_uberblock_load() skips distributed spares
 			 * when attempting to locate the best uberblock.
 			 */
 			if (zio->io_flags & ZIO_FLAG_PROBE) {
 				zio->io_error = 0;
 			} else {
 				zio->io_error = SET_ERROR(EIO);
 			}
 		} else {
 			cvd = vdev_draid_spare_get_child(vd, offset);
 
 			if (cvd == NULL || !vdev_readable(cvd)) {
 				zio->io_error = SET_ERROR(ENXIO);
 			} else {
 				zio_nowait(zio_vdev_child_io(zio, NULL, cvd,
 				    offset, zio->io_abd, zio->io_size,
 				    zio->io_type, zio->io_priority, 0,
 				    vdev_draid_spare_child_done, zio));
 			}
 		}
 		break;
 
 	case ZIO_TYPE_TRIM:
 		/* The vdev label ranges are never trimmed */
 		ASSERT0(VDEV_OFFSET_IS_LABEL(vd, zio->io_offset));
 
 		cvd = vdev_draid_spare_get_child(vd, offset);
 
 		if (cvd == NULL || !cvd->vdev_has_trim) {
 			zio->io_error = SET_ERROR(ENXIO);
 		} else {
 			zio_nowait(zio_vdev_child_io(zio, NULL, cvd,
 			    offset, zio->io_abd, zio->io_size,
 			    zio->io_type, zio->io_priority, 0,
 			    vdev_draid_spare_child_done, zio));
 		}
 		break;
 
 	default:
 		zio->io_error = SET_ERROR(ENOTSUP);
 		break;
 	}
 
 	zio_execute(zio);
 }
 
 static void
 vdev_draid_spare_io_done(zio_t *zio)
 {
 	(void) zio;
 }
 
 /*
  * Lookup the full spare config in spa->spa_spares.sav_config and
  * return the top_guid and spare_id for the named spare.
  */
 static int
 vdev_draid_spare_lookup(spa_t *spa, nvlist_t *nv, uint64_t *top_guidp,
     uint64_t *spare_idp)
 {
 	nvlist_t **spares;
 	uint_t nspares;
 	int error;
 
 	if ((spa->spa_spares.sav_config == NULL) ||
 	    (nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
 	    ZPOOL_CONFIG_SPARES, &spares, &nspares) != 0)) {
 		return (SET_ERROR(ENOENT));
 	}
 
 	const char *spare_name;
 	error = nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &spare_name);
 	if (error != 0)
 		return (SET_ERROR(EINVAL));
 
 	for (int i = 0; i < nspares; i++) {
 		nvlist_t *spare = spares[i];
 		uint64_t top_guid, spare_id;
 		const char *type, *path;
 
 		/* Skip non-distributed spares */
 		error = nvlist_lookup_string(spare, ZPOOL_CONFIG_TYPE, &type);
 		if (error != 0 || strcmp(type, VDEV_TYPE_DRAID_SPARE) != 0)
 			continue;
 
 		/* Skip spares with the wrong name */
 		error = nvlist_lookup_string(spare, ZPOOL_CONFIG_PATH, &path);
 		if (error != 0 || strcmp(path, spare_name) != 0)
 			continue;
 
 		/* Found the matching spare */
 		error = nvlist_lookup_uint64(spare,
 		    ZPOOL_CONFIG_TOP_GUID, &top_guid);
 		if (error == 0) {
 			error = nvlist_lookup_uint64(spare,
 			    ZPOOL_CONFIG_SPARE_ID, &spare_id);
 		}
 
 		if (error != 0) {
 			return (SET_ERROR(EINVAL));
 		} else {
 			*top_guidp = top_guid;
 			*spare_idp = spare_id;
 			return (0);
 		}
 	}
 
 	return (SET_ERROR(ENOENT));
 }
 
 /*
  * Initialize private dRAID spare specific fields from the nvlist.
  */
 static int
 vdev_draid_spare_init(spa_t *spa, nvlist_t *nv, void **tsd)
 {
 	vdev_draid_spare_t *vds;
 	uint64_t top_guid = 0;
 	uint64_t spare_id;
 
 	/*
 	 * In the normal case check the list of spares stored in the spa
 	 * to lookup the top_guid and spare_id for provided spare config.
 	 * When creating a new pool or adding vdevs the spare list is not
 	 * yet populated and the values are provided in the passed config.
 	 */
 	if (vdev_draid_spare_lookup(spa, nv, &top_guid, &spare_id) != 0) {
 		if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_TOP_GUID,
 		    &top_guid) != 0)
 			return (SET_ERROR(EINVAL));
 
 		if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_SPARE_ID,
 		    &spare_id) != 0)
 			return (SET_ERROR(EINVAL));
 	}
 
 	vds = kmem_alloc(sizeof (vdev_draid_spare_t), KM_SLEEP);
 	vds->vds_draid_vdev = NULL;
 	vds->vds_top_guid = top_guid;
 	vds->vds_spare_id = spare_id;
 
 	*tsd = vds;
 
 	return (0);
 }
 
 static void
 vdev_draid_spare_fini(vdev_t *vd)
 {
 	kmem_free(vd->vdev_tsd, sizeof (vdev_draid_spare_t));
 }
 
 static void
 vdev_draid_spare_config_generate(vdev_t *vd, nvlist_t *nv)
 {
 	vdev_draid_spare_t *vds = vd->vdev_tsd;
 
 	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_spare_ops);
 
 	fnvlist_add_uint64(nv, ZPOOL_CONFIG_TOP_GUID, vds->vds_top_guid);
 	fnvlist_add_uint64(nv, ZPOOL_CONFIG_SPARE_ID, vds->vds_spare_id);
 }
 
 vdev_ops_t vdev_draid_spare_ops = {
 	.vdev_op_init = vdev_draid_spare_init,
 	.vdev_op_fini = vdev_draid_spare_fini,
 	.vdev_op_open = vdev_draid_spare_open,
 	.vdev_op_close = vdev_draid_spare_close,
 	.vdev_op_asize = vdev_default_asize,
 	.vdev_op_min_asize = vdev_default_min_asize,
 	.vdev_op_min_alloc = NULL,
 	.vdev_op_io_start = vdev_draid_spare_io_start,
 	.vdev_op_io_done = vdev_draid_spare_io_done,
 	.vdev_op_state_change = NULL,
 	.vdev_op_need_resilver = NULL,
 	.vdev_op_hold = NULL,
 	.vdev_op_rele = NULL,
 	.vdev_op_remap = NULL,
 	.vdev_op_xlate = vdev_default_xlate,
 	.vdev_op_rebuild_asize = NULL,
 	.vdev_op_metaslab_init = NULL,
 	.vdev_op_config_generate = vdev_draid_spare_config_generate,
 	.vdev_op_nparity = NULL,
 	.vdev_op_ndisks = NULL,
 	.vdev_op_type = VDEV_TYPE_DRAID_SPARE,
 	.vdev_op_leaf = B_TRUE,
 };
diff --git a/sys/contrib/openzfs/module/zfs/vdev_indirect.c b/sys/contrib/openzfs/module/zfs/vdev_indirect.c
index acb725696674..e3dba0257b21 100644
--- a/sys/contrib/openzfs/module/zfs/vdev_indirect.c
+++ b/sys/contrib/openzfs/module/zfs/vdev_indirect.c
@@ -1,1911 +1,1925 @@
 /*
  * CDDL HEADER START
  *
  * This file and its contents are supplied under the terms of the
  * Common Development and Distribution License ("CDDL"), version 1.0.
  * You may only use this file in accordance with the terms of version
  * 1.0 of the CDDL.
  *
  * A full copy of the text of the CDDL should have accompanied this
  * source.  A copy of the CDDL is also available via the Internet at
  * http://www.illumos.org/license/CDDL.
  *
  * CDDL HEADER END
  */
 
 /*
  * Copyright (c) 2014, 2017 by Delphix. All rights reserved.
  * Copyright (c) 2019, loli10K <ezomori.nozomu@gmail.com>. All rights reserved.
  * Copyright (c) 2014, 2020 by Delphix. All rights reserved.
  */
 
 #include <sys/zfs_context.h>
 #include <sys/spa.h>
 #include <sys/spa_impl.h>
 #include <sys/vdev_impl.h>
 #include <sys/fs/zfs.h>
 #include <sys/zio.h>
 #include <sys/zio_checksum.h>
 #include <sys/metaslab.h>
 #include <sys/dmu.h>
 #include <sys/vdev_indirect_mapping.h>
 #include <sys/dmu_tx.h>
 #include <sys/dsl_synctask.h>
 #include <sys/zap.h>
 #include <sys/abd.h>
 #include <sys/zthr.h>
+#include <sys/fm/fs/zfs.h>
 
 /*
  * An indirect vdev corresponds to a vdev that has been removed.  Since
  * we cannot rewrite block pointers of snapshots, etc., we keep a
  * mapping from old location on the removed device to the new location
  * on another device in the pool and use this mapping whenever we need
  * to access the DVA.  Unfortunately, this mapping did not respect
  * logical block boundaries when it was first created, and so a DVA on
  * this indirect vdev may be "split" into multiple sections that each
  * map to a different location.  As a consequence, not all DVAs can be
  * translated to an equivalent new DVA.  Instead we must provide a
  * "vdev_remap" operation that executes a callback on each contiguous
  * segment of the new location.  This function is used in multiple ways:
  *
  *  - I/Os to this vdev use the callback to determine where the
  *    data is now located, and issue child I/Os for each segment's new
  *    location.
  *
  *  - frees and claims to this vdev use the callback to free or claim
  *    each mapped segment.  (Note that we don't actually need to claim
  *    log blocks on indirect vdevs, because we don't allocate to
  *    removing vdevs.  However, zdb uses zio_claim() for its leak
  *    detection.)
  */
 
 /*
  * "Big theory statement" for how we mark blocks obsolete.
  *
  * When a block on an indirect vdev is freed or remapped, a section of
  * that vdev's mapping may no longer be referenced (aka "obsolete").  We
  * keep track of how much of each mapping entry is obsolete.  When
  * an entry becomes completely obsolete, we can remove it, thus reducing
  * the memory used by the mapping.  The complete picture of obsolescence
  * is given by the following data structures, described below:
  *  - the entry-specific obsolete count
  *  - the vdev-specific obsolete spacemap
  *  - the pool-specific obsolete bpobj
  *
  * == On disk data structures used ==
  *
  * We track the obsolete space for the pool using several objects.  Each
  * of these objects is created on demand and freed when no longer
  * needed, and is assumed to be empty if it does not exist.
  * SPA_FEATURE_OBSOLETE_COUNTS includes the count of these objects.
  *
  *  - Each vic_mapping_object (associated with an indirect vdev) can
  *    have a vimp_counts_object.  This is an array of uint32_t's
  *    with the same number of entries as the vic_mapping_object.  When
  *    the mapping is condensed, entries from the vic_obsolete_sm_object
  *    (see below) are folded into the counts.  Therefore, each
  *    obsolete_counts entry tells us the number of bytes in the
  *    corresponding mapping entry that were not referenced when the
  *    mapping was last condensed.
  *
  *  - Each indirect or removing vdev can have a vic_obsolete_sm_object.
  *    This is a space map containing an alloc entry for every DVA that
  *    has been obsoleted since the last time this indirect vdev was
  *    condensed.  We use this object in order to improve performance
  *    when marking a DVA as obsolete.  Instead of modifying an arbitrary
  *    offset of the vimp_counts_object, we only need to append an entry
  *    to the end of this object.  When a DVA becomes obsolete, it is
  *    added to the obsolete space map.  This happens when the DVA is
  *    freed, remapped and not referenced by a snapshot, or the last
  *    snapshot referencing it is destroyed.
  *
  *  - Each dataset can have a ds_remap_deadlist object.  This is a
  *    deadlist object containing all blocks that were remapped in this
  *    dataset but referenced in a previous snapshot.  Blocks can *only*
  *    appear on this list if they were remapped (dsl_dataset_block_remapped);
  *    blocks that were killed in a head dataset are put on the normal
  *    ds_deadlist and marked obsolete when they are freed.
  *
  *  - The pool can have a dp_obsolete_bpobj.  This is a list of blocks
  *    in the pool that need to be marked obsolete.  When a snapshot is
  *    destroyed, we move some of the ds_remap_deadlist to the obsolete
  *    bpobj (see dsl_destroy_snapshot_handle_remaps()).  We then
  *    asynchronously process the obsolete bpobj, moving its entries to
  *    the specific vdevs' obsolete space maps.
  *
  * == Summary of how we mark blocks as obsolete ==
  *
  * - When freeing a block: if any DVA is on an indirect vdev, append to
  *   vic_obsolete_sm_object.
  * - When remapping a block, add dva to ds_remap_deadlist (if prev snap
  *   references; otherwise append to vic_obsolete_sm_object).
  * - When freeing a snapshot: move parts of ds_remap_deadlist to
  *   dp_obsolete_bpobj (same algorithm as ds_deadlist).
  * - When syncing the spa: process dp_obsolete_bpobj, moving ranges to
  *   individual vdev's vic_obsolete_sm_object.
  */
 
 /*
  * "Big theory statement" for how we condense indirect vdevs.
  *
  * Condensing an indirect vdev's mapping is the process of determining
  * the precise counts of obsolete space for each mapping entry (by
  * integrating the obsolete spacemap into the obsolete counts) and
  * writing out a new mapping that contains only referenced entries.
  *
  * We condense a vdev when we expect the mapping to shrink (see
  * vdev_indirect_should_condense()), but only perform one condense at a
  * time to limit the memory usage.  In addition, we use a separate
  * open-context thread (spa_condense_indirect_thread) to incrementally
  * create the new mapping object in a way that minimizes the impact on
  * the rest of the system.
  *
  * == Generating a new mapping ==
  *
  * To generate a new mapping, we follow these steps:
  *
  * 1. Save the old obsolete space map and create a new mapping object
  *    (see spa_condense_indirect_start_sync()).  This initializes the
  *    spa_condensing_indirect_phys with the "previous obsolete space map",
  *    which is now read only.  Newly obsolete DVAs will be added to a
  *    new (initially empty) obsolete space map, and will not be
  *    considered as part of this condense operation.
  *
  * 2. Construct in memory the precise counts of obsolete space for each
  *    mapping entry, by incorporating the obsolete space map into the
  *    counts.  (See vdev_indirect_mapping_load_obsolete_{counts,spacemap}().)
  *
  * 3. Iterate through each mapping entry, writing to the new mapping any
  *    entries that are not completely obsolete (i.e. which don't have
  *    obsolete count == mapping length).  (See
  *    spa_condense_indirect_generate_new_mapping().)
  *
  * 4. Destroy the old mapping object and switch over to the new one
  *    (spa_condense_indirect_complete_sync).
  *
  * == Restarting from failure ==
  *
  * To restart the condense when we import/open the pool, we must start
  * at the 2nd step above: reconstruct the precise counts in memory,
  * based on the space map + counts.  Then in the 3rd step, we start
  * iterating where we left off: at vimp_max_offset of the new mapping
  * object.
  */
 
 static int zfs_condense_indirect_vdevs_enable = B_TRUE;
 
 /*
  * Condense if at least this percent of the bytes in the mapping is
  * obsolete.  With the default of 25%, the amount of space mapped
  * will be reduced to 1% of its original size after at most 16
  * condenses.  Higher values will condense less often (causing less
  * i/o); lower values will reduce the mapping size more quickly.
  */
 static uint_t zfs_condense_indirect_obsolete_pct = 25;
 
 /*
  * Condense if the obsolete space map takes up more than this amount of
  * space on disk (logically).  This limits the amount of disk space
  * consumed by the obsolete space map; the default of 1GB is small enough
  * that we typically don't mind "wasting" it.
  */
 static uint64_t zfs_condense_max_obsolete_bytes = 1024 * 1024 * 1024;
 
 /*
  * Don't bother condensing if the mapping uses less than this amount of
  * memory.  The default of 128KB is considered a "trivial" amount of
  * memory and not worth reducing.
  */
 static uint64_t zfs_condense_min_mapping_bytes = 128 * 1024;
 
 /*
  * This is used by the test suite so that it can ensure that certain
  * actions happen while in the middle of a condense (which might otherwise
  * complete too quickly).  If used to reduce the performance impact of
  * condensing in production, a maximum value of 1 should be sufficient.
  */
 static uint_t zfs_condense_indirect_commit_entry_delay_ms = 0;
 
 /*
  * If an indirect split block contains more than this many possible unique
  * combinations when being reconstructed, consider it too computationally
  * expensive to check them all. Instead, try at most 100 randomly-selected
  * combinations each time the block is accessed.  This allows all segment
  * copies to participate fairly in the reconstruction when all combinations
  * cannot be checked and prevents repeated use of one bad copy.
  */
 uint_t zfs_reconstruct_indirect_combinations_max = 4096;
 
 /*
  * Enable to simulate damaged segments and validate reconstruction.  This
  * is intentionally not exposed as a module parameter.
  */
 unsigned long zfs_reconstruct_indirect_damage_fraction = 0;
 
 /*
  * The indirect_child_t represents the vdev that we will read from, when we
  * need to read all copies of the data (e.g. for scrub or reconstruction).
  * For plain (non-mirror) top-level vdevs (i.e. is_vdev is not a mirror),
  * ic_vdev is the same as is_vdev.  However, for mirror top-level vdevs,
  * ic_vdev is a child of the mirror.
  */
 typedef struct indirect_child {
 	abd_t *ic_data;
 	vdev_t *ic_vdev;
 
 	/*
 	 * ic_duplicate is NULL when the ic_data contents are unique, when it
 	 * is determined to be a duplicate it references the primary child.
 	 */
 	struct indirect_child *ic_duplicate;
 	list_node_t ic_node; /* node on is_unique_child */
 	int ic_error; /* set when a child does not contain the data */
 } indirect_child_t;
 
 /*
  * The indirect_split_t represents one mapped segment of an i/o to the
  * indirect vdev. For non-split (contiguously-mapped) blocks, there will be
  * only one indirect_split_t, with is_split_offset==0 and is_size==io_size.
  * For split blocks, there will be several of these.
  */
 typedef struct indirect_split {
 	list_node_t is_node; /* link on iv_splits */
 
 	/*
 	 * is_split_offset is the offset into the i/o.
 	 * This is the sum of the previous splits' is_size's.
 	 */
 	uint64_t is_split_offset;
 
 	vdev_t *is_vdev; /* top-level vdev */
 	uint64_t is_target_offset; /* offset on is_vdev */
 	uint64_t is_size;
 	int is_children; /* number of entries in is_child[] */
 	int is_unique_children; /* number of entries in is_unique_child */
 	list_t is_unique_child;
 
 	/*
 	 * is_good_child is the child that we are currently using to
 	 * attempt reconstruction.
 	 */
 	indirect_child_t *is_good_child;
 
 	indirect_child_t is_child[];
 } indirect_split_t;
 
 /*
  * The indirect_vsd_t is associated with each i/o to the indirect vdev.
  * It is the "Vdev-Specific Data" in the zio_t's io_vsd.
  */
 typedef struct indirect_vsd {
 	boolean_t iv_split_block;
 	boolean_t iv_reconstruct;
 	uint64_t iv_unique_combinations;
 	uint64_t iv_attempts;
 	uint64_t iv_attempts_max;
 
 	list_t iv_splits; /* list of indirect_split_t's */
 } indirect_vsd_t;
 
 static void
 vdev_indirect_map_free(zio_t *zio)
 {
 	indirect_vsd_t *iv = zio->io_vsd;
 
 	indirect_split_t *is;
 	while ((is = list_remove_head(&iv->iv_splits)) != NULL) {
 		for (int c = 0; c < is->is_children; c++) {
 			indirect_child_t *ic = &is->is_child[c];
 			if (ic->ic_data != NULL)
 				abd_free(ic->ic_data);
 		}
 
 		indirect_child_t *ic;
 		while ((ic = list_remove_head(&is->is_unique_child)) != NULL)
 			;
 
 		list_destroy(&is->is_unique_child);
 
 		kmem_free(is,
 		    offsetof(indirect_split_t, is_child[is->is_children]));
 	}
 	kmem_free(iv, sizeof (*iv));
 }
 
 static const zio_vsd_ops_t vdev_indirect_vsd_ops = {
 	.vsd_free = vdev_indirect_map_free,
 };
 
 /*
  * Mark the given offset and size as being obsolete.
  */
 void
 vdev_indirect_mark_obsolete(vdev_t *vd, uint64_t offset, uint64_t size)
 {
 	spa_t *spa = vd->vdev_spa;
 
 	ASSERT3U(vd->vdev_indirect_config.vic_mapping_object, !=, 0);
 	ASSERT(vd->vdev_removing || vd->vdev_ops == &vdev_indirect_ops);
 	ASSERT(size > 0);
 	VERIFY(vdev_indirect_mapping_entry_for_offset(
 	    vd->vdev_indirect_mapping, offset) != NULL);
 
 	if (spa_feature_is_enabled(spa, SPA_FEATURE_OBSOLETE_COUNTS)) {
 		mutex_enter(&vd->vdev_obsolete_lock);
 		range_tree_add(vd->vdev_obsolete_segments, offset, size);
 		mutex_exit(&vd->vdev_obsolete_lock);
 		vdev_dirty(vd, 0, NULL, spa_syncing_txg(spa));
 	}
 }
 
 /*
  * Mark the DVA vdev_id:offset:size as being obsolete in the given tx. This
  * wrapper is provided because the DMU does not know about vdev_t's and
  * cannot directly call vdev_indirect_mark_obsolete.
  */
 void
 spa_vdev_indirect_mark_obsolete(spa_t *spa, uint64_t vdev_id, uint64_t offset,
     uint64_t size, dmu_tx_t *tx)
 {
 	vdev_t *vd = vdev_lookup_top(spa, vdev_id);
 	ASSERT(dmu_tx_is_syncing(tx));
 
 	/* The DMU can only remap indirect vdevs. */
 	ASSERT3P(vd->vdev_ops, ==, &vdev_indirect_ops);
 	vdev_indirect_mark_obsolete(vd, offset, size);
 }
 
 static spa_condensing_indirect_t *
 spa_condensing_indirect_create(spa_t *spa)
 {
 	spa_condensing_indirect_phys_t *scip =
 	    &spa->spa_condensing_indirect_phys;
 	spa_condensing_indirect_t *sci = kmem_zalloc(sizeof (*sci), KM_SLEEP);
 	objset_t *mos = spa->spa_meta_objset;
 
 	for (int i = 0; i < TXG_SIZE; i++) {
 		list_create(&sci->sci_new_mapping_entries[i],
 		    sizeof (vdev_indirect_mapping_entry_t),
 		    offsetof(vdev_indirect_mapping_entry_t, vime_node));
 	}
 
 	sci->sci_new_mapping =
 	    vdev_indirect_mapping_open(mos, scip->scip_next_mapping_object);
 
 	return (sci);
 }
 
 static void
 spa_condensing_indirect_destroy(spa_condensing_indirect_t *sci)
 {
 	for (int i = 0; i < TXG_SIZE; i++)
 		list_destroy(&sci->sci_new_mapping_entries[i]);
 
 	if (sci->sci_new_mapping != NULL)
 		vdev_indirect_mapping_close(sci->sci_new_mapping);
 
 	kmem_free(sci, sizeof (*sci));
 }
 
 boolean_t
 vdev_indirect_should_condense(vdev_t *vd)
 {
 	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
 	spa_t *spa = vd->vdev_spa;
 
 	ASSERT(dsl_pool_sync_context(spa->spa_dsl_pool));
 
 	if (!zfs_condense_indirect_vdevs_enable)
 		return (B_FALSE);
 
 	/*
 	 * We can only condense one indirect vdev at a time.
 	 */
 	if (spa->spa_condensing_indirect != NULL)
 		return (B_FALSE);
 
 	if (spa_shutting_down(spa))
 		return (B_FALSE);
 
 	/*
 	 * The mapping object size must not change while we are
 	 * condensing, so we can only condense indirect vdevs
 	 * (not vdevs that are still in the middle of being removed).
 	 */
 	if (vd->vdev_ops != &vdev_indirect_ops)
 		return (B_FALSE);
 
 	/*
 	 * If nothing new has been marked obsolete, there is no
 	 * point in condensing.
 	 */
 	uint64_t obsolete_sm_obj __maybe_unused;
 	ASSERT0(vdev_obsolete_sm_object(vd, &obsolete_sm_obj));
 	if (vd->vdev_obsolete_sm == NULL) {
 		ASSERT0(obsolete_sm_obj);
 		return (B_FALSE);
 	}
 
 	ASSERT(vd->vdev_obsolete_sm != NULL);
 
 	ASSERT3U(obsolete_sm_obj, ==, space_map_object(vd->vdev_obsolete_sm));
 
 	uint64_t bytes_mapped = vdev_indirect_mapping_bytes_mapped(vim);
 	uint64_t bytes_obsolete = space_map_allocated(vd->vdev_obsolete_sm);
 	uint64_t mapping_size = vdev_indirect_mapping_size(vim);
 	uint64_t obsolete_sm_size = space_map_length(vd->vdev_obsolete_sm);
 
 	ASSERT3U(bytes_obsolete, <=, bytes_mapped);
 
 	/*
 	 * If a high percentage of the bytes that are mapped have become
 	 * obsolete, condense (unless the mapping is already small enough).
 	 * This has a good chance of reducing the amount of memory used
 	 * by the mapping.
 	 */
 	if (bytes_obsolete * 100 / bytes_mapped >=
 	    zfs_condense_indirect_obsolete_pct &&
 	    mapping_size > zfs_condense_min_mapping_bytes) {
 		zfs_dbgmsg("should condense vdev %llu because obsolete "
 		    "spacemap covers %d%% of %lluMB mapping",
 		    (u_longlong_t)vd->vdev_id,
 		    (int)(bytes_obsolete * 100 / bytes_mapped),
 		    (u_longlong_t)bytes_mapped / 1024 / 1024);
 		return (B_TRUE);
 	}
 
 	/*
 	 * If the obsolete space map takes up too much space on disk,
 	 * condense in order to free up this disk space.
 	 */
 	if (obsolete_sm_size >= zfs_condense_max_obsolete_bytes) {
 		zfs_dbgmsg("should condense vdev %llu because obsolete sm "
 		    "length %lluMB >= max size %lluMB",
 		    (u_longlong_t)vd->vdev_id,
 		    (u_longlong_t)obsolete_sm_size / 1024 / 1024,
 		    (u_longlong_t)zfs_condense_max_obsolete_bytes /
 		    1024 / 1024);
 		return (B_TRUE);
 	}
 
 	return (B_FALSE);
 }
 
 /*
  * This sync task completes (finishes) a condense, deleting the old
  * mapping and replacing it with the new one.
  */
 static void
 spa_condense_indirect_complete_sync(void *arg, dmu_tx_t *tx)
 {
 	spa_condensing_indirect_t *sci = arg;
 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
 	spa_condensing_indirect_phys_t *scip =
 	    &spa->spa_condensing_indirect_phys;
 	vdev_t *vd = vdev_lookup_top(spa, scip->scip_vdev);
 	vdev_indirect_config_t *vic = &vd->vdev_indirect_config;
 	objset_t *mos = spa->spa_meta_objset;
 	vdev_indirect_mapping_t *old_mapping = vd->vdev_indirect_mapping;
 	uint64_t old_count = vdev_indirect_mapping_num_entries(old_mapping);
 	uint64_t new_count =
 	    vdev_indirect_mapping_num_entries(sci->sci_new_mapping);
 
 	ASSERT(dmu_tx_is_syncing(tx));
 	ASSERT3P(vd->vdev_ops, ==, &vdev_indirect_ops);
 	ASSERT3P(sci, ==, spa->spa_condensing_indirect);
 	for (int i = 0; i < TXG_SIZE; i++) {
 		ASSERT(list_is_empty(&sci->sci_new_mapping_entries[i]));
 	}
 	ASSERT(vic->vic_mapping_object != 0);
 	ASSERT3U(vd->vdev_id, ==, scip->scip_vdev);
 	ASSERT(scip->scip_next_mapping_object != 0);
 	ASSERT(scip->scip_prev_obsolete_sm_object != 0);
 
 	/*
 	 * Reset vdev_indirect_mapping to refer to the new object.
 	 */
 	rw_enter(&vd->vdev_indirect_rwlock, RW_WRITER);
 	vdev_indirect_mapping_close(vd->vdev_indirect_mapping);
 	vd->vdev_indirect_mapping = sci->sci_new_mapping;
 	rw_exit(&vd->vdev_indirect_rwlock);
 
 	sci->sci_new_mapping = NULL;
 	vdev_indirect_mapping_free(mos, vic->vic_mapping_object, tx);
 	vic->vic_mapping_object = scip->scip_next_mapping_object;
 	scip->scip_next_mapping_object = 0;
 
 	space_map_free_obj(mos, scip->scip_prev_obsolete_sm_object, tx);
 	spa_feature_decr(spa, SPA_FEATURE_OBSOLETE_COUNTS, tx);
 	scip->scip_prev_obsolete_sm_object = 0;
 
 	scip->scip_vdev = 0;
 
 	VERIFY0(zap_remove(mos, DMU_POOL_DIRECTORY_OBJECT,
 	    DMU_POOL_CONDENSING_INDIRECT, tx));
 	spa_condensing_indirect_destroy(spa->spa_condensing_indirect);
 	spa->spa_condensing_indirect = NULL;
 
 	zfs_dbgmsg("finished condense of vdev %llu in txg %llu: "
 	    "new mapping object %llu has %llu entries "
 	    "(was %llu entries)",
 	    (u_longlong_t)vd->vdev_id, (u_longlong_t)dmu_tx_get_txg(tx),
 	    (u_longlong_t)vic->vic_mapping_object,
 	    (u_longlong_t)new_count, (u_longlong_t)old_count);
 
 	vdev_config_dirty(spa->spa_root_vdev);
 }
 
 /*
  * This sync task appends entries to the new mapping object.
  */
 static void
 spa_condense_indirect_commit_sync(void *arg, dmu_tx_t *tx)
 {
 	spa_condensing_indirect_t *sci = arg;
 	uint64_t txg = dmu_tx_get_txg(tx);
 	spa_t *spa __maybe_unused = dmu_tx_pool(tx)->dp_spa;
 
 	ASSERT(dmu_tx_is_syncing(tx));
 	ASSERT3P(sci, ==, spa->spa_condensing_indirect);
 
 	vdev_indirect_mapping_add_entries(sci->sci_new_mapping,
 	    &sci->sci_new_mapping_entries[txg & TXG_MASK], tx);
 	ASSERT(list_is_empty(&sci->sci_new_mapping_entries[txg & TXG_MASK]));
 }
 
 /*
  * Open-context function to add one entry to the new mapping.  The new
  * entry will be remembered and written from syncing context.
  */
 static void
 spa_condense_indirect_commit_entry(spa_t *spa,
     vdev_indirect_mapping_entry_phys_t *vimep, uint32_t count)
 {
 	spa_condensing_indirect_t *sci = spa->spa_condensing_indirect;
 
 	ASSERT3U(count, <, DVA_GET_ASIZE(&vimep->vimep_dst));
 
 	dmu_tx_t *tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir);
 	dmu_tx_hold_space(tx, sizeof (*vimep) + sizeof (count));
 	VERIFY0(dmu_tx_assign(tx, TXG_WAIT));
 	int txgoff = dmu_tx_get_txg(tx) & TXG_MASK;
 
 	/*
 	 * If we are the first entry committed this txg, kick off the sync
 	 * task to write to the MOS on our behalf.
 	 */
 	if (list_is_empty(&sci->sci_new_mapping_entries[txgoff])) {
 		dsl_sync_task_nowait(dmu_tx_pool(tx),
 		    spa_condense_indirect_commit_sync, sci, tx);
 	}
 
 	vdev_indirect_mapping_entry_t *vime =
 	    kmem_alloc(sizeof (*vime), KM_SLEEP);
 	vime->vime_mapping = *vimep;
 	vime->vime_obsolete_count = count;
 	list_insert_tail(&sci->sci_new_mapping_entries[txgoff], vime);
 
 	dmu_tx_commit(tx);
 }
 
 static void
 spa_condense_indirect_generate_new_mapping(vdev_t *vd,
     uint32_t *obsolete_counts, uint64_t start_index, zthr_t *zthr)
 {
 	spa_t *spa = vd->vdev_spa;
 	uint64_t mapi = start_index;
 	vdev_indirect_mapping_t *old_mapping = vd->vdev_indirect_mapping;
 	uint64_t old_num_entries =
 	    vdev_indirect_mapping_num_entries(old_mapping);
 
 	ASSERT3P(vd->vdev_ops, ==, &vdev_indirect_ops);
 	ASSERT3U(vd->vdev_id, ==, spa->spa_condensing_indirect_phys.scip_vdev);
 
 	zfs_dbgmsg("starting condense of vdev %llu from index %llu",
 	    (u_longlong_t)vd->vdev_id,
 	    (u_longlong_t)mapi);
 
 	while (mapi < old_num_entries) {
 
 		if (zthr_iscancelled(zthr)) {
 			zfs_dbgmsg("pausing condense of vdev %llu "
 			    "at index %llu", (u_longlong_t)vd->vdev_id,
 			    (u_longlong_t)mapi);
 			break;
 		}
 
 		vdev_indirect_mapping_entry_phys_t *entry =
 		    &old_mapping->vim_entries[mapi];
 		uint64_t entry_size = DVA_GET_ASIZE(&entry->vimep_dst);
 		ASSERT3U(obsolete_counts[mapi], <=, entry_size);
 		if (obsolete_counts[mapi] < entry_size) {
 			spa_condense_indirect_commit_entry(spa, entry,
 			    obsolete_counts[mapi]);
 
 			/*
 			 * This delay may be requested for testing, debugging,
 			 * or performance reasons.
 			 */
 			hrtime_t now = gethrtime();
 			hrtime_t sleep_until = now + MSEC2NSEC(
 			    zfs_condense_indirect_commit_entry_delay_ms);
 			zfs_sleep_until(sleep_until);
 		}
 
 		mapi++;
 	}
 }
 
 static boolean_t
 spa_condense_indirect_thread_check(void *arg, zthr_t *zthr)
 {
 	(void) zthr;
 	spa_t *spa = arg;
 
 	return (spa->spa_condensing_indirect != NULL);
 }
 
 static void
 spa_condense_indirect_thread(void *arg, zthr_t *zthr)
 {
 	spa_t *spa = arg;
 	vdev_t *vd;
 
 	ASSERT3P(spa->spa_condensing_indirect, !=, NULL);
 	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
 	vd = vdev_lookup_top(spa, spa->spa_condensing_indirect_phys.scip_vdev);
 	ASSERT3P(vd, !=, NULL);
 	spa_config_exit(spa, SCL_VDEV, FTAG);
 
 	spa_condensing_indirect_t *sci = spa->spa_condensing_indirect;
 	spa_condensing_indirect_phys_t *scip =
 	    &spa->spa_condensing_indirect_phys;
 	uint32_t *counts;
 	uint64_t start_index;
 	vdev_indirect_mapping_t *old_mapping = vd->vdev_indirect_mapping;
 	space_map_t *prev_obsolete_sm = NULL;
 
 	ASSERT3U(vd->vdev_id, ==, scip->scip_vdev);
 	ASSERT(scip->scip_next_mapping_object != 0);
 	ASSERT(scip->scip_prev_obsolete_sm_object != 0);
 	ASSERT3P(vd->vdev_ops, ==, &vdev_indirect_ops);
 
 	for (int i = 0; i < TXG_SIZE; i++) {
 		/*
 		 * The list must start out empty in order for the
 		 * _commit_sync() sync task to be properly registered
 		 * on the first call to _commit_entry(); so it's wise
 		 * to double check and ensure we actually are starting
 		 * with empty lists.
 		 */
 		ASSERT(list_is_empty(&sci->sci_new_mapping_entries[i]));
 	}
 
 	VERIFY0(space_map_open(&prev_obsolete_sm, spa->spa_meta_objset,
 	    scip->scip_prev_obsolete_sm_object, 0, vd->vdev_asize, 0));
 	counts = vdev_indirect_mapping_load_obsolete_counts(old_mapping);
 	if (prev_obsolete_sm != NULL) {
 		vdev_indirect_mapping_load_obsolete_spacemap(old_mapping,
 		    counts, prev_obsolete_sm);
 	}
 	space_map_close(prev_obsolete_sm);
 
 	/*
 	 * Generate new mapping.  Determine what index to continue from
 	 * based on the max offset that we've already written in the
 	 * new mapping.
 	 */
 	uint64_t max_offset =
 	    vdev_indirect_mapping_max_offset(sci->sci_new_mapping);
 	if (max_offset == 0) {
 		/* We haven't written anything to the new mapping yet. */
 		start_index = 0;
 	} else {
 		/*
 		 * Pick up from where we left off. _entry_for_offset()
 		 * returns a pointer into the vim_entries array. If
 		 * max_offset is greater than any of the mappings
 		 * contained in the table  NULL will be returned and
 		 * that indicates we've exhausted our iteration of the
 		 * old_mapping.
 		 */
 
 		vdev_indirect_mapping_entry_phys_t *entry =
 		    vdev_indirect_mapping_entry_for_offset_or_next(old_mapping,
 		    max_offset);
 
 		if (entry == NULL) {
 			/*
 			 * We've already written the whole new mapping.
 			 * This special value will cause us to skip the
 			 * generate_new_mapping step and just do the sync
 			 * task to complete the condense.
 			 */
 			start_index = UINT64_MAX;
 		} else {
 			start_index = entry - old_mapping->vim_entries;
 			ASSERT3U(start_index, <,
 			    vdev_indirect_mapping_num_entries(old_mapping));
 		}
 	}
 
 	spa_condense_indirect_generate_new_mapping(vd, counts,
 	    start_index, zthr);
 
 	vdev_indirect_mapping_free_obsolete_counts(old_mapping, counts);
 
 	/*
 	 * If the zthr has received a cancellation signal while running
 	 * in generate_new_mapping() or at any point after that, then bail
 	 * early. We don't want to complete the condense if the spa is
 	 * shutting down.
 	 */
 	if (zthr_iscancelled(zthr))
 		return;
 
 	VERIFY0(dsl_sync_task(spa_name(spa), NULL,
 	    spa_condense_indirect_complete_sync, sci, 0,
 	    ZFS_SPACE_CHECK_EXTRA_RESERVED));
 }
 
 /*
  * Sync task to begin the condensing process.
  */
 void
 spa_condense_indirect_start_sync(vdev_t *vd, dmu_tx_t *tx)
 {
 	spa_t *spa = vd->vdev_spa;
 	spa_condensing_indirect_phys_t *scip =
 	    &spa->spa_condensing_indirect_phys;
 
 	ASSERT0(scip->scip_next_mapping_object);
 	ASSERT0(scip->scip_prev_obsolete_sm_object);
 	ASSERT0(scip->scip_vdev);
 	ASSERT(dmu_tx_is_syncing(tx));
 	ASSERT3P(vd->vdev_ops, ==, &vdev_indirect_ops);
 	ASSERT(spa_feature_is_active(spa, SPA_FEATURE_OBSOLETE_COUNTS));
 	ASSERT(vdev_indirect_mapping_num_entries(vd->vdev_indirect_mapping));
 
 	uint64_t obsolete_sm_obj;
 	VERIFY0(vdev_obsolete_sm_object(vd, &obsolete_sm_obj));
 	ASSERT3U(obsolete_sm_obj, !=, 0);
 
 	scip->scip_vdev = vd->vdev_id;
 	scip->scip_next_mapping_object =
 	    vdev_indirect_mapping_alloc(spa->spa_meta_objset, tx);
 
 	scip->scip_prev_obsolete_sm_object = obsolete_sm_obj;
 
 	/*
 	 * We don't need to allocate a new space map object, since
 	 * vdev_indirect_sync_obsolete will allocate one when needed.
 	 */
 	space_map_close(vd->vdev_obsolete_sm);
 	vd->vdev_obsolete_sm = NULL;
 	VERIFY0(zap_remove(spa->spa_meta_objset, vd->vdev_top_zap,
 	    VDEV_TOP_ZAP_INDIRECT_OBSOLETE_SM, tx));
 
 	VERIFY0(zap_add(spa->spa_dsl_pool->dp_meta_objset,
 	    DMU_POOL_DIRECTORY_OBJECT,
 	    DMU_POOL_CONDENSING_INDIRECT, sizeof (uint64_t),
 	    sizeof (*scip) / sizeof (uint64_t), scip, tx));
 
 	ASSERT3P(spa->spa_condensing_indirect, ==, NULL);
 	spa->spa_condensing_indirect = spa_condensing_indirect_create(spa);
 
 	zfs_dbgmsg("starting condense of vdev %llu in txg %llu: "
 	    "posm=%llu nm=%llu",
 	    (u_longlong_t)vd->vdev_id, (u_longlong_t)dmu_tx_get_txg(tx),
 	    (u_longlong_t)scip->scip_prev_obsolete_sm_object,
 	    (u_longlong_t)scip->scip_next_mapping_object);
 
 	zthr_wakeup(spa->spa_condense_zthr);
 }
 
 /*
  * Sync to the given vdev's obsolete space map any segments that are no longer
  * referenced as of the given txg.
  *
  * If the obsolete space map doesn't exist yet, create and open it.
  */
 void
 vdev_indirect_sync_obsolete(vdev_t *vd, dmu_tx_t *tx)
 {
 	spa_t *spa = vd->vdev_spa;
 	vdev_indirect_config_t *vic __maybe_unused = &vd->vdev_indirect_config;
 
 	ASSERT3U(vic->vic_mapping_object, !=, 0);
 	ASSERT(range_tree_space(vd->vdev_obsolete_segments) > 0);
 	ASSERT(vd->vdev_removing || vd->vdev_ops == &vdev_indirect_ops);
 	ASSERT(spa_feature_is_enabled(spa, SPA_FEATURE_OBSOLETE_COUNTS));
 
 	uint64_t obsolete_sm_object;
 	VERIFY0(vdev_obsolete_sm_object(vd, &obsolete_sm_object));
 	if (obsolete_sm_object == 0) {
 		obsolete_sm_object = space_map_alloc(spa->spa_meta_objset,
 		    zfs_vdev_standard_sm_blksz, tx);
 
 		ASSERT(vd->vdev_top_zap != 0);
 		VERIFY0(zap_add(vd->vdev_spa->spa_meta_objset, vd->vdev_top_zap,
 		    VDEV_TOP_ZAP_INDIRECT_OBSOLETE_SM,
 		    sizeof (obsolete_sm_object), 1, &obsolete_sm_object, tx));
 		ASSERT0(vdev_obsolete_sm_object(vd, &obsolete_sm_object));
 		ASSERT3U(obsolete_sm_object, !=, 0);
 
 		spa_feature_incr(spa, SPA_FEATURE_OBSOLETE_COUNTS, tx);
 		VERIFY0(space_map_open(&vd->vdev_obsolete_sm,
 		    spa->spa_meta_objset, obsolete_sm_object,
 		    0, vd->vdev_asize, 0));
 	}
 
 	ASSERT(vd->vdev_obsolete_sm != NULL);
 	ASSERT3U(obsolete_sm_object, ==,
 	    space_map_object(vd->vdev_obsolete_sm));
 
 	space_map_write(vd->vdev_obsolete_sm,
 	    vd->vdev_obsolete_segments, SM_ALLOC, SM_NO_VDEVID, tx);
 	range_tree_vacate(vd->vdev_obsolete_segments, NULL, NULL);
 }
 
 int
 spa_condense_init(spa_t *spa)
 {
 	int error = zap_lookup(spa->spa_meta_objset,
 	    DMU_POOL_DIRECTORY_OBJECT,
 	    DMU_POOL_CONDENSING_INDIRECT, sizeof (uint64_t),
 	    sizeof (spa->spa_condensing_indirect_phys) / sizeof (uint64_t),
 	    &spa->spa_condensing_indirect_phys);
 	if (error == 0) {
 		if (spa_writeable(spa)) {
 			spa->spa_condensing_indirect =
 			    spa_condensing_indirect_create(spa);
 		}
 		return (0);
 	} else if (error == ENOENT) {
 		return (0);
 	} else {
 		return (error);
 	}
 }
 
 void
 spa_condense_fini(spa_t *spa)
 {
 	if (spa->spa_condensing_indirect != NULL) {
 		spa_condensing_indirect_destroy(spa->spa_condensing_indirect);
 		spa->spa_condensing_indirect = NULL;
 	}
 }
 
 void
 spa_start_indirect_condensing_thread(spa_t *spa)
 {
 	ASSERT3P(spa->spa_condense_zthr, ==, NULL);
 	spa->spa_condense_zthr = zthr_create("z_indirect_condense",
 	    spa_condense_indirect_thread_check,
 	    spa_condense_indirect_thread, spa, minclsyspri);
 }
 
 /*
  * Gets the obsolete spacemap object from the vdev's ZAP.  On success sm_obj
  * will contain either the obsolete spacemap object or zero if none exists.
  * All other errors are returned to the caller.
  */
 int
 vdev_obsolete_sm_object(vdev_t *vd, uint64_t *sm_obj)
 {
 	ASSERT0(spa_config_held(vd->vdev_spa, SCL_ALL, RW_WRITER));
 
 	if (vd->vdev_top_zap == 0) {
 		*sm_obj = 0;
 		return (0);
 	}
 
 	int error = zap_lookup(vd->vdev_spa->spa_meta_objset, vd->vdev_top_zap,
 	    VDEV_TOP_ZAP_INDIRECT_OBSOLETE_SM, sizeof (uint64_t), 1, sm_obj);
 	if (error == ENOENT) {
 		*sm_obj = 0;
 		error = 0;
 	}
 
 	return (error);
 }
 
 /*
  * Gets the obsolete count are precise spacemap object from the vdev's ZAP.
  * On success are_precise will be set to reflect if the counts are precise.
  * All other errors are returned to the caller.
  */
 int
 vdev_obsolete_counts_are_precise(vdev_t *vd, boolean_t *are_precise)
 {
 	ASSERT0(spa_config_held(vd->vdev_spa, SCL_ALL, RW_WRITER));
 
 	if (vd->vdev_top_zap == 0) {
 		*are_precise = B_FALSE;
 		return (0);
 	}
 
 	uint64_t val = 0;
 	int error = zap_lookup(vd->vdev_spa->spa_meta_objset, vd->vdev_top_zap,
 	    VDEV_TOP_ZAP_OBSOLETE_COUNTS_ARE_PRECISE, sizeof (val), 1, &val);
 	if (error == 0) {
 		*are_precise = (val != 0);
 	} else if (error == ENOENT) {
 		*are_precise = B_FALSE;
 		error = 0;
 	}
 
 	return (error);
 }
 
 static void
 vdev_indirect_close(vdev_t *vd)
 {
 	(void) vd;
 }
 
 static int
 vdev_indirect_open(vdev_t *vd, uint64_t *psize, uint64_t *max_psize,
     uint64_t *logical_ashift, uint64_t *physical_ashift)
 {
 	*psize = *max_psize = vd->vdev_asize +
 	    VDEV_LABEL_START_SIZE + VDEV_LABEL_END_SIZE;
 	*logical_ashift = vd->vdev_ashift;
 	*physical_ashift = vd->vdev_physical_ashift;
 	return (0);
 }
 
 typedef struct remap_segment {
 	vdev_t *rs_vd;
 	uint64_t rs_offset;
 	uint64_t rs_asize;
 	uint64_t rs_split_offset;
 	list_node_t rs_node;
 } remap_segment_t;
 
 static remap_segment_t *
 rs_alloc(vdev_t *vd, uint64_t offset, uint64_t asize, uint64_t split_offset)
 {
 	remap_segment_t *rs = kmem_alloc(sizeof (remap_segment_t), KM_SLEEP);
 	rs->rs_vd = vd;
 	rs->rs_offset = offset;
 	rs->rs_asize = asize;
 	rs->rs_split_offset = split_offset;
 	return (rs);
 }
 
 /*
  * Given an indirect vdev and an extent on that vdev, it duplicates the
  * physical entries of the indirect mapping that correspond to the extent
  * to a new array and returns a pointer to it. In addition, copied_entries
  * is populated with the number of mapping entries that were duplicated.
  *
  * Note that the function assumes that the caller holds vdev_indirect_rwlock.
  * This ensures that the mapping won't change due to condensing as we
  * copy over its contents.
  *
  * Finally, since we are doing an allocation, it is up to the caller to
  * free the array allocated in this function.
  */
 static vdev_indirect_mapping_entry_phys_t *
 vdev_indirect_mapping_duplicate_adjacent_entries(vdev_t *vd, uint64_t offset,
     uint64_t asize, uint64_t *copied_entries)
 {
 	vdev_indirect_mapping_entry_phys_t *duplicate_mappings = NULL;
 	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
 	uint64_t entries = 0;
 
 	ASSERT(RW_READ_HELD(&vd->vdev_indirect_rwlock));
 
 	vdev_indirect_mapping_entry_phys_t *first_mapping =
 	    vdev_indirect_mapping_entry_for_offset(vim, offset);
 	ASSERT3P(first_mapping, !=, NULL);
 
 	vdev_indirect_mapping_entry_phys_t *m = first_mapping;
 	while (asize > 0) {
 		uint64_t size = DVA_GET_ASIZE(&m->vimep_dst);
 
 		ASSERT3U(offset, >=, DVA_MAPPING_GET_SRC_OFFSET(m));
 		ASSERT3U(offset, <, DVA_MAPPING_GET_SRC_OFFSET(m) + size);
 
 		uint64_t inner_offset = offset - DVA_MAPPING_GET_SRC_OFFSET(m);
 		uint64_t inner_size = MIN(asize, size - inner_offset);
 
 		offset += inner_size;
 		asize -= inner_size;
 		entries++;
 		m++;
 	}
 
 	size_t copy_length = entries * sizeof (*first_mapping);
 	duplicate_mappings = kmem_alloc(copy_length, KM_SLEEP);
 	memcpy(duplicate_mappings, first_mapping, copy_length);
 	*copied_entries = entries;
 
 	return (duplicate_mappings);
 }
 
 /*
  * Goes through the relevant indirect mappings until it hits a concrete vdev
  * and issues the callback. On the way to the concrete vdev, if any other
  * indirect vdevs are encountered, then the callback will also be called on
  * each of those indirect vdevs. For example, if the segment is mapped to
  * segment A on indirect vdev 1, and then segment A on indirect vdev 1 is
  * mapped to segment B on concrete vdev 2, then the callback will be called on
  * both vdev 1 and vdev 2.
  *
  * While the callback passed to vdev_indirect_remap() is called on every vdev
  * the function encounters, certain callbacks only care about concrete vdevs.
  * These types of callbacks should return immediately and explicitly when they
  * are called on an indirect vdev.
  *
  * Because there is a possibility that a DVA section in the indirect device
  * has been split into multiple sections in our mapping, we keep track
  * of the relevant contiguous segments of the new location (remap_segment_t)
  * in a stack. This way we can call the callback for each of the new sections
  * created by a single section of the indirect device. Note though, that in
  * this scenario the callbacks in each split block won't occur in-order in
  * terms of offset, so callers should not make any assumptions about that.
  *
  * For callbacks that don't handle split blocks and immediately return when
  * they encounter them (as is the case for remap_blkptr_cb), the caller can
  * assume that its callback will be applied from the first indirect vdev
  * encountered to the last one and then the concrete vdev, in that order.
  */
 static void
 vdev_indirect_remap(vdev_t *vd, uint64_t offset, uint64_t asize,
     void (*func)(uint64_t, vdev_t *, uint64_t, uint64_t, void *), void *arg)
 {
 	list_t stack;
 	spa_t *spa = vd->vdev_spa;
 
 	list_create(&stack, sizeof (remap_segment_t),
 	    offsetof(remap_segment_t, rs_node));
 
 	for (remap_segment_t *rs = rs_alloc(vd, offset, asize, 0);
 	    rs != NULL; rs = list_remove_head(&stack)) {
 		vdev_t *v = rs->rs_vd;
 		uint64_t num_entries = 0;
 
 		ASSERT(spa_config_held(spa, SCL_ALL, RW_READER) != 0);
 		ASSERT(rs->rs_asize > 0);
 
 		/*
 		 * Note: As this function can be called from open context
 		 * (e.g. zio_read()), we need the following rwlock to
 		 * prevent the mapping from being changed by condensing.
 		 *
 		 * So we grab the lock and we make a copy of the entries
 		 * that are relevant to the extent that we are working on.
 		 * Once that is done, we drop the lock and iterate over
 		 * our copy of the mapping. Once we are done with the with
 		 * the remap segment and we free it, we also free our copy
 		 * of the indirect mapping entries that are relevant to it.
 		 *
 		 * This way we don't need to wait until the function is
 		 * finished with a segment, to condense it. In addition, we
 		 * don't need a recursive rwlock for the case that a call to
 		 * vdev_indirect_remap() needs to call itself (through the
 		 * codepath of its callback) for the same vdev in the middle
 		 * of its execution.
 		 */
 		rw_enter(&v->vdev_indirect_rwlock, RW_READER);
 		ASSERT3P(v->vdev_indirect_mapping, !=, NULL);
 
 		vdev_indirect_mapping_entry_phys_t *mapping =
 		    vdev_indirect_mapping_duplicate_adjacent_entries(v,
 		    rs->rs_offset, rs->rs_asize, &num_entries);
 		ASSERT3P(mapping, !=, NULL);
 		ASSERT3U(num_entries, >, 0);
 		rw_exit(&v->vdev_indirect_rwlock);
 
 		for (uint64_t i = 0; i < num_entries; i++) {
 			/*
 			 * Note: the vdev_indirect_mapping can not change
 			 * while we are running.  It only changes while the
 			 * removal is in progress, and then only from syncing
 			 * context. While a removal is in progress, this
 			 * function is only called for frees, which also only
 			 * happen from syncing context.
 			 */
 			vdev_indirect_mapping_entry_phys_t *m = &mapping[i];
 
 			ASSERT3P(m, !=, NULL);
 			ASSERT3U(rs->rs_asize, >, 0);
 
 			uint64_t size = DVA_GET_ASIZE(&m->vimep_dst);
 			uint64_t dst_offset = DVA_GET_OFFSET(&m->vimep_dst);
 			uint64_t dst_vdev = DVA_GET_VDEV(&m->vimep_dst);
 
 			ASSERT3U(rs->rs_offset, >=,
 			    DVA_MAPPING_GET_SRC_OFFSET(m));
 			ASSERT3U(rs->rs_offset, <,
 			    DVA_MAPPING_GET_SRC_OFFSET(m) + size);
 			ASSERT3U(dst_vdev, !=, v->vdev_id);
 
 			uint64_t inner_offset = rs->rs_offset -
 			    DVA_MAPPING_GET_SRC_OFFSET(m);
 			uint64_t inner_size =
 			    MIN(rs->rs_asize, size - inner_offset);
 
 			vdev_t *dst_v = vdev_lookup_top(spa, dst_vdev);
 			ASSERT3P(dst_v, !=, NULL);
 
 			if (dst_v->vdev_ops == &vdev_indirect_ops) {
 				list_insert_head(&stack,
 				    rs_alloc(dst_v, dst_offset + inner_offset,
 				    inner_size, rs->rs_split_offset));
 
 			}
 
 			if ((zfs_flags & ZFS_DEBUG_INDIRECT_REMAP) &&
 			    IS_P2ALIGNED(inner_size, 2 * SPA_MINBLOCKSIZE)) {
 				/*
 				 * Note: This clause exists only solely for
 				 * testing purposes. We use it to ensure that
 				 * split blocks work and that the callbacks
 				 * using them yield the same result if issued
 				 * in reverse order.
 				 */
 				uint64_t inner_half = inner_size / 2;
 
 				func(rs->rs_split_offset + inner_half, dst_v,
 				    dst_offset + inner_offset + inner_half,
 				    inner_half, arg);
 
 				func(rs->rs_split_offset, dst_v,
 				    dst_offset + inner_offset,
 				    inner_half, arg);
 			} else {
 				func(rs->rs_split_offset, dst_v,
 				    dst_offset + inner_offset,
 				    inner_size, arg);
 			}
 
 			rs->rs_offset += inner_size;
 			rs->rs_asize -= inner_size;
 			rs->rs_split_offset += inner_size;
 		}
 		VERIFY0(rs->rs_asize);
 
 		kmem_free(mapping, num_entries * sizeof (*mapping));
 		kmem_free(rs, sizeof (remap_segment_t));
 	}
 	list_destroy(&stack);
 }
 
 static void
 vdev_indirect_child_io_done(zio_t *zio)
 {
 	zio_t *pio = zio->io_private;
 
 	mutex_enter(&pio->io_lock);
 	pio->io_error = zio_worst_error(pio->io_error, zio->io_error);
 	mutex_exit(&pio->io_lock);
 
 	abd_free(zio->io_abd);
 }
 
 /*
  * This is a callback for vdev_indirect_remap() which allocates an
  * indirect_split_t for each split segment and adds it to iv_splits.
  */
 static void
 vdev_indirect_gather_splits(uint64_t split_offset, vdev_t *vd, uint64_t offset,
     uint64_t size, void *arg)
 {
 	zio_t *zio = arg;
 	indirect_vsd_t *iv = zio->io_vsd;
 
 	ASSERT3P(vd, !=, NULL);
 
 	if (vd->vdev_ops == &vdev_indirect_ops)
 		return;
 
 	int n = 1;
 	if (vd->vdev_ops == &vdev_mirror_ops)
 		n = vd->vdev_children;
 
 	indirect_split_t *is =
 	    kmem_zalloc(offsetof(indirect_split_t, is_child[n]), KM_SLEEP);
 
 	is->is_children = n;
 	is->is_size = size;
 	is->is_split_offset = split_offset;
 	is->is_target_offset = offset;
 	is->is_vdev = vd;
 	list_create(&is->is_unique_child, sizeof (indirect_child_t),
 	    offsetof(indirect_child_t, ic_node));
 
 	/*
 	 * Note that we only consider multiple copies of the data for
 	 * *mirror* vdevs.  We don't for "replacing" or "spare" vdevs, even
 	 * though they use the same ops as mirror, because there's only one
 	 * "good" copy under the replacing/spare.
 	 */
 	if (vd->vdev_ops == &vdev_mirror_ops) {
 		for (int i = 0; i < n; i++) {
 			is->is_child[i].ic_vdev = vd->vdev_child[i];
 			list_link_init(&is->is_child[i].ic_node);
 		}
 	} else {
 		is->is_child[0].ic_vdev = vd;
 	}
 
 	list_insert_tail(&iv->iv_splits, is);
 }
 
 static void
 vdev_indirect_read_split_done(zio_t *zio)
 {
 	indirect_child_t *ic = zio->io_private;
 
 	if (zio->io_error != 0) {
 		/*
 		 * Clear ic_data to indicate that we do not have data for this
 		 * child.
 		 */
 		abd_free(ic->ic_data);
 		ic->ic_data = NULL;
 	}
 }
 
 /*
  * Issue reads for all copies (mirror children) of all splits.
  */
 static void
 vdev_indirect_read_all(zio_t *zio)
 {
 	indirect_vsd_t *iv = zio->io_vsd;
 
 	ASSERT3U(zio->io_type, ==, ZIO_TYPE_READ);
 
 	for (indirect_split_t *is = list_head(&iv->iv_splits);
 	    is != NULL; is = list_next(&iv->iv_splits, is)) {
 		for (int i = 0; i < is->is_children; i++) {
 			indirect_child_t *ic = &is->is_child[i];
 
 			if (!vdev_readable(ic->ic_vdev))
 				continue;
 
 			/*
 			 * If a child is missing the data, set ic_error. Used
 			 * in vdev_indirect_repair(). We perform the read
 			 * nevertheless which provides the opportunity to
 			 * reconstruct the split block if at all possible.
 			 */
 			if (vdev_dtl_contains(ic->ic_vdev, DTL_MISSING,
 			    zio->io_txg, 1))
 				ic->ic_error = SET_ERROR(ESTALE);
 
 			ic->ic_data = abd_alloc_sametype(zio->io_abd,
 			    is->is_size);
 			ic->ic_duplicate = NULL;
 
 			zio_nowait(zio_vdev_child_io(zio, NULL,
 			    ic->ic_vdev, is->is_target_offset, ic->ic_data,
 			    is->is_size, zio->io_type, zio->io_priority, 0,
 			    vdev_indirect_read_split_done, ic));
 		}
 	}
 	iv->iv_reconstruct = B_TRUE;
 }
 
 static void
 vdev_indirect_io_start(zio_t *zio)
 {
 	spa_t *spa __maybe_unused = zio->io_spa;
 	indirect_vsd_t *iv = kmem_zalloc(sizeof (*iv), KM_SLEEP);
 	list_create(&iv->iv_splits,
 	    sizeof (indirect_split_t), offsetof(indirect_split_t, is_node));
 
 	zio->io_vsd = iv;
 	zio->io_vsd_ops = &vdev_indirect_vsd_ops;
 
 	ASSERT(spa_config_held(spa, SCL_ALL, RW_READER) != 0);
 	if (zio->io_type != ZIO_TYPE_READ) {
 		ASSERT3U(zio->io_type, ==, ZIO_TYPE_WRITE);
 		/*
 		 * Note: this code can handle other kinds of writes,
 		 * but we don't expect them.
 		 */
 		ASSERT((zio->io_flags & (ZIO_FLAG_SELF_HEAL |
 		    ZIO_FLAG_RESILVER | ZIO_FLAG_INDUCE_DAMAGE)) != 0);
 	}
 
 	vdev_indirect_remap(zio->io_vd, zio->io_offset, zio->io_size,
 	    vdev_indirect_gather_splits, zio);
 
 	indirect_split_t *first = list_head(&iv->iv_splits);
 	ASSERT3P(first, !=, NULL);
 	if (first->is_size == zio->io_size) {
 		/*
 		 * This is not a split block; we are pointing to the entire
 		 * data, which will checksum the same as the original data.
 		 * Pass the BP down so that the child i/o can verify the
 		 * checksum, and try a different location if available
 		 * (e.g. on a mirror).
 		 *
 		 * While this special case could be handled the same as the
 		 * general (split block) case, doing it this way ensures
 		 * that the vast majority of blocks on indirect vdevs
 		 * (which are not split) are handled identically to blocks
 		 * on non-indirect vdevs.  This allows us to be less strict
 		 * about performance in the general (but rare) case.
 		 */
 		ASSERT0(first->is_split_offset);
 		ASSERT3P(list_next(&iv->iv_splits, first), ==, NULL);
 		zio_nowait(zio_vdev_child_io(zio, zio->io_bp,
 		    first->is_vdev, first->is_target_offset,
 		    abd_get_offset(zio->io_abd, 0),
 		    zio->io_size, zio->io_type, zio->io_priority, 0,
 		    vdev_indirect_child_io_done, zio));
 	} else {
 		iv->iv_split_block = B_TRUE;
 		if (zio->io_type == ZIO_TYPE_READ &&
 		    zio->io_flags & (ZIO_FLAG_SCRUB | ZIO_FLAG_RESILVER)) {
 			/*
 			 * Read all copies.  Note that for simplicity,
 			 * we don't bother consulting the DTL in the
 			 * resilver case.
 			 */
 			vdev_indirect_read_all(zio);
 		} else {
 			/*
 			 * If this is a read zio, we read one copy of each
 			 * split segment, from the top-level vdev.  Since
 			 * we don't know the checksum of each split
 			 * individually, the child zio can't ensure that
 			 * we get the right data. E.g. if it's a mirror,
 			 * it will just read from a random (healthy) leaf
 			 * vdev. We have to verify the checksum in
 			 * vdev_indirect_io_done().
 			 *
 			 * For write zios, the vdev code will ensure we write
 			 * to all children.
 			 */
 			for (indirect_split_t *is = list_head(&iv->iv_splits);
 			    is != NULL; is = list_next(&iv->iv_splits, is)) {
 				zio_nowait(zio_vdev_child_io(zio, NULL,
 				    is->is_vdev, is->is_target_offset,
 				    abd_get_offset_size(zio->io_abd,
 				    is->is_split_offset, is->is_size),
 				    is->is_size, zio->io_type,
 				    zio->io_priority, 0,
 				    vdev_indirect_child_io_done, zio));
 			}
 
 		}
 	}
 
 	zio_execute(zio);
 }
 
 /*
  * Report a checksum error for a child.
  */
 static void
 vdev_indirect_checksum_error(zio_t *zio,
     indirect_split_t *is, indirect_child_t *ic)
 {
 	vdev_t *vd = ic->ic_vdev;
 
 	if (zio->io_flags & ZIO_FLAG_SPECULATIVE)
 		return;
 
 	mutex_enter(&vd->vdev_stat_lock);
 	vd->vdev_stat.vs_checksum_errors++;
 	mutex_exit(&vd->vdev_stat_lock);
 
 	zio_bad_cksum_t zbc = { 0 };
 	abd_t *bad_abd = ic->ic_data;
 	abd_t *good_abd = is->is_good_child->ic_data;
 	(void) zfs_ereport_post_checksum(zio->io_spa, vd, NULL, zio,
 	    is->is_target_offset, is->is_size, good_abd, bad_abd, &zbc);
 }
 
 /*
  * Issue repair i/os for any incorrect copies.  We do this by comparing
  * each split segment's correct data (is_good_child's ic_data) with each
  * other copy of the data.  If they differ, then we overwrite the bad data
  * with the good copy.  The DTL is checked in vdev_indirect_read_all() and
  * if a vdev is missing a copy of the data we set ic_error and the read is
  * performed. This provides the opportunity to reconstruct the split block
  * if at all possible. ic_error is checked here and if set it suppresses
  * incrementing the checksum counter. Aside from this DTLs are not checked,
  * which simplifies this code and also issues the optimal number of writes
  * (based on which copies actually read bad data, as opposed to which we
  * think might be wrong).  For the same reason, we always use
  * ZIO_FLAG_SELF_HEAL, to bypass the DTL check in zio_vdev_io_start().
  */
 static void
 vdev_indirect_repair(zio_t *zio)
 {
 	indirect_vsd_t *iv = zio->io_vsd;
 
 	if (!spa_writeable(zio->io_spa))
 		return;
 
 	for (indirect_split_t *is = list_head(&iv->iv_splits);
 	    is != NULL; is = list_next(&iv->iv_splits, is)) {
 		for (int c = 0; c < is->is_children; c++) {
 			indirect_child_t *ic = &is->is_child[c];
 			if (ic == is->is_good_child)
 				continue;
 			if (ic->ic_data == NULL)
 				continue;
 			if (ic->ic_duplicate == is->is_good_child)
 				continue;
 
 			zio_nowait(zio_vdev_child_io(zio, NULL,
 			    ic->ic_vdev, is->is_target_offset,
 			    is->is_good_child->ic_data, is->is_size,
 			    ZIO_TYPE_WRITE, ZIO_PRIORITY_ASYNC_WRITE,
 			    ZIO_FLAG_IO_REPAIR | ZIO_FLAG_SELF_HEAL,
 			    NULL, NULL));
 
 			/*
 			 * If ic_error is set the current child does not have
 			 * a copy of the data, so suppress incrementing the
 			 * checksum counter.
 			 */
 			if (ic->ic_error == ESTALE)
 				continue;
 
 			vdev_indirect_checksum_error(zio, is, ic);
 		}
 	}
 }
 
 /*
  * Report checksum errors on all children that we read from.
  */
 static void
 vdev_indirect_all_checksum_errors(zio_t *zio)
 {
 	indirect_vsd_t *iv = zio->io_vsd;
 
 	if (zio->io_flags & ZIO_FLAG_SPECULATIVE)
 		return;
 
 	for (indirect_split_t *is = list_head(&iv->iv_splits);
 	    is != NULL; is = list_next(&iv->iv_splits, is)) {
 		for (int c = 0; c < is->is_children; c++) {
 			indirect_child_t *ic = &is->is_child[c];
 
 			if (ic->ic_data == NULL)
 				continue;
 
 			vdev_t *vd = ic->ic_vdev;
 
 			mutex_enter(&vd->vdev_stat_lock);
 			vd->vdev_stat.vs_checksum_errors++;
 			mutex_exit(&vd->vdev_stat_lock);
 			(void) zfs_ereport_post_checksum(zio->io_spa, vd,
 			    NULL, zio, is->is_target_offset, is->is_size,
 			    NULL, NULL, NULL);
 		}
 	}
 }
 
 /*
  * Copy data from all the splits to a main zio then validate the checksum.
  * If then checksum is successfully validated return success.
  */
 static int
 vdev_indirect_splits_checksum_validate(indirect_vsd_t *iv, zio_t *zio)
 {
 	zio_bad_cksum_t zbc;
 
 	for (indirect_split_t *is = list_head(&iv->iv_splits);
 	    is != NULL; is = list_next(&iv->iv_splits, is)) {
 
 		ASSERT3P(is->is_good_child->ic_data, !=, NULL);
 		ASSERT3P(is->is_good_child->ic_duplicate, ==, NULL);
 
 		abd_copy_off(zio->io_abd, is->is_good_child->ic_data,
 		    is->is_split_offset, 0, is->is_size);
 	}
 
 	return (zio_checksum_error(zio, &zbc));
 }
 
 /*
  * There are relatively few possible combinations making it feasible to
  * deterministically check them all.  We do this by setting the good_child
  * to the next unique split version.  If we reach the end of the list then
  * "carry over" to the next unique split version (like counting in base
  * is_unique_children, but each digit can have a different base).
  */
 static int
 vdev_indirect_splits_enumerate_all(indirect_vsd_t *iv, zio_t *zio)
 {
 	boolean_t more = B_TRUE;
 
 	iv->iv_attempts = 0;
 
 	for (indirect_split_t *is = list_head(&iv->iv_splits);
 	    is != NULL; is = list_next(&iv->iv_splits, is))
 		is->is_good_child = list_head(&is->is_unique_child);
 
 	while (more == B_TRUE) {
 		iv->iv_attempts++;
 		more = B_FALSE;
 
 		if (vdev_indirect_splits_checksum_validate(iv, zio) == 0)
 			return (0);
 
 		for (indirect_split_t *is = list_head(&iv->iv_splits);
 		    is != NULL; is = list_next(&iv->iv_splits, is)) {
 			is->is_good_child = list_next(&is->is_unique_child,
 			    is->is_good_child);
 			if (is->is_good_child != NULL) {
 				more = B_TRUE;
 				break;
 			}
 
 			is->is_good_child = list_head(&is->is_unique_child);
 		}
 	}
 
 	ASSERT3S(iv->iv_attempts, <=, iv->iv_unique_combinations);
 
 	return (SET_ERROR(ECKSUM));
 }
 
 /*
  * There are too many combinations to try all of them in a reasonable amount
  * of time.  So try a fixed number of random combinations from the unique
  * split versions, after which we'll consider the block unrecoverable.
  */
 static int
 vdev_indirect_splits_enumerate_randomly(indirect_vsd_t *iv, zio_t *zio)
 {
 	iv->iv_attempts = 0;
 
 	while (iv->iv_attempts < iv->iv_attempts_max) {
 		iv->iv_attempts++;
 
 		for (indirect_split_t *is = list_head(&iv->iv_splits);
 		    is != NULL; is = list_next(&iv->iv_splits, is)) {
 			indirect_child_t *ic = list_head(&is->is_unique_child);
 			int children = is->is_unique_children;
 
 			for (int i = random_in_range(children); i > 0; i--)
 				ic = list_next(&is->is_unique_child, ic);
 
 			ASSERT3P(ic, !=, NULL);
 			is->is_good_child = ic;
 		}
 
 		if (vdev_indirect_splits_checksum_validate(iv, zio) == 0)
 			return (0);
 	}
 
 	return (SET_ERROR(ECKSUM));
 }
 
 /*
  * This is a validation function for reconstruction.  It randomly selects
  * a good combination, if one can be found, and then it intentionally
  * damages all other segment copes by zeroing them.  This forces the
  * reconstruction algorithm to locate the one remaining known good copy.
  */
 static int
 vdev_indirect_splits_damage(indirect_vsd_t *iv, zio_t *zio)
 {
 	int error;
 
 	/* Presume all the copies are unique for initial selection. */
 	for (indirect_split_t *is = list_head(&iv->iv_splits);
 	    is != NULL; is = list_next(&iv->iv_splits, is)) {
 		is->is_unique_children = 0;
 
 		for (int i = 0; i < is->is_children; i++) {
 			indirect_child_t *ic = &is->is_child[i];
 			if (ic->ic_data != NULL) {
 				is->is_unique_children++;
 				list_insert_tail(&is->is_unique_child, ic);
 			}
 		}
 
 		if (list_is_empty(&is->is_unique_child)) {
 			error = SET_ERROR(EIO);
 			goto out;
 		}
 	}
 
 	/*
 	 * Set each is_good_child to a randomly-selected child which
 	 * is known to contain validated data.
 	 */
 	error = vdev_indirect_splits_enumerate_randomly(iv, zio);
 	if (error)
 		goto out;
 
 	/*
 	 * Damage all but the known good copy by zeroing it.  This will
 	 * result in two or less unique copies per indirect_child_t.
 	 * Both may need to be checked in order to reconstruct the block.
 	 * Set iv->iv_attempts_max such that all unique combinations will
 	 * enumerated, but limit the damage to at most 12 indirect splits.
 	 */
 	iv->iv_attempts_max = 1;
 
 	for (indirect_split_t *is = list_head(&iv->iv_splits);
 	    is != NULL; is = list_next(&iv->iv_splits, is)) {
 		for (int c = 0; c < is->is_children; c++) {
 			indirect_child_t *ic = &is->is_child[c];
 
 			if (ic == is->is_good_child)
 				continue;
 			if (ic->ic_data == NULL)
 				continue;
 
 			abd_zero(ic->ic_data, abd_get_size(ic->ic_data));
 		}
 
 		iv->iv_attempts_max *= 2;
 		if (iv->iv_attempts_max >= (1ULL << 12)) {
 			iv->iv_attempts_max = UINT64_MAX;
 			break;
 		}
 	}
 
 out:
 	/* Empty the unique children lists so they can be reconstructed. */
 	for (indirect_split_t *is = list_head(&iv->iv_splits);
 	    is != NULL; is = list_next(&iv->iv_splits, is)) {
 		indirect_child_t *ic;
 		while ((ic = list_remove_head(&is->is_unique_child)) != NULL)
 			;
 
 		is->is_unique_children = 0;
 	}
 
 	return (error);
 }
 
 /*
  * This function is called when we have read all copies of the data and need
  * to try to find a combination of copies that gives us the right checksum.
  *
  * If we pointed to any mirror vdevs, this effectively does the job of the
  * mirror.  The mirror vdev code can't do its own job because we don't know
  * the checksum of each split segment individually.
  *
  * We have to try every unique combination of copies of split segments, until
  * we find one that checksums correctly.  Duplicate segment copies are first
  * identified and latter skipped during reconstruction.  This optimization
  * reduces the search space and ensures that of the remaining combinations
  * at most one is correct.
  *
  * When the total number of combinations is small they can all be checked.
  * For example, if we have 3 segments in the split, and each points to a
  * 2-way mirror with unique copies, we will have the following pieces of data:
  *
  *       |     mirror child
  * split |     [0]        [1]
  * ======|=====================
  *   A   |  data_A_0   data_A_1
  *   B   |  data_B_0   data_B_1
  *   C   |  data_C_0   data_C_1
  *
  * We will try the following (mirror children)^(number of splits) (2^3=8)
  * combinations, which is similar to bitwise-little-endian counting in
  * binary.  In general each "digit" corresponds to a split segment, and the
  * base of each digit is is_children, which can be different for each
  * digit.
  *
  * "low bit"        "high bit"
  *        v                 v
  * data_A_0 data_B_0 data_C_0
  * data_A_1 data_B_0 data_C_0
  * data_A_0 data_B_1 data_C_0
  * data_A_1 data_B_1 data_C_0
  * data_A_0 data_B_0 data_C_1
  * data_A_1 data_B_0 data_C_1
  * data_A_0 data_B_1 data_C_1
  * data_A_1 data_B_1 data_C_1
  *
  * Note that the split segments may be on the same or different top-level
  * vdevs. In either case, we may need to try lots of combinations (see
  * zfs_reconstruct_indirect_combinations_max).  This ensures that if a mirror
  * has small silent errors on all of its children, we can still reconstruct
  * the correct data, as long as those errors are at sufficiently-separated
  * offsets (specifically, separated by the largest block size - default of
  * 128KB, but up to 16MB).
  */
 static void
 vdev_indirect_reconstruct_io_done(zio_t *zio)
 {
 	indirect_vsd_t *iv = zio->io_vsd;
 	boolean_t known_good = B_FALSE;
 	int error;
 
 	iv->iv_unique_combinations = 1;
 	iv->iv_attempts_max = UINT64_MAX;
 
 	if (zfs_reconstruct_indirect_combinations_max > 0)
 		iv->iv_attempts_max = zfs_reconstruct_indirect_combinations_max;
 
 	/*
 	 * If nonzero, every 1/x blocks will be damaged, in order to validate
 	 * reconstruction when there are split segments with damaged copies.
 	 * Known_good will be TRUE when reconstruction is known to be possible.
 	 */
 	if (zfs_reconstruct_indirect_damage_fraction != 0 &&
 	    random_in_range(zfs_reconstruct_indirect_damage_fraction) == 0)
 		known_good = (vdev_indirect_splits_damage(iv, zio) == 0);
 
 	/*
 	 * Determine the unique children for a split segment and add them
 	 * to the is_unique_child list.  By restricting reconstruction
 	 * to these children, only unique combinations will be considered.
 	 * This can vastly reduce the search space when there are a large
 	 * number of indirect splits.
 	 */
 	for (indirect_split_t *is = list_head(&iv->iv_splits);
 	    is != NULL; is = list_next(&iv->iv_splits, is)) {
 		is->is_unique_children = 0;
 
 		for (int i = 0; i < is->is_children; i++) {
 			indirect_child_t *ic_i = &is->is_child[i];
 
 			if (ic_i->ic_data == NULL ||
 			    ic_i->ic_duplicate != NULL)
 				continue;
 
 			for (int j = i + 1; j < is->is_children; j++) {
 				indirect_child_t *ic_j = &is->is_child[j];
 
 				if (ic_j->ic_data == NULL ||
 				    ic_j->ic_duplicate != NULL)
 					continue;
 
 				if (abd_cmp(ic_i->ic_data, ic_j->ic_data) == 0)
 					ic_j->ic_duplicate = ic_i;
 			}
 
 			is->is_unique_children++;
 			list_insert_tail(&is->is_unique_child, ic_i);
 		}
 
 		/* Reconstruction is impossible, no valid children */
 		EQUIV(list_is_empty(&is->is_unique_child),
 		    is->is_unique_children == 0);
 		if (list_is_empty(&is->is_unique_child)) {
 			zio->io_error = EIO;
 			vdev_indirect_all_checksum_errors(zio);
 			zio_checksum_verified(zio);
 			return;
 		}
 
 		iv->iv_unique_combinations *= is->is_unique_children;
 	}
 
 	if (iv->iv_unique_combinations <= iv->iv_attempts_max)
 		error = vdev_indirect_splits_enumerate_all(iv, zio);
 	else
 		error = vdev_indirect_splits_enumerate_randomly(iv, zio);
 
 	if (error != 0) {
 		/* All attempted combinations failed. */
 		ASSERT3B(known_good, ==, B_FALSE);
 		zio->io_error = error;
 		vdev_indirect_all_checksum_errors(zio);
 	} else {
 		/*
 		 * The checksum has been successfully validated.  Issue
 		 * repair I/Os to any copies of splits which don't match
 		 * the validated version.
 		 */
 		ASSERT0(vdev_indirect_splits_checksum_validate(iv, zio));
 		vdev_indirect_repair(zio);
 		zio_checksum_verified(zio);
 	}
 }
 
 static void
 vdev_indirect_io_done(zio_t *zio)
 {
 	indirect_vsd_t *iv = zio->io_vsd;
 
 	if (iv->iv_reconstruct) {
 		/*
 		 * We have read all copies of the data (e.g. from mirrors),
 		 * either because this was a scrub/resilver, or because the
 		 * one-copy read didn't checksum correctly.
 		 */
 		vdev_indirect_reconstruct_io_done(zio);
 		return;
 	}
 
 	if (!iv->iv_split_block) {
 		/*
 		 * This was not a split block, so we passed the BP down,
 		 * and the checksum was handled by the (one) child zio.
 		 */
 		return;
 	}
 
 	zio_bad_cksum_t zbc;
 	int ret = zio_checksum_error(zio, &zbc);
+	/*
+	 * Any Direct I/O read that has a checksum error must be treated as
+	 * suspicious as the contents of the buffer could be getting
+	 * manipulated while the I/O is taking place. The checksum verify error
+	 * will be reported to the top-level VDEV.
+	 */
+	if (zio->io_flags & ZIO_FLAG_DIO_READ && ret == ECKSUM) {
+		zio->io_error = ret;
+		zio->io_flags |= ZIO_FLAG_DIO_CHKSUM_ERR;
+		zio_dio_chksum_verify_error_report(zio);
+		ret = 0;
+	}
+
 	if (ret == 0) {
 		zio_checksum_verified(zio);
 		return;
 	}
 
 	/*
 	 * The checksum didn't match.  Read all copies of all splits, and
 	 * then we will try to reconstruct.  The next time
 	 * vdev_indirect_io_done() is called, iv_reconstruct will be set.
 	 */
 	vdev_indirect_read_all(zio);
 
 	zio_vdev_io_redone(zio);
 }
 
 vdev_ops_t vdev_indirect_ops = {
 	.vdev_op_init = NULL,
 	.vdev_op_fini = NULL,
 	.vdev_op_open = vdev_indirect_open,
 	.vdev_op_close = vdev_indirect_close,
 	.vdev_op_asize = vdev_default_asize,
 	.vdev_op_min_asize = vdev_default_min_asize,
 	.vdev_op_min_alloc = NULL,
 	.vdev_op_io_start = vdev_indirect_io_start,
 	.vdev_op_io_done = vdev_indirect_io_done,
 	.vdev_op_state_change = NULL,
 	.vdev_op_need_resilver = NULL,
 	.vdev_op_hold = NULL,
 	.vdev_op_rele = NULL,
 	.vdev_op_remap = vdev_indirect_remap,
 	.vdev_op_xlate = NULL,
 	.vdev_op_rebuild_asize = NULL,
 	.vdev_op_metaslab_init = NULL,
 	.vdev_op_config_generate = NULL,
 	.vdev_op_nparity = NULL,
 	.vdev_op_ndisks = NULL,
 	.vdev_op_type = VDEV_TYPE_INDIRECT,	/* name of this vdev type */
 	.vdev_op_leaf = B_FALSE			/* leaf vdev */
 };
 
 EXPORT_SYMBOL(spa_condense_fini);
 EXPORT_SYMBOL(spa_start_indirect_condensing_thread);
 EXPORT_SYMBOL(spa_condense_indirect_start_sync);
 EXPORT_SYMBOL(spa_condense_init);
 EXPORT_SYMBOL(spa_vdev_indirect_mark_obsolete);
 EXPORT_SYMBOL(vdev_indirect_mark_obsolete);
 EXPORT_SYMBOL(vdev_indirect_should_condense);
 EXPORT_SYMBOL(vdev_indirect_sync_obsolete);
 EXPORT_SYMBOL(vdev_obsolete_counts_are_precise);
 EXPORT_SYMBOL(vdev_obsolete_sm_object);
 
 /* BEGIN CSTYLED */
 ZFS_MODULE_PARAM(zfs_condense, zfs_condense_, indirect_vdevs_enable, INT,
 	ZMOD_RW, "Whether to attempt condensing indirect vdev mappings");
 
 ZFS_MODULE_PARAM(zfs_condense, zfs_condense_, indirect_obsolete_pct, UINT,
 	ZMOD_RW,
 	"Minimum obsolete percent of bytes in the mapping "
 	"to attempt condensing");
 
 ZFS_MODULE_PARAM(zfs_condense, zfs_condense_, min_mapping_bytes, U64, ZMOD_RW,
 	"Don't bother condensing if the mapping uses less than this amount of "
 	"memory");
 
 ZFS_MODULE_PARAM(zfs_condense, zfs_condense_, max_obsolete_bytes, U64,
 	ZMOD_RW,
 	"Minimum size obsolete spacemap to attempt condensing");
 
 ZFS_MODULE_PARAM(zfs_condense, zfs_condense_, indirect_commit_entry_delay_ms,
 	UINT, ZMOD_RW,
 	"Used by tests to ensure certain actions happen in the middle of a "
 	"condense. A maximum value of 1 should be sufficient.");
 
 ZFS_MODULE_PARAM(zfs_reconstruct, zfs_reconstruct_, indirect_combinations_max,
 	UINT, ZMOD_RW,
 	"Maximum number of combinations when reconstructing split segments");
 /* END CSTYLED */
diff --git a/sys/contrib/openzfs/module/zfs/vdev_mirror.c b/sys/contrib/openzfs/module/zfs/vdev_mirror.c
index 102eacb03349..65a840bf9728 100644
--- a/sys/contrib/openzfs/module/zfs/vdev_mirror.c
+++ b/sys/contrib/openzfs/module/zfs/vdev_mirror.c
@@ -1,1040 +1,1061 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 /*
  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
  */
 
 /*
  * Copyright (c) 2012, 2015 by Delphix. All rights reserved.
  */
 
 #include <sys/zfs_context.h>
 #include <sys/spa.h>
 #include <sys/spa_impl.h>
 #include <sys/dsl_pool.h>
 #include <sys/dsl_scan.h>
 #include <sys/vdev_impl.h>
 #include <sys/vdev_draid.h>
 #include <sys/zio.h>
 #include <sys/zio_checksum.h>
 #include <sys/abd.h>
 #include <sys/fs/zfs.h>
 
 /*
  * Vdev mirror kstats
  */
 static kstat_t *mirror_ksp = NULL;
 
 typedef struct mirror_stats {
 	kstat_named_t vdev_mirror_stat_rotating_linear;
 	kstat_named_t vdev_mirror_stat_rotating_offset;
 	kstat_named_t vdev_mirror_stat_rotating_seek;
 	kstat_named_t vdev_mirror_stat_non_rotating_linear;
 	kstat_named_t vdev_mirror_stat_non_rotating_seek;
 
 	kstat_named_t vdev_mirror_stat_preferred_found;
 	kstat_named_t vdev_mirror_stat_preferred_not_found;
 } mirror_stats_t;
 
 static mirror_stats_t mirror_stats = {
 	/* New I/O follows directly the last I/O */
 	{ "rotating_linear",			KSTAT_DATA_UINT64 },
 	/* New I/O is within zfs_vdev_mirror_rotating_seek_offset of the last */
 	{ "rotating_offset",			KSTAT_DATA_UINT64 },
 	/* New I/O requires random seek */
 	{ "rotating_seek",			KSTAT_DATA_UINT64 },
 	/* New I/O follows directly the last I/O  (nonrot) */
 	{ "non_rotating_linear",		KSTAT_DATA_UINT64 },
 	/* New I/O requires random seek (nonrot) */
 	{ "non_rotating_seek",			KSTAT_DATA_UINT64 },
 	/* Preferred child vdev found */
 	{ "preferred_found",			KSTAT_DATA_UINT64 },
 	/* Preferred child vdev not found or equal load  */
 	{ "preferred_not_found",		KSTAT_DATA_UINT64 },
 
 };
 
 #define	MIRROR_STAT(stat)		(mirror_stats.stat.value.ui64)
 #define	MIRROR_INCR(stat, val) 		atomic_add_64(&MIRROR_STAT(stat), val)
 #define	MIRROR_BUMP(stat)		MIRROR_INCR(stat, 1)
 
 void
 vdev_mirror_stat_init(void)
 {
 	mirror_ksp = kstat_create("zfs", 0, "vdev_mirror_stats",
 	    "misc", KSTAT_TYPE_NAMED,
 	    sizeof (mirror_stats) / sizeof (kstat_named_t), KSTAT_FLAG_VIRTUAL);
 	if (mirror_ksp != NULL) {
 		mirror_ksp->ks_data = &mirror_stats;
 		kstat_install(mirror_ksp);
 	}
 }
 
 void
 vdev_mirror_stat_fini(void)
 {
 	if (mirror_ksp != NULL) {
 		kstat_delete(mirror_ksp);
 		mirror_ksp = NULL;
 	}
 }
 
 /*
  * Virtual device vector for mirroring.
  */
 typedef struct mirror_child {
 	vdev_t		*mc_vd;
 	abd_t		*mc_abd;
 	uint64_t	mc_offset;
 	int		mc_error;
 	int		mc_load;
 	uint8_t		mc_tried;
 	uint8_t		mc_skipped;
 	uint8_t		mc_speculative;
 	uint8_t		mc_rebuilding;
 } mirror_child_t;
 
 typedef struct mirror_map {
 	int		*mm_preferred;
 	int		mm_preferred_cnt;
 	int		mm_children;
 	boolean_t	mm_resilvering;
 	boolean_t	mm_rebuilding;
 	boolean_t	mm_root;
 	mirror_child_t	mm_child[];
 } mirror_map_t;
 
 static const int vdev_mirror_shift = 21;
 
 /*
  * The load configuration settings below are tuned by default for
  * the case where all devices are of the same rotational type.
  *
  * If there is a mixture of rotating and non-rotating media, setting
  * zfs_vdev_mirror_non_rotating_seek_inc to 0 may well provide better results
  * as it will direct more reads to the non-rotating vdevs which are more likely
  * to have a higher performance.
  */
 
 /* Rotating media load calculation configuration. */
 static int zfs_vdev_mirror_rotating_inc = 0;
 static int zfs_vdev_mirror_rotating_seek_inc = 5;
 static int zfs_vdev_mirror_rotating_seek_offset = 1 * 1024 * 1024;
 
 /* Non-rotating media load calculation configuration. */
 static int zfs_vdev_mirror_non_rotating_inc = 0;
 static int zfs_vdev_mirror_non_rotating_seek_inc = 1;
 
 static inline size_t
 vdev_mirror_map_size(int children)
 {
 	return (offsetof(mirror_map_t, mm_child[children]) +
 	    sizeof (int) * children);
 }
 
 static inline mirror_map_t *
 vdev_mirror_map_alloc(int children, boolean_t resilvering, boolean_t root)
 {
 	mirror_map_t *mm;
 
 	mm = kmem_zalloc(vdev_mirror_map_size(children), KM_SLEEP);
 	mm->mm_children = children;
 	mm->mm_resilvering = resilvering;
 	mm->mm_root = root;
 	mm->mm_preferred = (int *)((uintptr_t)mm +
 	    offsetof(mirror_map_t, mm_child[children]));
 
 	return (mm);
 }
 
 static void
 vdev_mirror_map_free(zio_t *zio)
 {
 	mirror_map_t *mm = zio->io_vsd;
 
 	kmem_free(mm, vdev_mirror_map_size(mm->mm_children));
 }
 
 static const zio_vsd_ops_t vdev_mirror_vsd_ops = {
 	.vsd_free = vdev_mirror_map_free,
 };
 
 static int
 vdev_mirror_load(mirror_map_t *mm, vdev_t *vd, uint64_t zio_offset)
 {
 	uint64_t last_offset;
 	int64_t offset_diff;
 	int load;
 
 	/* All DVAs have equal weight at the root. */
 	if (mm->mm_root)
 		return (INT_MAX);
 
 	/*
 	 * We don't return INT_MAX if the device is resilvering i.e.
 	 * vdev_resilver_txg != 0 as when tested performance was slightly
 	 * worse overall when resilvering with compared to without.
 	 */
 
 	/* Fix zio_offset for leaf vdevs */
 	if (vd->vdev_ops->vdev_op_leaf)
 		zio_offset += VDEV_LABEL_START_SIZE;
 
 	/* Standard load based on pending queue length. */
 	load = vdev_queue_length(vd);
 	last_offset = vdev_queue_last_offset(vd);
 
 	if (vd->vdev_nonrot) {
 		/* Non-rotating media. */
 		if (last_offset == zio_offset) {
 			MIRROR_BUMP(vdev_mirror_stat_non_rotating_linear);
 			return (load + zfs_vdev_mirror_non_rotating_inc);
 		}
 
 		/*
 		 * Apply a seek penalty even for non-rotating devices as
 		 * sequential I/O's can be aggregated into fewer operations on
 		 * the device, thus avoiding unnecessary per-command overhead
 		 * and boosting performance.
 		 */
 		MIRROR_BUMP(vdev_mirror_stat_non_rotating_seek);
 		return (load + zfs_vdev_mirror_non_rotating_seek_inc);
 	}
 
 	/* Rotating media I/O's which directly follow the last I/O. */
 	if (last_offset == zio_offset) {
 		MIRROR_BUMP(vdev_mirror_stat_rotating_linear);
 		return (load + zfs_vdev_mirror_rotating_inc);
 	}
 
 	/*
 	 * Apply half the seek increment to I/O's within seek offset
 	 * of the last I/O issued to this vdev as they should incur less
 	 * of a seek increment.
 	 */
 	offset_diff = (int64_t)(last_offset - zio_offset);
 	if (ABS(offset_diff) < zfs_vdev_mirror_rotating_seek_offset) {
 		MIRROR_BUMP(vdev_mirror_stat_rotating_offset);
 		return (load + (zfs_vdev_mirror_rotating_seek_inc / 2));
 	}
 
 	/* Apply the full seek increment to all other I/O's. */
 	MIRROR_BUMP(vdev_mirror_stat_rotating_seek);
 	return (load + zfs_vdev_mirror_rotating_seek_inc);
 }
 
 static boolean_t
 vdev_mirror_rebuilding(vdev_t *vd)
 {
 	if (vd->vdev_ops->vdev_op_leaf && vd->vdev_rebuild_txg)
 		return (B_TRUE);
 
 	for (int i = 0; i < vd->vdev_children; i++) {
 		if (vdev_mirror_rebuilding(vd->vdev_child[i])) {
 			return (B_TRUE);
 		}
 	}
 
 	return (B_FALSE);
 }
 
 /*
  * Avoid inlining the function to keep vdev_mirror_io_start(), which
  * is this functions only caller, as small as possible on the stack.
  */
 noinline static mirror_map_t *
 vdev_mirror_map_init(zio_t *zio)
 {
 	mirror_map_t *mm = NULL;
 	mirror_child_t *mc;
 	vdev_t *vd = zio->io_vd;
 	int c;
 
 	if (vd == NULL) {
 		dva_t *dva = zio->io_bp->blk_dva;
 		spa_t *spa = zio->io_spa;
 		dsl_scan_t *scn = spa->spa_dsl_pool->dp_scan;
 		dva_t dva_copy[SPA_DVAS_PER_BP];
 
 		/*
 		 * The sequential scrub code sorts and issues all DVAs
 		 * of a bp separately. Each of these IOs includes all
 		 * original DVA copies so that repairs can be performed
 		 * in the event of an error, but we only actually want
 		 * to check the first DVA since the others will be
 		 * checked by their respective sorted IOs. Only if we
 		 * hit an error will we try all DVAs upon retrying.
 		 *
 		 * Note: This check is safe even if the user switches
 		 * from a legacy scrub to a sequential one in the middle
 		 * of processing, since scn_is_sorted isn't updated until
 		 * all outstanding IOs from the previous scrub pass
 		 * complete.
 		 */
 		if ((zio->io_flags & ZIO_FLAG_SCRUB) &&
 		    !(zio->io_flags & ZIO_FLAG_IO_RETRY) &&
 		    dsl_scan_scrubbing(spa->spa_dsl_pool) &&
 		    scn->scn_is_sorted) {
 			c = 1;
 		} else {
 			c = BP_GET_NDVAS(zio->io_bp);
 		}
 
 		/*
 		 * If the pool cannot be written to, then infer that some
 		 * DVAs might be invalid or point to vdevs that do not exist.
 		 * We skip them.
 		 */
 		if (!spa_writeable(spa)) {
 			ASSERT3U(zio->io_type, ==, ZIO_TYPE_READ);
 			int j = 0;
 			for (int i = 0; i < c; i++) {
 				if (zfs_dva_valid(spa, &dva[i], zio->io_bp))
 					dva_copy[j++] = dva[i];
 			}
 			if (j == 0) {
 				zio->io_vsd = NULL;
 				zio->io_error = ENXIO;
 				return (NULL);
 			}
 			if (j < c) {
 				dva = dva_copy;
 				c = j;
 			}
 		}
 
 		mm = vdev_mirror_map_alloc(c, B_FALSE, B_TRUE);
 		for (c = 0; c < mm->mm_children; c++) {
 			mc = &mm->mm_child[c];
 
 			mc->mc_vd = vdev_lookup_top(spa, DVA_GET_VDEV(&dva[c]));
 			mc->mc_offset = DVA_GET_OFFSET(&dva[c]);
 			if (mc->mc_vd == NULL) {
 				kmem_free(mm, vdev_mirror_map_size(
 				    mm->mm_children));
 				zio->io_vsd = NULL;
 				zio->io_error = ENXIO;
 				return (NULL);
 			}
 		}
 	} else {
 		/*
 		 * If we are resilvering, then we should handle scrub reads
 		 * differently; we shouldn't issue them to the resilvering
 		 * device because it might not have those blocks.
 		 *
 		 * We are resilvering iff:
 		 * 1) We are a replacing vdev (ie our name is "replacing-1" or
 		 *    "spare-1" or something like that), and
 		 * 2) The pool is currently being resilvered.
 		 *
 		 * We cannot simply check vd->vdev_resilver_txg, because it's
 		 * not set in this path.
 		 *
 		 * Nor can we just check our vdev_ops; there are cases (such as
 		 * when a user types "zpool replace pool odev spare_dev" and
 		 * spare_dev is in the spare list, or when a spare device is
 		 * automatically used to replace a DEGRADED device) when
 		 * resilvering is complete but both the original vdev and the
 		 * spare vdev remain in the pool.  That behavior is intentional.
 		 * It helps implement the policy that a spare should be
 		 * automatically removed from the pool after the user replaces
 		 * the device that originally failed.
 		 *
 		 * If a spa load is in progress, then spa_dsl_pool may be
 		 * uninitialized.  But we shouldn't be resilvering during a spa
 		 * load anyway.
 		 */
 		boolean_t replacing = (vd->vdev_ops == &vdev_replacing_ops ||
 		    vd->vdev_ops == &vdev_spare_ops) &&
 		    spa_load_state(vd->vdev_spa) == SPA_LOAD_NONE &&
 		    dsl_scan_resilvering(vd->vdev_spa->spa_dsl_pool);
 		mm = vdev_mirror_map_alloc(vd->vdev_children, replacing,
 		    B_FALSE);
 		for (c = 0; c < mm->mm_children; c++) {
 			mc = &mm->mm_child[c];
 			mc->mc_vd = vd->vdev_child[c];
 			mc->mc_offset = zio->io_offset;
 
 			if (vdev_mirror_rebuilding(mc->mc_vd))
 				mm->mm_rebuilding = mc->mc_rebuilding = B_TRUE;
 		}
 	}
 
 	return (mm);
 }
 
 static int
 vdev_mirror_open(vdev_t *vd, uint64_t *asize, uint64_t *max_asize,
     uint64_t *logical_ashift, uint64_t *physical_ashift)
 {
 	int numerrors = 0;
 	int lasterror = 0;
 
 	if (vd->vdev_children == 0) {
 		vd->vdev_stat.vs_aux = VDEV_AUX_BAD_LABEL;
 		return (SET_ERROR(EINVAL));
 	}
 
 	vdev_open_children(vd);
 
 	for (int c = 0; c < vd->vdev_children; c++) {
 		vdev_t *cvd = vd->vdev_child[c];
 
 		if (cvd->vdev_open_error) {
 			lasterror = cvd->vdev_open_error;
 			numerrors++;
 			continue;
 		}
 
 		*asize = MIN(*asize - 1, cvd->vdev_asize - 1) + 1;
 		*max_asize = MIN(*max_asize - 1, cvd->vdev_max_asize - 1) + 1;
 		*logical_ashift = MAX(*logical_ashift, cvd->vdev_ashift);
 	}
 	for (int c = 0; c < vd->vdev_children; c++) {
 		vdev_t *cvd = vd->vdev_child[c];
 
 		if (cvd->vdev_open_error)
 			continue;
 		*physical_ashift = vdev_best_ashift(*logical_ashift,
 		    *physical_ashift, cvd->vdev_physical_ashift);
 	}
 
 	if (numerrors == vd->vdev_children) {
 		if (vdev_children_are_offline(vd))
 			vd->vdev_stat.vs_aux = VDEV_AUX_CHILDREN_OFFLINE;
 		else
 			vd->vdev_stat.vs_aux = VDEV_AUX_NO_REPLICAS;
 		return (lasterror);
 	}
 
 	return (0);
 }
 
 static void
 vdev_mirror_close(vdev_t *vd)
 {
 	for (int c = 0; c < vd->vdev_children; c++)
 		vdev_close(vd->vdev_child[c]);
 }
 
 static void
 vdev_mirror_child_done(zio_t *zio)
 {
 	mirror_child_t *mc = zio->io_private;
 
 	mc->mc_error = zio->io_error;
 	mc->mc_tried = 1;
 	mc->mc_skipped = 0;
 }
 
 /*
  * Check the other, lower-index DVAs to see if they're on the same
  * vdev as the child we picked.  If they are, use them since they
  * are likely to have been allocated from the primary metaslab in
  * use at the time, and hence are more likely to have locality with
  * single-copy data.
  */
 static int
 vdev_mirror_dva_select(zio_t *zio, int p)
 {
 	dva_t *dva = zio->io_bp->blk_dva;
 	mirror_map_t *mm = zio->io_vsd;
 	int preferred;
 	int c;
 
 	preferred = mm->mm_preferred[p];
 	for (p--; p >= 0; p--) {
 		c = mm->mm_preferred[p];
 		if (DVA_GET_VDEV(&dva[c]) == DVA_GET_VDEV(&dva[preferred]))
 			preferred = c;
 	}
 	return (preferred);
 }
 
 static int
 vdev_mirror_preferred_child_randomize(zio_t *zio)
 {
 	mirror_map_t *mm = zio->io_vsd;
 	int p;
 
 	if (mm->mm_root) {
 		p = random_in_range(mm->mm_preferred_cnt);
 		return (vdev_mirror_dva_select(zio, p));
 	}
 
 	/*
 	 * To ensure we don't always favour the first matching vdev,
 	 * which could lead to wear leveling issues on SSD's, we
 	 * use the I/O offset as a pseudo random seed into the vdevs
 	 * which have the lowest load.
 	 */
 	p = (zio->io_offset >> vdev_mirror_shift) % mm->mm_preferred_cnt;
 	return (mm->mm_preferred[p]);
 }
 
 static boolean_t
 vdev_mirror_child_readable(mirror_child_t *mc)
 {
 	vdev_t *vd = mc->mc_vd;
 
 	if (vd->vdev_top != NULL && vd->vdev_top->vdev_ops == &vdev_draid_ops)
 		return (vdev_draid_readable(vd, mc->mc_offset));
 	else
 		return (vdev_readable(vd));
 }
 
 static boolean_t
 vdev_mirror_child_missing(mirror_child_t *mc, uint64_t txg, uint64_t size)
 {
 	vdev_t *vd = mc->mc_vd;
 
 	if (vd->vdev_top != NULL && vd->vdev_top->vdev_ops == &vdev_draid_ops)
 		return (vdev_draid_missing(vd, mc->mc_offset, txg, size));
 	else
 		return (vdev_dtl_contains(vd, DTL_MISSING, txg, size));
 }
 
 /*
  * Try to find a vdev whose DTL doesn't contain the block we want to read
  * preferring vdevs based on determined load. If we can't, try the read on
  * any vdev we haven't already tried.
  *
  * Distributed spares are an exception to the above load rule. They are
  * always preferred in order to detect gaps in the distributed spare which
  * are created when another disk in the dRAID fails. In order to restore
  * redundancy those gaps must be read to trigger the required repair IO.
  */
 static int
 vdev_mirror_child_select(zio_t *zio)
 {
 	mirror_map_t *mm = zio->io_vsd;
 	uint64_t txg = zio->io_txg;
 	int c, lowest_load;
 
 	ASSERT(zio->io_bp == NULL || BP_GET_BIRTH(zio->io_bp) == txg);
 
 	lowest_load = INT_MAX;
 	mm->mm_preferred_cnt = 0;
 	for (c = 0; c < mm->mm_children; c++) {
 		mirror_child_t *mc;
 
 		mc = &mm->mm_child[c];
 		if (mc->mc_tried || mc->mc_skipped)
 			continue;
 
 		if (mc->mc_vd == NULL ||
 		    !vdev_mirror_child_readable(mc)) {
 			mc->mc_error = SET_ERROR(ENXIO);
 			mc->mc_tried = 1;	/* don't even try */
 			mc->mc_skipped = 1;
 			continue;
 		}
 
 		if (vdev_mirror_child_missing(mc, txg, 1)) {
 			mc->mc_error = SET_ERROR(ESTALE);
 			mc->mc_skipped = 1;
 			mc->mc_speculative = 1;
 			continue;
 		}
 
 		if (mc->mc_vd->vdev_ops == &vdev_draid_spare_ops) {
 			mm->mm_preferred[0] = c;
 			mm->mm_preferred_cnt = 1;
 			break;
 		}
 
 		mc->mc_load = vdev_mirror_load(mm, mc->mc_vd, mc->mc_offset);
 		if (mc->mc_load > lowest_load)
 			continue;
 
 		if (mc->mc_load < lowest_load) {
 			lowest_load = mc->mc_load;
 			mm->mm_preferred_cnt = 0;
 		}
 		mm->mm_preferred[mm->mm_preferred_cnt] = c;
 		mm->mm_preferred_cnt++;
 	}
 
 	if (mm->mm_preferred_cnt == 1) {
 		MIRROR_BUMP(vdev_mirror_stat_preferred_found);
 		return (mm->mm_preferred[0]);
 	}
 
 	if (mm->mm_preferred_cnt > 1) {
 		MIRROR_BUMP(vdev_mirror_stat_preferred_not_found);
 		return (vdev_mirror_preferred_child_randomize(zio));
 	}
 
 	/*
 	 * Every device is either missing or has this txg in its DTL.
 	 * Look for any child we haven't already tried before giving up.
 	 */
 	for (c = 0; c < mm->mm_children; c++) {
 		if (!mm->mm_child[c].mc_tried)
 			return (c);
 	}
 
 	/*
 	 * Every child failed.  There's no place left to look.
 	 */
 	return (-1);
 }
 
 static void
 vdev_mirror_io_start(zio_t *zio)
 {
 	mirror_map_t *mm;
 	mirror_child_t *mc;
 	int c, children;
 
 	mm = vdev_mirror_map_init(zio);
 	zio->io_vsd = mm;
 	zio->io_vsd_ops = &vdev_mirror_vsd_ops;
 
 	if (mm == NULL) {
 		ASSERT(!spa_trust_config(zio->io_spa));
 		ASSERT(zio->io_type == ZIO_TYPE_READ);
 		zio_execute(zio);
 		return;
 	}
 
 	if (zio->io_type == ZIO_TYPE_READ) {
 		if ((zio->io_flags & ZIO_FLAG_SCRUB) && !mm->mm_resilvering) {
 			/*
 			 * For scrubbing reads we need to issue reads to all
 			 * children.  One child can reuse parent buffer, but
 			 * for others we have to allocate separate ones to
 			 * verify checksums if io_bp is non-NULL, or compare
 			 * them in vdev_mirror_io_done() otherwise.
 			 */
 			boolean_t first = B_TRUE;
 			for (c = 0; c < mm->mm_children; c++) {
 				mc = &mm->mm_child[c];
 
 				/* Don't issue ZIOs to offline children */
 				if (!vdev_mirror_child_readable(mc)) {
 					mc->mc_error = SET_ERROR(ENXIO);
 					mc->mc_tried = 1;
 					mc->mc_skipped = 1;
 					continue;
 				}
 
 				mc->mc_abd = first ? zio->io_abd :
 				    abd_alloc_sametype(zio->io_abd,
 				    zio->io_size);
 				zio_nowait(zio_vdev_child_io(zio, zio->io_bp,
 				    mc->mc_vd, mc->mc_offset, mc->mc_abd,
 				    zio->io_size, zio->io_type,
 				    zio->io_priority, 0,
 				    vdev_mirror_child_done, mc));
 				first = B_FALSE;
 			}
 			zio_execute(zio);
 			return;
 		}
 		/*
 		 * For normal reads just pick one child.
 		 */
 		c = vdev_mirror_child_select(zio);
 		children = (c >= 0);
 	} else {
 		ASSERT(zio->io_type == ZIO_TYPE_WRITE);
 
 		/*
 		 * Writes go to all children.
 		 */
 		c = 0;
 		children = mm->mm_children;
 	}
 
 	while (children--) {
 		mc = &mm->mm_child[c];
 		c++;
 
 		/*
 		 * When sequentially resilvering only issue write repair
 		 * IOs to the vdev which is being rebuilt since performance
 		 * is limited by the slowest child.  This is an issue for
 		 * faster replacement devices such as distributed spares.
 		 */
 		if ((zio->io_priority == ZIO_PRIORITY_REBUILD) &&
 		    (zio->io_flags & ZIO_FLAG_IO_REPAIR) &&
 		    !(zio->io_flags & ZIO_FLAG_SCRUB) &&
 		    mm->mm_rebuilding && !mc->mc_rebuilding) {
 			continue;
 		}
 
 		zio_nowait(zio_vdev_child_io(zio, zio->io_bp,
 		    mc->mc_vd, mc->mc_offset, zio->io_abd, zio->io_size,
 		    zio->io_type, zio->io_priority, 0,
 		    vdev_mirror_child_done, mc));
 	}
 
 	zio_execute(zio);
 }
 
 static int
 vdev_mirror_worst_error(mirror_map_t *mm)
 {
 	int error[2] = { 0, 0 };
 
 	for (int c = 0; c < mm->mm_children; c++) {
 		mirror_child_t *mc = &mm->mm_child[c];
 		int s = mc->mc_speculative;
 		error[s] = zio_worst_error(error[s], mc->mc_error);
 	}
 
 	return (error[0] ? error[0] : error[1]);
 }
 
 static void
 vdev_mirror_io_done(zio_t *zio)
 {
 	mirror_map_t *mm = zio->io_vsd;
 	mirror_child_t *mc;
 	int c;
 	int good_copies = 0;
 	int unexpected_errors = 0;
 	int last_good_copy = -1;
 
 	if (mm == NULL)
 		return;
 
 	for (c = 0; c < mm->mm_children; c++) {
 		mc = &mm->mm_child[c];
 
 		if (mc->mc_error) {
 			if (!mc->mc_skipped)
 				unexpected_errors++;
 		} else if (mc->mc_tried) {
 			last_good_copy = c;
 			good_copies++;
 		}
 	}
 
 	if (zio->io_type == ZIO_TYPE_WRITE) {
 		/*
 		 * XXX -- for now, treat partial writes as success.
 		 *
 		 * Now that we support write reallocation, it would be better
 		 * to treat partial failure as real failure unless there are
 		 * no non-degraded top-level vdevs left, and not update DTLs
 		 * if we intend to reallocate.
 		 */
 		if (good_copies != mm->mm_children) {
 			/*
 			 * Always require at least one good copy.
 			 *
 			 * For ditto blocks (io_vd == NULL), require
 			 * all copies to be good.
 			 *
 			 * XXX -- for replacing vdevs, there's no great answer.
 			 * If the old device is really dead, we may not even
 			 * be able to access it -- so we only want to
 			 * require good writes to the new device.  But if
 			 * the new device turns out to be flaky, we want
 			 * to be able to detach it -- which requires all
 			 * writes to the old device to have succeeded.
 			 */
 			if (good_copies == 0 || zio->io_vd == NULL)
 				zio->io_error = vdev_mirror_worst_error(mm);
 		}
 		return;
 	}
 
 	ASSERT(zio->io_type == ZIO_TYPE_READ);
 
+	/*
+	 * Any Direct I/O read that has a checksum error must be treated as
+	 * suspicious as the contents of the buffer could be getting
+	 * manipulated while the I/O is taking place. The checksum verify error
+	 * will be reported to the top-level Mirror VDEV.
+	 *
+	 * There will be no attampt at reading any additional data copies. If
+	 * the buffer is still being manipulated while attempting to read from
+	 * another child, there exists a possibly that the checksum could be
+	 * verified as valid. However, the buffer contents could again get
+	 * manipulated after verifying the checksum. This would lead to bad data
+	 * being written out during self healing.
+	 */
+	if ((zio->io_flags & ZIO_FLAG_DIO_READ) &&
+	    (zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR)) {
+		zio_dio_chksum_verify_error_report(zio);
+		zio->io_error = vdev_mirror_worst_error(mm);
+		ASSERT3U(zio->io_error, ==, ECKSUM);
+		return;
+	}
+
 	/*
 	 * If we don't have a good copy yet, keep trying other children.
 	 */
 	if (good_copies == 0 && (c = vdev_mirror_child_select(zio)) != -1) {
 		ASSERT(c >= 0 && c < mm->mm_children);
 		mc = &mm->mm_child[c];
 		zio_vdev_io_redone(zio);
 		zio_nowait(zio_vdev_child_io(zio, zio->io_bp,
 		    mc->mc_vd, mc->mc_offset, zio->io_abd, zio->io_size,
 		    ZIO_TYPE_READ, zio->io_priority, 0,
 		    vdev_mirror_child_done, mc));
 		return;
 	}
 
 	if (zio->io_flags & ZIO_FLAG_SCRUB && !mm->mm_resilvering) {
 		abd_t *best_abd = NULL;
 		if (last_good_copy >= 0)
 			best_abd = mm->mm_child[last_good_copy].mc_abd;
 
 		/*
 		 * If we're scrubbing but don't have a BP available (because
 		 * this vdev is under a raidz or draid vdev) then the best we
 		 * can do is compare all of the copies read.  If they're not
 		 * identical then return a checksum error and the most likely
 		 * correct data.  The raidz code will issue a repair I/O if
 		 * possible.
 		 */
 		if (zio->io_bp == NULL) {
 			ASSERT(zio->io_vd->vdev_ops == &vdev_replacing_ops ||
 			    zio->io_vd->vdev_ops == &vdev_spare_ops);
 
 			abd_t *pref_abd = NULL;
 			for (c = 0; c < last_good_copy; c++) {
 				mc = &mm->mm_child[c];
 				if (mc->mc_error || !mc->mc_tried)
 					continue;
 
 				if (abd_cmp(mc->mc_abd, best_abd) != 0)
 					zio->io_error = SET_ERROR(ECKSUM);
 
 				/*
 				 * The distributed spare is always prefered
 				 * by vdev_mirror_child_select() so it's
 				 * considered to be the best candidate.
 				 */
 				if (pref_abd == NULL &&
 				    mc->mc_vd->vdev_ops ==
 				    &vdev_draid_spare_ops)
 					pref_abd = mc->mc_abd;
 
 				/*
 				 * In the absence of a preferred copy, use
 				 * the parent pointer to avoid a memory copy.
 				 */
 				if (mc->mc_abd == zio->io_abd)
 					best_abd = mc->mc_abd;
 			}
 			if (pref_abd)
 				best_abd = pref_abd;
 		} else {
 
 			/*
 			 * If we have a BP available, then checksums are
 			 * already verified and we just need a buffer
 			 * with valid data, preferring parent one to
 			 * avoid a memory copy.
 			 */
 			for (c = 0; c < last_good_copy; c++) {
 				mc = &mm->mm_child[c];
 				if (mc->mc_error || !mc->mc_tried)
 					continue;
 				if (mc->mc_abd == zio->io_abd) {
 					best_abd = mc->mc_abd;
 					break;
 				}
 			}
 		}
 
 		if (best_abd && best_abd != zio->io_abd)
 			abd_copy(zio->io_abd, best_abd, zio->io_size);
 		for (c = 0; c < mm->mm_children; c++) {
 			mc = &mm->mm_child[c];
 			if (mc->mc_abd != zio->io_abd)
 				abd_free(mc->mc_abd);
 			mc->mc_abd = NULL;
 		}
 	}
 
 	if (good_copies == 0) {
 		zio->io_error = vdev_mirror_worst_error(mm);
 		ASSERT(zio->io_error != 0);
 	}
 
 	if (good_copies && spa_writeable(zio->io_spa) &&
 	    (unexpected_errors ||
 	    (zio->io_flags & ZIO_FLAG_RESILVER) ||
 	    ((zio->io_flags & ZIO_FLAG_SCRUB) && mm->mm_resilvering))) {
 		/*
 		 * Use the good data we have in hand to repair damaged children.
 		 */
 		for (c = 0; c < mm->mm_children; c++) {
 			/*
 			 * Don't rewrite known good children.
 			 * Not only is it unnecessary, it could
 			 * actually be harmful: if the system lost
 			 * power while rewriting the only good copy,
 			 * there would be no good copies left!
 			 */
 			mc = &mm->mm_child[c];
 
 			if (mc->mc_error == 0) {
 				vdev_ops_t *ops = mc->mc_vd->vdev_ops;
 
 				if (mc->mc_tried)
 					continue;
 				/*
 				 * We didn't try this child.  We need to
 				 * repair it if:
 				 * 1. it's a scrub (in which case we have
 				 * tried everything that was healthy)
 				 *  - or -
 				 * 2. it's an indirect or distributed spare
 				 * vdev (in which case it could point to any
 				 * other vdev, which might have a bad DTL)
 				 *  - or -
 				 * 3. the DTL indicates that this data is
 				 * missing from this vdev
 				 */
 				if (!(zio->io_flags & ZIO_FLAG_SCRUB) &&
 				    ops != &vdev_indirect_ops &&
 				    ops != &vdev_draid_spare_ops &&
 				    !vdev_dtl_contains(mc->mc_vd, DTL_PARTIAL,
 				    zio->io_txg, 1))
 					continue;
 				mc->mc_error = SET_ERROR(ESTALE);
 			}
 
 			zio_nowait(zio_vdev_child_io(zio, zio->io_bp,
 			    mc->mc_vd, mc->mc_offset,
 			    zio->io_abd, zio->io_size, ZIO_TYPE_WRITE,
 			    zio->io_priority == ZIO_PRIORITY_REBUILD ?
 			    ZIO_PRIORITY_REBUILD : ZIO_PRIORITY_ASYNC_WRITE,
 			    ZIO_FLAG_IO_REPAIR | (unexpected_errors ?
 			    ZIO_FLAG_SELF_HEAL : 0), NULL, NULL));
 		}
 	}
 }
 
 static void
 vdev_mirror_state_change(vdev_t *vd, int faulted, int degraded)
 {
 	if (faulted == vd->vdev_children) {
 		if (vdev_children_are_offline(vd)) {
 			vdev_set_state(vd, B_FALSE, VDEV_STATE_OFFLINE,
 			    VDEV_AUX_CHILDREN_OFFLINE);
 		} else {
 			vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
 			    VDEV_AUX_NO_REPLICAS);
 		}
 	} else if (degraded + faulted != 0) {
 		vdev_set_state(vd, B_FALSE, VDEV_STATE_DEGRADED, VDEV_AUX_NONE);
 	} else {
 		vdev_set_state(vd, B_FALSE, VDEV_STATE_HEALTHY, VDEV_AUX_NONE);
 	}
 }
 
 /*
  * Return the maximum asize for a rebuild zio in the provided range.
  */
 static uint64_t
 vdev_mirror_rebuild_asize(vdev_t *vd, uint64_t start, uint64_t asize,
     uint64_t max_segment)
 {
 	(void) start;
 
 	uint64_t psize = MIN(P2ROUNDUP(max_segment, 1 << vd->vdev_ashift),
 	    SPA_MAXBLOCKSIZE);
 
 	return (MIN(asize, vdev_psize_to_asize(vd, psize)));
 }
 
 vdev_ops_t vdev_mirror_ops = {
 	.vdev_op_init = NULL,
 	.vdev_op_fini = NULL,
 	.vdev_op_open = vdev_mirror_open,
 	.vdev_op_close = vdev_mirror_close,
 	.vdev_op_asize = vdev_default_asize,
 	.vdev_op_min_asize = vdev_default_min_asize,
 	.vdev_op_min_alloc = NULL,
 	.vdev_op_io_start = vdev_mirror_io_start,
 	.vdev_op_io_done = vdev_mirror_io_done,
 	.vdev_op_state_change = vdev_mirror_state_change,
 	.vdev_op_need_resilver = vdev_default_need_resilver,
 	.vdev_op_hold = NULL,
 	.vdev_op_rele = NULL,
 	.vdev_op_remap = NULL,
 	.vdev_op_xlate = vdev_default_xlate,
 	.vdev_op_rebuild_asize = vdev_mirror_rebuild_asize,
 	.vdev_op_metaslab_init = NULL,
 	.vdev_op_config_generate = NULL,
 	.vdev_op_nparity = NULL,
 	.vdev_op_ndisks = NULL,
 	.vdev_op_type = VDEV_TYPE_MIRROR,	/* name of this vdev type */
 	.vdev_op_leaf = B_FALSE			/* not a leaf vdev */
 };
 
 vdev_ops_t vdev_replacing_ops = {
 	.vdev_op_init = NULL,
 	.vdev_op_fini = NULL,
 	.vdev_op_open = vdev_mirror_open,
 	.vdev_op_close = vdev_mirror_close,
 	.vdev_op_asize = vdev_default_asize,
 	.vdev_op_min_asize = vdev_default_min_asize,
 	.vdev_op_min_alloc = NULL,
 	.vdev_op_io_start = vdev_mirror_io_start,
 	.vdev_op_io_done = vdev_mirror_io_done,
 	.vdev_op_state_change = vdev_mirror_state_change,
 	.vdev_op_need_resilver = vdev_default_need_resilver,
 	.vdev_op_hold = NULL,
 	.vdev_op_rele = NULL,
 	.vdev_op_remap = NULL,
 	.vdev_op_xlate = vdev_default_xlate,
 	.vdev_op_rebuild_asize = vdev_mirror_rebuild_asize,
 	.vdev_op_metaslab_init = NULL,
 	.vdev_op_config_generate = NULL,
 	.vdev_op_nparity = NULL,
 	.vdev_op_ndisks = NULL,
 	.vdev_op_type = VDEV_TYPE_REPLACING,	/* name of this vdev type */
 	.vdev_op_leaf = B_FALSE			/* not a leaf vdev */
 };
 
 vdev_ops_t vdev_spare_ops = {
 	.vdev_op_init = NULL,
 	.vdev_op_fini = NULL,
 	.vdev_op_open = vdev_mirror_open,
 	.vdev_op_close = vdev_mirror_close,
 	.vdev_op_asize = vdev_default_asize,
 	.vdev_op_min_asize = vdev_default_min_asize,
 	.vdev_op_min_alloc = NULL,
 	.vdev_op_io_start = vdev_mirror_io_start,
 	.vdev_op_io_done = vdev_mirror_io_done,
 	.vdev_op_state_change = vdev_mirror_state_change,
 	.vdev_op_need_resilver = vdev_default_need_resilver,
 	.vdev_op_hold = NULL,
 	.vdev_op_rele = NULL,
 	.vdev_op_remap = NULL,
 	.vdev_op_xlate = vdev_default_xlate,
 	.vdev_op_rebuild_asize = vdev_mirror_rebuild_asize,
 	.vdev_op_metaslab_init = NULL,
 	.vdev_op_config_generate = NULL,
 	.vdev_op_nparity = NULL,
 	.vdev_op_ndisks = NULL,
 	.vdev_op_type = VDEV_TYPE_SPARE,	/* name of this vdev type */
 	.vdev_op_leaf = B_FALSE			/* not a leaf vdev */
 };
 
 ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, rotating_inc, INT, ZMOD_RW,
 	"Rotating media load increment for non-seeking I/Os");
 
 ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, rotating_seek_inc, INT,
 	ZMOD_RW, "Rotating media load increment for seeking I/Os");
 
 /* BEGIN CSTYLED */
 ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, rotating_seek_offset, INT,
 	ZMOD_RW,
 	"Offset in bytes from the last I/O which triggers "
 	"a reduced rotating media seek increment");
 /* END CSTYLED */
 
 ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, non_rotating_inc, INT,
 	ZMOD_RW, "Non-rotating media load increment for non-seeking I/Os");
 
 ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, non_rotating_seek_inc, INT,
 	ZMOD_RW, "Non-rotating media load increment for seeking I/Os");
diff --git a/sys/contrib/openzfs/module/zfs/vdev_raidz.c b/sys/contrib/openzfs/module/zfs/vdev_raidz.c
index 15c8b8ca6016..5e330626be2b 100644
--- a/sys/contrib/openzfs/module/zfs/vdev_raidz.c
+++ b/sys/contrib/openzfs/module/zfs/vdev_raidz.c
@@ -1,5022 +1,5056 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 
 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2012, 2020 by Delphix. All rights reserved.
  * Copyright (c) 2016 Gvozden Nešković. All rights reserved.
  */
 
 #include <sys/zfs_context.h>
 #include <sys/spa.h>
 #include <sys/spa_impl.h>
 #include <sys/zap.h>
 #include <sys/vdev_impl.h>
 #include <sys/metaslab_impl.h>
 #include <sys/zio.h>
 #include <sys/zio_checksum.h>
 #include <sys/dmu_tx.h>
 #include <sys/abd.h>
 #include <sys/zfs_rlock.h>
 #include <sys/fs/zfs.h>
 #include <sys/fm/fs/zfs.h>
 #include <sys/vdev_raidz.h>
 #include <sys/vdev_raidz_impl.h>
 #include <sys/vdev_draid.h>
 #include <sys/uberblock_impl.h>
 #include <sys/dsl_scan.h>
 
 #ifdef ZFS_DEBUG
 #include <sys/vdev.h>	/* For vdev_xlate() in vdev_raidz_io_verify() */
 #endif
 
 /*
  * Virtual device vector for RAID-Z.
  *
  * This vdev supports single, double, and triple parity. For single parity,
  * we use a simple XOR of all the data columns. For double or triple parity,
  * we use a special case of Reed-Solomon coding. This extends the
  * technique described in "The mathematics of RAID-6" by H. Peter Anvin by
  * drawing on the system described in "A Tutorial on Reed-Solomon Coding for
  * Fault-Tolerance in RAID-like Systems" by James S. Plank on which the
  * former is also based. The latter is designed to provide higher performance
  * for writes.
  *
  * Note that the Plank paper claimed to support arbitrary N+M, but was then
  * amended six years later identifying a critical flaw that invalidates its
  * claims. Nevertheless, the technique can be adapted to work for up to
  * triple parity. For additional parity, the amendment "Note: Correction to
  * the 1997 Tutorial on Reed-Solomon Coding" by James S. Plank and Ying Ding
  * is viable, but the additional complexity means that write performance will
  * suffer.
  *
  * All of the methods above operate on a Galois field, defined over the
  * integers mod 2^N. In our case we choose N=8 for GF(8) so that all elements
  * can be expressed with a single byte. Briefly, the operations on the
  * field are defined as follows:
  *
  *   o addition (+) is represented by a bitwise XOR
  *   o subtraction (-) is therefore identical to addition: A + B = A - B
  *   o multiplication of A by 2 is defined by the following bitwise expression:
  *
  *	(A * 2)_7 = A_6
  *	(A * 2)_6 = A_5
  *	(A * 2)_5 = A_4
  *	(A * 2)_4 = A_3 + A_7
  *	(A * 2)_3 = A_2 + A_7
  *	(A * 2)_2 = A_1 + A_7
  *	(A * 2)_1 = A_0
  *	(A * 2)_0 = A_7
  *
  * In C, multiplying by 2 is therefore ((a << 1) ^ ((a & 0x80) ? 0x1d : 0)).
  * As an aside, this multiplication is derived from the error correcting
  * primitive polynomial x^8 + x^4 + x^3 + x^2 + 1.
  *
  * Observe that any number in the field (except for 0) can be expressed as a
  * power of 2 -- a generator for the field. We store a table of the powers of
  * 2 and logs base 2 for quick look ups, and exploit the fact that A * B can
  * be rewritten as 2^(log_2(A) + log_2(B)) (where '+' is normal addition rather
  * than field addition). The inverse of a field element A (A^-1) is therefore
  * A ^ (255 - 1) = A^254.
  *
  * The up-to-three parity columns, P, Q, R over several data columns,
  * D_0, ... D_n-1, can be expressed by field operations:
  *
  *	P = D_0 + D_1 + ... + D_n-2 + D_n-1
  *	Q = 2^n-1 * D_0 + 2^n-2 * D_1 + ... + 2^1 * D_n-2 + 2^0 * D_n-1
  *	  = ((...((D_0) * 2 + D_1) * 2 + ...) * 2 + D_n-2) * 2 + D_n-1
  *	R = 4^n-1 * D_0 + 4^n-2 * D_1 + ... + 4^1 * D_n-2 + 4^0 * D_n-1
  *	  = ((...((D_0) * 4 + D_1) * 4 + ...) * 4 + D_n-2) * 4 + D_n-1
  *
  * We chose 1, 2, and 4 as our generators because 1 corresponds to the trivial
  * XOR operation, and 2 and 4 can be computed quickly and generate linearly-
  * independent coefficients. (There are no additional coefficients that have
  * this property which is why the uncorrected Plank method breaks down.)
  *
  * See the reconstruction code below for how P, Q and R can used individually
  * or in concert to recover missing data columns.
  */
 
 #define	VDEV_RAIDZ_P		0
 #define	VDEV_RAIDZ_Q		1
 #define	VDEV_RAIDZ_R		2
 
 #define	VDEV_RAIDZ_MUL_2(x)	(((x) << 1) ^ (((x) & 0x80) ? 0x1d : 0))
 #define	VDEV_RAIDZ_MUL_4(x)	(VDEV_RAIDZ_MUL_2(VDEV_RAIDZ_MUL_2(x)))
 
 /*
  * We provide a mechanism to perform the field multiplication operation on a
  * 64-bit value all at once rather than a byte at a time. This works by
  * creating a mask from the top bit in each byte and using that to
  * conditionally apply the XOR of 0x1d.
  */
 #define	VDEV_RAIDZ_64MUL_2(x, mask) \
 { \
 	(mask) = (x) & 0x8080808080808080ULL; \
 	(mask) = ((mask) << 1) - ((mask) >> 7); \
 	(x) = (((x) << 1) & 0xfefefefefefefefeULL) ^ \
 	    ((mask) & 0x1d1d1d1d1d1d1d1dULL); \
 }
 
 #define	VDEV_RAIDZ_64MUL_4(x, mask) \
 { \
 	VDEV_RAIDZ_64MUL_2((x), mask); \
 	VDEV_RAIDZ_64MUL_2((x), mask); \
 }
 
 
 /*
  * Big Theory Statement for how a RAIDZ VDEV is expanded
  *
  * An existing RAIDZ VDEV can be expanded by attaching a new disk. Expansion
  * works with all three RAIDZ parity choices, including RAIDZ1, 2, or 3. VDEVs
  * that have been previously expanded can be expanded again.
  *
  * The RAIDZ VDEV must be healthy (must be able to write to all the drives in
  * the VDEV) when an expansion starts.  And the expansion will pause if any
  * disk in the VDEV fails, and resume once the VDEV is healthy again. All other
  * operations on the pool can continue while an expansion is in progress (e.g.
  * read/write, snapshot, zpool add, etc). Except zpool checkpoint, zpool trim,
  * and zpool initialize which can't be run during an expansion.  Following a
  * reboot or export/import, the expansion resumes where it left off.
  *
  * == Reflowing the Data ==
  *
  * The expansion involves reflowing (copying) the data from the current set
  * of disks to spread it across the new set which now has one more disk. This
  * reflow operation is similar to reflowing text when the column width of a
  * text editor window is expanded. The text doesn’t change but the location of
  * the text changes to accommodate the new width. An example reflow result for
  * a 4-wide RAIDZ1 to a 5-wide is shown below.
  *
  *                            Reflow End State
  *            Each letter indicates a parity group (logical stripe)
  *
  *         Before expansion                         After Expansion
  *     D1     D2     D3     D4               D1     D2     D3     D4     D5
  *  +------+------+------+------+         +------+------+------+------+------+
  *  |      |      |      |      |         |      |      |      |      |      |
  *  |  A   |  A   |  A   |  A   |         |  A   |  A   |  A   |  A   |  B   |
  *  |     1|     2|     3|     4|         |     1|     2|     3|     4|     5|
  *  +------+------+------+------+         +------+------+------+------+------+
  *  |      |      |      |      |         |      |      |      |      |      |
  *  |  B   |  B   |  C   |  C   |         |  B   |  C   |  C   |  C   |  C   |
  *  |     5|     6|     7|     8|         |     6|     7|     8|     9|    10|
  *  +------+------+------+------+         +------+------+------+------+------+
  *  |      |      |      |      |         |      |      |      |      |      |
  *  |  C   |  C   |  D   |  D   |         |  D   |  D   |  E   |  E   |  E   |
  *  |     9|    10|    11|    12|         |    11|    12|    13|    14|    15|
  *  +------+------+------+------+         +------+------+------+------+------+
  *  |      |      |      |      |         |      |      |      |      |      |
  *  |  E   |  E   |  E   |  E   |   -->   |  E   |  F   |  F   |  G   |  G   |
  *  |    13|    14|    15|    16|         |    16|    17|    18|p   19|    20|
  *  +------+------+------+------+         +------+------+------+------+------+
  *  |      |      |      |      |         |      |      |      |      |      |
  *  |  F   |  F   |  G   |  G   |         |  G   |  G   |  H   |  H   |  H   |
  *  |    17|    18|    19|    20|         |    21|    22|    23|    24|    25|
  *  +------+------+------+------+         +------+------+------+------+------+
  *  |      |      |      |      |         |      |      |      |      |      |
  *  |  G   |  G   |  H   |  H   |         |  H   |  I   |  I   |  J   |  J   |
  *  |    21|    22|    23|    24|         |    26|    27|    28|    29|    30|
  *  +------+------+------+------+         +------+------+------+------+------+
  *  |      |      |      |      |         |      |      |      |      |      |
  *  |  H   |  H   |  I   |  I   |         |  J   |  J   |      |      |  K   |
  *  |    25|    26|    27|    28|         |    31|    32|    33|    34|    35|
  *  +------+------+------+------+         +------+------+------+------+------+
  *
  * This reflow approach has several advantages. There is no need to read or
  * modify the block pointers or recompute any block checksums.  The reflow
  * doesn’t need to know where the parity sectors reside. We can read and write
  * data sequentially and the copy can occur in a background thread in open
  * context. The design also allows for fast discovery of what data to copy.
  *
  * The VDEV metaslabs are processed, one at a time, to copy the block data to
  * have it flow across all the disks. The metaslab is disabled for allocations
  * during the copy. As an optimization, we only copy the allocated data which
  * can be determined by looking at the metaslab range tree. During the copy we
  * must maintain the redundancy guarantees of the RAIDZ VDEV (i.e., we still
  * need to be able to survive losing parity count disks).  This means we
  * cannot overwrite data during the reflow that would be needed if a disk is
  * lost.
  *
  * After the reflow completes, all newly-written blocks will have the new
  * layout, i.e., they will have the parity to data ratio implied by the new
  * number of disks in the RAIDZ group.  Even though the reflow copies all of
  * the allocated space (data and parity), it is only rearranged, not changed.
  *
  * This act of reflowing the data has a few implications about blocks
  * that were written before the reflow completes:
  *
  *  - Old blocks will still use the same amount of space (i.e., they will have
  *    the parity to data ratio implied by the old number of disks in the RAIDZ
  *    group).
  *  - Reading old blocks will be slightly slower than before the reflow, for
  *    two reasons. First, we will have to read from all disks in the RAIDZ
  *    VDEV, rather than being able to skip the children that contain only
  *    parity of this block (because the data of a single block is now spread
  *    out across all the disks).  Second, in most cases there will be an extra
  *    bcopy, needed to rearrange the data back to its original layout in memory.
  *
  * == Scratch Area ==
  *
  * As we copy the block data, we can only progress to the point that writes
  * will not overlap with blocks whose progress has not yet been recorded on
  * disk.  Since partially-copied rows are always read from the old location,
  * we need to stop one row before the sector-wise overlap, to prevent any
  * row-wise overlap. For example, in the diagram above, when we reflow sector
  * B6 it will overwite the original location for B5.
  *
  * To get around this, a scratch space is used so that we can start copying
  * without risking data loss by overlapping the row. As an added benefit, it
  * improves performance at the beginning of the reflow, but that small perf
  * boost wouldn't be worth the complexity on its own.
  *
  * Ideally we want to copy at least 2 * (new_width)^2 so that we have a
  * separation of 2*(new_width+1) and a chunk size of new_width+2. With the max
  * RAIDZ width of 255 and 4K sectors this would be 2MB per disk. In practice
  * the widths will likely be single digits so we can get a substantial chuck
  * size using only a few MB of scratch per disk.
  *
  * The scratch area is persisted to disk which holds a large amount of reflowed
  * state. We can always read the partially written stripes when a disk fails or
  * the copy is interrupted (crash) during the initial copying phase and also
  * get past a small chunk size restriction.  At a minimum, the scratch space
  * must be large enough to get us to the point that one row does not overlap
  * itself when moved (i.e new_width^2).  But going larger is even better. We
  * use the 3.5 MiB reserved "boot" space that resides after the ZFS disk labels
  * as our scratch space to handle overwriting the initial part of the VDEV.
  *
  *	0     256K   512K                    4M
  *	+------+------+-----------------------+-----------------------------
  *	| VDEV | VDEV |   Boot Block (3.5M)   |  Allocatable space ...
  *	|  L0  |  L1  |       Reserved        |     (Metaslabs)
  *	+------+------+-----------------------+-------------------------------
  *                        Scratch Area
  *
  * == Reflow Progress Updates ==
  * After the initial scratch-based reflow, the expansion process works
  * similarly to device removal. We create a new open context thread which
  * reflows the data, and periodically kicks off sync tasks to update logical
  * state. In this case, state is the committed progress (offset of next data
  * to copy). We need to persist the completed offset on disk, so that if we
  * crash we know which format each VDEV offset is in.
  *
  * == Time Dependent Geometry ==
  *
  * In non-expanded RAIDZ, blocks are read from disk in a column by column
  * fashion. For a multi-row block, the second sector is in the first column
  * not in the second column. This allows us to issue full reads for each
  * column directly into the request buffer. The block data is thus laid out
  * sequentially in a column-by-column fashion.
  *
  * For example, in the before expansion diagram above, one logical block might
  * be sectors G19-H26. The parity is in G19,H23; and the data is in
  * G20,H24,G21,H25,G22,H26.
  *
  * After a block is reflowed, the sectors that were all in the original column
  * data can now reside in different columns. When reading from an expanded
  * VDEV, we need to know the logical stripe width for each block so we can
  * reconstitute the block’s data after the reads are completed. Likewise,
  * when we perform the combinatorial reconstruction we need to know the
  * original width so we can retry combinations from the past layouts.
  *
  * Time dependent geometry is what we call having blocks with different layouts
  * (stripe widths) in the same VDEV. This time-dependent geometry uses the
  * block’s birth time (+ the time expansion ended) to establish the correct
  * width for a given block. After an expansion completes, we record the time
  * for blocks written with a particular width (geometry).
  *
  * == On Disk Format Changes ==
  *
  * New pool feature flag, 'raidz_expansion' whose reference count is the number
  * of RAIDZ VDEVs that have been expanded.
  *
  * The blocks on expanded RAIDZ VDEV can have different logical stripe widths.
  *
  * Since the uberblock can point to arbitrary blocks, which might be on the
  * expanding RAIDZ, and might or might not have been expanded. We need to know
  * which way a block is laid out before reading it. This info is the next
  * offset that needs to be reflowed and we persist that in the uberblock, in
  * the new ub_raidz_reflow_info field, as opposed to the MOS or the vdev label.
  * After the expansion is complete, we then use the raidz_expand_txgs array
  * (see below) to determine how to read a block and the ub_raidz_reflow_info
  * field no longer required.
  *
  * The uberblock's ub_raidz_reflow_info field also holds the scratch space
  * state (i.e., active or not) which is also required before reading a block
  * during the initial phase of reflowing the data.
  *
  * The top-level RAIDZ VDEV has two new entries in the nvlist:
  *
  * 'raidz_expand_txgs' array: logical stripe widths by txg are recorded here
  *                            and used after the expansion is complete to
  *                            determine how to read a raidz block
  * 'raidz_expanding' boolean: present during reflow and removed after completion
  *                            used during a spa import to resume an unfinished
  *                            expansion
  *
  * And finally the VDEVs top zap adds the following informational entries:
  *   VDEV_TOP_ZAP_RAIDZ_EXPAND_STATE
  *   VDEV_TOP_ZAP_RAIDZ_EXPAND_START_TIME
  *   VDEV_TOP_ZAP_RAIDZ_EXPAND_END_TIME
  *   VDEV_TOP_ZAP_RAIDZ_EXPAND_BYTES_COPIED
  */
 
 /*
  * For testing only: pause the raidz expansion after reflowing this amount.
  * (accessed by ZTS and ztest)
  */
 #ifdef	_KERNEL
 static
 #endif	/* _KERNEL */
 unsigned long raidz_expand_max_reflow_bytes = 0;
 
 /*
  * For testing only: pause the raidz expansion at a certain point.
  */
 uint_t raidz_expand_pause_point = 0;
 
 /*
  * Maximum amount of copy io's outstanding at once.
  */
 static unsigned long raidz_expand_max_copy_bytes = 10 * SPA_MAXBLOCKSIZE;
 
 /*
  * Apply raidz map abds aggregation if the number of rows in the map is equal
  * or greater than the value below.
  */
 static unsigned long raidz_io_aggregate_rows = 4;
 
 /*
  * Automatically start a pool scrub when a RAIDZ expansion completes in
  * order to verify the checksums of all blocks which have been copied
  * during the expansion.  Automatic scrubbing is enabled by default and
  * is strongly recommended.
  */
 static int zfs_scrub_after_expand = 1;
 
 static void
 vdev_raidz_row_free(raidz_row_t *rr)
 {
 	for (int c = 0; c < rr->rr_cols; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 
 		if (rc->rc_size != 0)
 			abd_free(rc->rc_abd);
 		if (rc->rc_orig_data != NULL)
 			abd_free(rc->rc_orig_data);
 	}
 
 	if (rr->rr_abd_empty != NULL)
 		abd_free(rr->rr_abd_empty);
 
 	kmem_free(rr, offsetof(raidz_row_t, rr_col[rr->rr_scols]));
 }
 
 void
 vdev_raidz_map_free(raidz_map_t *rm)
 {
 	for (int i = 0; i < rm->rm_nrows; i++)
 		vdev_raidz_row_free(rm->rm_row[i]);
 
 	if (rm->rm_nphys_cols) {
 		for (int i = 0; i < rm->rm_nphys_cols; i++) {
 			if (rm->rm_phys_col[i].rc_abd != NULL)
 				abd_free(rm->rm_phys_col[i].rc_abd);
 		}
 
 		kmem_free(rm->rm_phys_col, sizeof (raidz_col_t) *
 		    rm->rm_nphys_cols);
 	}
 
 	ASSERT3P(rm->rm_lr, ==, NULL);
 	kmem_free(rm, offsetof(raidz_map_t, rm_row[rm->rm_nrows]));
 }
 
 static void
 vdev_raidz_map_free_vsd(zio_t *zio)
 {
 	raidz_map_t *rm = zio->io_vsd;
 
 	vdev_raidz_map_free(rm);
 }
 
 static int
 vdev_raidz_reflow_compare(const void *x1, const void *x2)
 {
 	const reflow_node_t *l = x1;
 	const reflow_node_t *r = x2;
 
 	return (TREE_CMP(l->re_txg, r->re_txg));
 }
 
 const zio_vsd_ops_t vdev_raidz_vsd_ops = {
 	.vsd_free = vdev_raidz_map_free_vsd,
 };
 
 raidz_row_t *
-vdev_raidz_row_alloc(int cols)
+vdev_raidz_row_alloc(int cols, zio_t *zio)
 {
 	raidz_row_t *rr =
 	    kmem_zalloc(offsetof(raidz_row_t, rr_col[cols]), KM_SLEEP);
 
 	rr->rr_cols = cols;
 	rr->rr_scols = cols;
 
 	for (int c = 0; c < cols; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 		rc->rc_shadow_devidx = INT_MAX;
 		rc->rc_shadow_offset = UINT64_MAX;
-		rc->rc_allow_repair = 1;
+		/*
+		 * We can not allow self healing to take place for Direct I/O
+		 * reads. There is nothing that stops the buffer contents from
+		 * being manipulated while the I/O is in flight. It is possible
+		 * that the checksum could be verified on the buffer and then
+		 * the contents of that buffer are manipulated afterwards. This
+		 * could lead to bad data being written out during self
+		 * healing.
+		 */
+		if (!(zio->io_flags & ZIO_FLAG_DIO_READ))
+			rc->rc_allow_repair = 1;
 	}
 	return (rr);
 }
 
 static void
 vdev_raidz_map_alloc_write(zio_t *zio, raidz_map_t *rm, uint64_t ashift)
 {
 	int c;
 	int nwrapped = 0;
 	uint64_t off = 0;
 	raidz_row_t *rr = rm->rm_row[0];
 
 	ASSERT3U(zio->io_type, ==, ZIO_TYPE_WRITE);
 	ASSERT3U(rm->rm_nrows, ==, 1);
 
 	/*
 	 * Pad any parity columns with additional space to account for skip
 	 * sectors.
 	 */
 	if (rm->rm_skipstart < rr->rr_firstdatacol) {
 		ASSERT0(rm->rm_skipstart);
 		nwrapped = rm->rm_nskip;
 	} else if (rr->rr_scols < (rm->rm_skipstart + rm->rm_nskip)) {
 		nwrapped =
 		    (rm->rm_skipstart + rm->rm_nskip) % rr->rr_scols;
 	}
 
 	/*
 	 * Optional single skip sectors (rc_size == 0) will be handled in
 	 * vdev_raidz_io_start_write().
 	 */
 	int skipped = rr->rr_scols - rr->rr_cols;
 
 	/* Allocate buffers for the parity columns */
 	for (c = 0; c < rr->rr_firstdatacol; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 
 		/*
 		 * Parity columns will pad out a linear ABD to account for
 		 * the skip sector. A linear ABD is used here because
 		 * parity calculations use the ABD buffer directly to calculate
 		 * parity. This avoids doing a memcpy back to the ABD after the
 		 * parity has been calculated. By issuing the parity column
 		 * with the skip sector we can reduce contention on the child
 		 * VDEV queue locks (vq_lock).
 		 */
 		if (c < nwrapped) {
 			rc->rc_abd = abd_alloc_linear(
 			    rc->rc_size + (1ULL << ashift), B_FALSE);
 			abd_zero_off(rc->rc_abd, rc->rc_size, 1ULL << ashift);
 			skipped++;
 		} else {
 			rc->rc_abd = abd_alloc_linear(rc->rc_size, B_FALSE);
 		}
 	}
 
 	for (off = 0; c < rr->rr_cols; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 		abd_t *abd = abd_get_offset_struct(&rc->rc_abdstruct,
 		    zio->io_abd, off, rc->rc_size);
 
 		/*
 		 * Generate I/O for skip sectors to improve aggregation
 		 * continuity. We will use gang ABD's to reduce contention
 		 * on the child VDEV queue locks (vq_lock) by issuing
 		 * a single I/O that contains the data and skip sector.
 		 *
 		 * It is important to make sure that rc_size is not updated
 		 * even though we are adding a skip sector to the ABD. When
 		 * calculating the parity in vdev_raidz_generate_parity_row()
 		 * the rc_size is used to iterate through the ABD's. We can
 		 * not have zero'd out skip sectors used for calculating
 		 * parity for raidz, because those same sectors are not used
 		 * during reconstruction.
 		 */
 		if (c >= rm->rm_skipstart && skipped < rm->rm_nskip) {
 			rc->rc_abd = abd_alloc_gang();
 			abd_gang_add(rc->rc_abd, abd, B_TRUE);
 			abd_gang_add(rc->rc_abd,
 			    abd_get_zeros(1ULL << ashift), B_TRUE);
 			skipped++;
 		} else {
 			rc->rc_abd = abd;
 		}
 		off += rc->rc_size;
 	}
 
 	ASSERT3U(off, ==, zio->io_size);
 	ASSERT3S(skipped, ==, rm->rm_nskip);
 }
 
 static void
 vdev_raidz_map_alloc_read(zio_t *zio, raidz_map_t *rm)
 {
 	int c;
 	raidz_row_t *rr = rm->rm_row[0];
 
 	ASSERT3U(rm->rm_nrows, ==, 1);
 
 	/* Allocate buffers for the parity columns */
 	for (c = 0; c < rr->rr_firstdatacol; c++)
 		rr->rr_col[c].rc_abd =
 		    abd_alloc_linear(rr->rr_col[c].rc_size, B_FALSE);
 
 	for (uint64_t off = 0; c < rr->rr_cols; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 		rc->rc_abd = abd_get_offset_struct(&rc->rc_abdstruct,
 		    zio->io_abd, off, rc->rc_size);
 		off += rc->rc_size;
 	}
 }
 
 /*
  * Divides the IO evenly across all child vdevs; usually, dcols is
  * the number of children in the target vdev.
  *
  * Avoid inlining the function to keep vdev_raidz_io_start(), which
  * is this functions only caller, as small as possible on the stack.
  */
 noinline raidz_map_t *
 vdev_raidz_map_alloc(zio_t *zio, uint64_t ashift, uint64_t dcols,
     uint64_t nparity)
 {
 	raidz_row_t *rr;
 	/* The starting RAIDZ (parent) vdev sector of the block. */
 	uint64_t b = zio->io_offset >> ashift;
 	/* The zio's size in units of the vdev's minimum sector size. */
 	uint64_t s = zio->io_size >> ashift;
 	/* The first column for this stripe. */
 	uint64_t f = b % dcols;
 	/* The starting byte offset on each child vdev. */
 	uint64_t o = (b / dcols) << ashift;
 	uint64_t acols, scols;
 
 	raidz_map_t *rm =
 	    kmem_zalloc(offsetof(raidz_map_t, rm_row[1]), KM_SLEEP);
 	rm->rm_nrows = 1;
 
 	/*
 	 * "Quotient": The number of data sectors for this stripe on all but
 	 * the "big column" child vdevs that also contain "remainder" data.
 	 */
 	uint64_t q = s / (dcols - nparity);
 
 	/*
 	 * "Remainder": The number of partial stripe data sectors in this I/O.
 	 * This will add a sector to some, but not all, child vdevs.
 	 */
 	uint64_t r = s - q * (dcols - nparity);
 
 	/* The number of "big columns" - those which contain remainder data. */
 	uint64_t bc = (r == 0 ? 0 : r + nparity);
 
 	/*
 	 * The total number of data and parity sectors associated with
 	 * this I/O.
 	 */
 	uint64_t tot = s + nparity * (q + (r == 0 ? 0 : 1));
 
 	/*
 	 * acols: The columns that will be accessed.
 	 * scols: The columns that will be accessed or skipped.
 	 */
 	if (q == 0) {
 		/* Our I/O request doesn't span all child vdevs. */
 		acols = bc;
 		scols = MIN(dcols, roundup(bc, nparity + 1));
 	} else {
 		acols = dcols;
 		scols = dcols;
 	}
 
 	ASSERT3U(acols, <=, scols);
-	rr = vdev_raidz_row_alloc(scols);
+	rr = vdev_raidz_row_alloc(scols, zio);
 	rm->rm_row[0] = rr;
 	rr->rr_cols = acols;
 	rr->rr_bigcols = bc;
 	rr->rr_firstdatacol = nparity;
 #ifdef ZFS_DEBUG
 	rr->rr_offset = zio->io_offset;
 	rr->rr_size = zio->io_size;
 #endif
 
 	uint64_t asize = 0;
 
 	for (uint64_t c = 0; c < scols; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 		uint64_t col = f + c;
 		uint64_t coff = o;
 		if (col >= dcols) {
 			col -= dcols;
 			coff += 1ULL << ashift;
 		}
 		rc->rc_devidx = col;
 		rc->rc_offset = coff;
 
 		if (c >= acols)
 			rc->rc_size = 0;
 		else if (c < bc)
 			rc->rc_size = (q + 1) << ashift;
 		else
 			rc->rc_size = q << ashift;
 
 		asize += rc->rc_size;
 	}
 
 	ASSERT3U(asize, ==, tot << ashift);
 	rm->rm_nskip = roundup(tot, nparity + 1) - tot;
 	rm->rm_skipstart = bc;
 
 	/*
 	 * If all data stored spans all columns, there's a danger that parity
 	 * will always be on the same device and, since parity isn't read
 	 * during normal operation, that device's I/O bandwidth won't be
 	 * used effectively. We therefore switch the parity every 1MB.
 	 *
 	 * ... at least that was, ostensibly, the theory. As a practical
 	 * matter unless we juggle the parity between all devices evenly, we
 	 * won't see any benefit. Further, occasional writes that aren't a
 	 * multiple of the LCM of the number of children and the minimum
 	 * stripe width are sufficient to avoid pessimal behavior.
 	 * Unfortunately, this decision created an implicit on-disk format
 	 * requirement that we need to support for all eternity, but only
 	 * for single-parity RAID-Z.
 	 *
 	 * If we intend to skip a sector in the zeroth column for padding
 	 * we must make sure to note this swap. We will never intend to
 	 * skip the first column since at least one data and one parity
 	 * column must appear in each row.
 	 */
 	ASSERT(rr->rr_cols >= 2);
 	ASSERT(rr->rr_col[0].rc_size == rr->rr_col[1].rc_size);
 
 	if (rr->rr_firstdatacol == 1 && (zio->io_offset & (1ULL << 20))) {
 		uint64_t devidx = rr->rr_col[0].rc_devidx;
 		o = rr->rr_col[0].rc_offset;
 		rr->rr_col[0].rc_devidx = rr->rr_col[1].rc_devidx;
 		rr->rr_col[0].rc_offset = rr->rr_col[1].rc_offset;
 		rr->rr_col[1].rc_devidx = devidx;
 		rr->rr_col[1].rc_offset = o;
 		if (rm->rm_skipstart == 0)
 			rm->rm_skipstart = 1;
 	}
 
 	if (zio->io_type == ZIO_TYPE_WRITE) {
 		vdev_raidz_map_alloc_write(zio, rm, ashift);
 	} else {
 		vdev_raidz_map_alloc_read(zio, rm);
 	}
 	/* init RAIDZ parity ops */
 	rm->rm_ops = vdev_raidz_math_get_ops();
 
 	return (rm);
 }
 
 /*
  * Everything before reflow_offset_synced should have been moved to the new
  * location (read and write completed).  However, this may not yet be reflected
  * in the on-disk format (e.g. raidz_reflow_sync() has been called but the
  * uberblock has not yet been written). If reflow is not in progress,
  * reflow_offset_synced should be UINT64_MAX. For each row, if the row is
  * entirely before reflow_offset_synced, it will come from the new location.
  * Otherwise this row will come from the old location.  Therefore, rows that
  * straddle the reflow_offset_synced will come from the old location.
  *
  * For writes, reflow_offset_next is the next offset to copy.  If a sector has
  * been copied, but not yet reflected in the on-disk progress
  * (reflow_offset_synced), it will also be written to the new (already copied)
  * offset.
  */
 noinline raidz_map_t *
 vdev_raidz_map_alloc_expanded(zio_t *zio,
     uint64_t ashift, uint64_t physical_cols, uint64_t logical_cols,
     uint64_t nparity, uint64_t reflow_offset_synced,
     uint64_t reflow_offset_next, boolean_t use_scratch)
 {
 	abd_t *abd = zio->io_abd;
 	uint64_t offset = zio->io_offset;
 	uint64_t size = zio->io_size;
 
 	/* The zio's size in units of the vdev's minimum sector size. */
 	uint64_t s = size >> ashift;
 
 	/*
 	 * "Quotient": The number of data sectors for this stripe on all but
 	 * the "big column" child vdevs that also contain "remainder" data.
 	 * AKA "full rows"
 	 */
 	uint64_t q = s / (logical_cols - nparity);
 
 	/*
 	 * "Remainder": The number of partial stripe data sectors in this I/O.
 	 * This will add a sector to some, but not all, child vdevs.
 	 */
 	uint64_t r = s - q * (logical_cols - nparity);
 
 	/* The number of "big columns" - those which contain remainder data. */
 	uint64_t bc = (r == 0 ? 0 : r + nparity);
 
 	/*
 	 * The total number of data and parity sectors associated with
 	 * this I/O.
 	 */
 	uint64_t tot = s + nparity * (q + (r == 0 ? 0 : 1));
 
 	/* How many rows contain data (not skip) */
 	uint64_t rows = howmany(tot, logical_cols);
 	int cols = MIN(tot, logical_cols);
 
 	raidz_map_t *rm =
 	    kmem_zalloc(offsetof(raidz_map_t, rm_row[rows]),
 	    KM_SLEEP);
 	rm->rm_nrows = rows;
 	rm->rm_nskip = roundup(tot, nparity + 1) - tot;
 	rm->rm_skipstart = bc;
 	uint64_t asize = 0;
 
 	for (uint64_t row = 0; row < rows; row++) {
 		boolean_t row_use_scratch = B_FALSE;
-		raidz_row_t *rr = vdev_raidz_row_alloc(cols);
+		raidz_row_t *rr = vdev_raidz_row_alloc(cols, zio);
 		rm->rm_row[row] = rr;
 
 		/* The starting RAIDZ (parent) vdev sector of the row. */
 		uint64_t b = (offset >> ashift) + row * logical_cols;
 
 		/*
 		 * If we are in the middle of a reflow, and the copying has
 		 * not yet completed for any part of this row, then use the
 		 * old location of this row.  Note that reflow_offset_synced
 		 * reflects the i/o that's been completed, because it's
 		 * updated by a synctask, after zio_wait(spa_txg_zio[]).
 		 * This is sufficient for our check, even if that progress
 		 * has not yet been recorded to disk (reflected in
 		 * spa_ubsync).  Also note that we consider the last row to
 		 * be "full width" (`cols`-wide rather than `bc`-wide) for
 		 * this calculation. This causes a tiny bit of unnecessary
 		 * double-writes but is safe and simpler to calculate.
 		 */
 		int row_phys_cols = physical_cols;
 		if (b + cols > reflow_offset_synced >> ashift)
 			row_phys_cols--;
 		else if (use_scratch)
 			row_use_scratch = B_TRUE;
 
 		/* starting child of this row */
 		uint64_t child_id = b % row_phys_cols;
 		/* The starting byte offset on each child vdev. */
 		uint64_t child_offset = (b / row_phys_cols) << ashift;
 
 		/*
 		 * Note, rr_cols is the entire width of the block, even
 		 * if this row is shorter.  This is needed because parity
 		 * generation (for Q and R) needs to know the entire width,
 		 * because it treats the short row as though it was
 		 * full-width (and the "phantom" sectors were zero-filled).
 		 *
 		 * Another approach to this would be to set cols shorter
 		 * (to just the number of columns that we might do i/o to)
 		 * and have another mechanism to tell the parity generation
 		 * about the "entire width".  Reconstruction (at least
 		 * vdev_raidz_reconstruct_general()) would also need to
 		 * know about the "entire width".
 		 */
 		rr->rr_firstdatacol = nparity;
 #ifdef ZFS_DEBUG
 		/*
 		 * note: rr_size is PSIZE, not ASIZE
 		 */
 		rr->rr_offset = b << ashift;
 		rr->rr_size = (rr->rr_cols - rr->rr_firstdatacol) << ashift;
 #endif
 
 		for (int c = 0; c < rr->rr_cols; c++, child_id++) {
 			if (child_id >= row_phys_cols) {
 				child_id -= row_phys_cols;
 				child_offset += 1ULL << ashift;
 			}
 			raidz_col_t *rc = &rr->rr_col[c];
 			rc->rc_devidx = child_id;
 			rc->rc_offset = child_offset;
 
 			/*
 			 * Get this from the scratch space if appropriate.
 			 * This only happens if we crashed in the middle of
 			 * raidz_reflow_scratch_sync() (while it's running,
 			 * the rangelock prevents us from doing concurrent
 			 * io), and even then only during zpool import or
 			 * when the pool is imported readonly.
 			 */
 			if (row_use_scratch)
 				rc->rc_offset -= VDEV_BOOT_SIZE;
 
 			uint64_t dc = c - rr->rr_firstdatacol;
 			if (c < rr->rr_firstdatacol) {
 				rc->rc_size = 1ULL << ashift;
 
 				/*
 				 * Parity sectors' rc_abd's are set below
 				 * after determining if this is an aggregation.
 				 */
 			} else if (row == rows - 1 && bc != 0 && c >= bc) {
 				/*
 				 * Past the end of the block (even including
 				 * skip sectors).  This sector is part of the
 				 * map so that we have full rows for p/q parity
 				 * generation.
 				 */
 				rc->rc_size = 0;
 				rc->rc_abd = NULL;
 			} else {
 				/* "data column" (col excluding parity) */
 				uint64_t off;
 
 				if (c < bc || r == 0) {
 					off = dc * rows + row;
 				} else {
 					off = r * rows +
 					    (dc - r) * (rows - 1) + row;
 				}
 				rc->rc_size = 1ULL << ashift;
 				rc->rc_abd = abd_get_offset_struct(
 				    &rc->rc_abdstruct, abd, off << ashift,
 				    rc->rc_size);
 			}
 
 			if (rc->rc_size == 0)
 				continue;
 
 			/*
 			 * If any part of this row is in both old and new
 			 * locations, the primary location is the old
 			 * location. If this sector was already copied to the
 			 * new location, we need to also write to the new,
 			 * "shadow" location.
 			 *
 			 * Note, `row_phys_cols != physical_cols` indicates
 			 * that the primary location is the old location.
 			 * `b+c < reflow_offset_next` indicates that the copy
 			 * to the new location has been initiated. We know
 			 * that the copy has completed because we have the
 			 * rangelock, which is held exclusively while the
 			 * copy is in progress.
 			 */
 			if (row_use_scratch ||
 			    (row_phys_cols != physical_cols &&
 			    b + c < reflow_offset_next >> ashift)) {
 				rc->rc_shadow_devidx = (b + c) % physical_cols;
 				rc->rc_shadow_offset =
 				    ((b + c) / physical_cols) << ashift;
 				if (row_use_scratch)
 					rc->rc_shadow_offset -= VDEV_BOOT_SIZE;
 			}
 
 			asize += rc->rc_size;
 		}
 
 		/*
 		 * See comment in vdev_raidz_map_alloc()
 		 */
 		if (rr->rr_firstdatacol == 1 && rr->rr_cols > 1 &&
 		    (offset & (1ULL << 20))) {
 			ASSERT(rr->rr_cols >= 2);
 			ASSERT(rr->rr_col[0].rc_size == rr->rr_col[1].rc_size);
 
 			int devidx0 = rr->rr_col[0].rc_devidx;
 			uint64_t offset0 = rr->rr_col[0].rc_offset;
 			int shadow_devidx0 = rr->rr_col[0].rc_shadow_devidx;
 			uint64_t shadow_offset0 =
 			    rr->rr_col[0].rc_shadow_offset;
 
 			rr->rr_col[0].rc_devidx = rr->rr_col[1].rc_devidx;
 			rr->rr_col[0].rc_offset = rr->rr_col[1].rc_offset;
 			rr->rr_col[0].rc_shadow_devidx =
 			    rr->rr_col[1].rc_shadow_devidx;
 			rr->rr_col[0].rc_shadow_offset =
 			    rr->rr_col[1].rc_shadow_offset;
 
 			rr->rr_col[1].rc_devidx = devidx0;
 			rr->rr_col[1].rc_offset = offset0;
 			rr->rr_col[1].rc_shadow_devidx = shadow_devidx0;
 			rr->rr_col[1].rc_shadow_offset = shadow_offset0;
 		}
 	}
 	ASSERT3U(asize, ==, tot << ashift);
 
 	/*
 	 * Determine if the block is contiguous, in which case we can use
 	 * an aggregation.
 	 */
 	if (rows >= raidz_io_aggregate_rows) {
 		rm->rm_nphys_cols = physical_cols;
 		rm->rm_phys_col =
 		    kmem_zalloc(sizeof (raidz_col_t) * rm->rm_nphys_cols,
 		    KM_SLEEP);
 
 		/*
 		 * Determine the aggregate io's offset and size, and check
 		 * that the io is contiguous.
 		 */
 		for (int i = 0;
 		    i < rm->rm_nrows && rm->rm_phys_col != NULL; i++) {
 			raidz_row_t *rr = rm->rm_row[i];
 			for (int c = 0; c < rr->rr_cols; c++) {
 				raidz_col_t *rc = &rr->rr_col[c];
 				raidz_col_t *prc =
 				    &rm->rm_phys_col[rc->rc_devidx];
 
 				if (rc->rc_size == 0)
 					continue;
 
 				if (prc->rc_size == 0) {
 					ASSERT0(prc->rc_offset);
 					prc->rc_offset = rc->rc_offset;
 				} else if (prc->rc_offset + prc->rc_size !=
 				    rc->rc_offset) {
 					/*
 					 * This block is not contiguous and
 					 * therefore can't be aggregated.
 					 * This is expected to be rare, so
 					 * the cost of allocating and then
 					 * freeing rm_phys_col is not
 					 * significant.
 					 */
 					kmem_free(rm->rm_phys_col,
 					    sizeof (raidz_col_t) *
 					    rm->rm_nphys_cols);
 					rm->rm_phys_col = NULL;
 					rm->rm_nphys_cols = 0;
 					break;
 				}
 				prc->rc_size += rc->rc_size;
 			}
 		}
 	}
 	if (rm->rm_phys_col != NULL) {
 		/*
 		 * Allocate aggregate ABD's.
 		 */
 		for (int i = 0; i < rm->rm_nphys_cols; i++) {
 			raidz_col_t *prc = &rm->rm_phys_col[i];
 
 			prc->rc_devidx = i;
 
 			if (prc->rc_size == 0)
 				continue;
 
 			prc->rc_abd =
 			    abd_alloc_linear(rm->rm_phys_col[i].rc_size,
 			    B_FALSE);
 		}
 
 		/*
 		 * Point the parity abd's into the aggregate abd's.
 		 */
 		for (int i = 0; i < rm->rm_nrows; i++) {
 			raidz_row_t *rr = rm->rm_row[i];
 			for (int c = 0; c < rr->rr_firstdatacol; c++) {
 				raidz_col_t *rc = &rr->rr_col[c];
 				raidz_col_t *prc =
 				    &rm->rm_phys_col[rc->rc_devidx];
 				rc->rc_abd =
 				    abd_get_offset_struct(&rc->rc_abdstruct,
 				    prc->rc_abd,
 				    rc->rc_offset - prc->rc_offset,
 				    rc->rc_size);
 			}
 		}
 	} else {
 		/*
 		 * Allocate new abd's for the parity sectors.
 		 */
 		for (int i = 0; i < rm->rm_nrows; i++) {
 			raidz_row_t *rr = rm->rm_row[i];
 			for (int c = 0; c < rr->rr_firstdatacol; c++) {
 				raidz_col_t *rc = &rr->rr_col[c];
 				rc->rc_abd =
 				    abd_alloc_linear(rc->rc_size,
 				    B_TRUE);
 			}
 		}
 	}
 	/* init RAIDZ parity ops */
 	rm->rm_ops = vdev_raidz_math_get_ops();
 
 	return (rm);
 }
 
 struct pqr_struct {
 	uint64_t *p;
 	uint64_t *q;
 	uint64_t *r;
 };
 
 static int
 vdev_raidz_p_func(void *buf, size_t size, void *private)
 {
 	struct pqr_struct *pqr = private;
 	const uint64_t *src = buf;
 	int cnt = size / sizeof (src[0]);
 
 	ASSERT(pqr->p && !pqr->q && !pqr->r);
 
 	for (int i = 0; i < cnt; i++, src++, pqr->p++)
 		*pqr->p ^= *src;
 
 	return (0);
 }
 
 static int
 vdev_raidz_pq_func(void *buf, size_t size, void *private)
 {
 	struct pqr_struct *pqr = private;
 	const uint64_t *src = buf;
 	uint64_t mask;
 	int cnt = size / sizeof (src[0]);
 
 	ASSERT(pqr->p && pqr->q && !pqr->r);
 
 	for (int i = 0; i < cnt; i++, src++, pqr->p++, pqr->q++) {
 		*pqr->p ^= *src;
 		VDEV_RAIDZ_64MUL_2(*pqr->q, mask);
 		*pqr->q ^= *src;
 	}
 
 	return (0);
 }
 
 static int
 vdev_raidz_pqr_func(void *buf, size_t size, void *private)
 {
 	struct pqr_struct *pqr = private;
 	const uint64_t *src = buf;
 	uint64_t mask;
 	int cnt = size / sizeof (src[0]);
 
 	ASSERT(pqr->p && pqr->q && pqr->r);
 
 	for (int i = 0; i < cnt; i++, src++, pqr->p++, pqr->q++, pqr->r++) {
 		*pqr->p ^= *src;
 		VDEV_RAIDZ_64MUL_2(*pqr->q, mask);
 		*pqr->q ^= *src;
 		VDEV_RAIDZ_64MUL_4(*pqr->r, mask);
 		*pqr->r ^= *src;
 	}
 
 	return (0);
 }
 
 static void
 vdev_raidz_generate_parity_p(raidz_row_t *rr)
 {
 	uint64_t *p = abd_to_buf(rr->rr_col[VDEV_RAIDZ_P].rc_abd);
 
 	for (int c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
 		abd_t *src = rr->rr_col[c].rc_abd;
 
 		if (c == rr->rr_firstdatacol) {
 			abd_copy_to_buf(p, src, rr->rr_col[c].rc_size);
 		} else {
 			struct pqr_struct pqr = { p, NULL, NULL };
 			(void) abd_iterate_func(src, 0, rr->rr_col[c].rc_size,
 			    vdev_raidz_p_func, &pqr);
 		}
 	}
 }
 
 static void
 vdev_raidz_generate_parity_pq(raidz_row_t *rr)
 {
 	uint64_t *p = abd_to_buf(rr->rr_col[VDEV_RAIDZ_P].rc_abd);
 	uint64_t *q = abd_to_buf(rr->rr_col[VDEV_RAIDZ_Q].rc_abd);
 	uint64_t pcnt = rr->rr_col[VDEV_RAIDZ_P].rc_size / sizeof (p[0]);
 	ASSERT(rr->rr_col[VDEV_RAIDZ_P].rc_size ==
 	    rr->rr_col[VDEV_RAIDZ_Q].rc_size);
 
 	for (int c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
 		abd_t *src = rr->rr_col[c].rc_abd;
 
 		uint64_t ccnt = rr->rr_col[c].rc_size / sizeof (p[0]);
 
 		if (c == rr->rr_firstdatacol) {
 			ASSERT(ccnt == pcnt || ccnt == 0);
 			abd_copy_to_buf(p, src, rr->rr_col[c].rc_size);
 			(void) memcpy(q, p, rr->rr_col[c].rc_size);
 
 			for (uint64_t i = ccnt; i < pcnt; i++) {
 				p[i] = 0;
 				q[i] = 0;
 			}
 		} else {
 			struct pqr_struct pqr = { p, q, NULL };
 
 			ASSERT(ccnt <= pcnt);
 			(void) abd_iterate_func(src, 0, rr->rr_col[c].rc_size,
 			    vdev_raidz_pq_func, &pqr);
 
 			/*
 			 * Treat short columns as though they are full of 0s.
 			 * Note that there's therefore nothing needed for P.
 			 */
 			uint64_t mask;
 			for (uint64_t i = ccnt; i < pcnt; i++) {
 				VDEV_RAIDZ_64MUL_2(q[i], mask);
 			}
 		}
 	}
 }
 
 static void
 vdev_raidz_generate_parity_pqr(raidz_row_t *rr)
 {
 	uint64_t *p = abd_to_buf(rr->rr_col[VDEV_RAIDZ_P].rc_abd);
 	uint64_t *q = abd_to_buf(rr->rr_col[VDEV_RAIDZ_Q].rc_abd);
 	uint64_t *r = abd_to_buf(rr->rr_col[VDEV_RAIDZ_R].rc_abd);
 	uint64_t pcnt = rr->rr_col[VDEV_RAIDZ_P].rc_size / sizeof (p[0]);
 	ASSERT(rr->rr_col[VDEV_RAIDZ_P].rc_size ==
 	    rr->rr_col[VDEV_RAIDZ_Q].rc_size);
 	ASSERT(rr->rr_col[VDEV_RAIDZ_P].rc_size ==
 	    rr->rr_col[VDEV_RAIDZ_R].rc_size);
 
 	for (int c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
 		abd_t *src = rr->rr_col[c].rc_abd;
 
 		uint64_t ccnt = rr->rr_col[c].rc_size / sizeof (p[0]);
 
 		if (c == rr->rr_firstdatacol) {
 			ASSERT(ccnt == pcnt || ccnt == 0);
 			abd_copy_to_buf(p, src, rr->rr_col[c].rc_size);
 			(void) memcpy(q, p, rr->rr_col[c].rc_size);
 			(void) memcpy(r, p, rr->rr_col[c].rc_size);
 
 			for (uint64_t i = ccnt; i < pcnt; i++) {
 				p[i] = 0;
 				q[i] = 0;
 				r[i] = 0;
 			}
 		} else {
 			struct pqr_struct pqr = { p, q, r };
 
 			ASSERT(ccnt <= pcnt);
 			(void) abd_iterate_func(src, 0, rr->rr_col[c].rc_size,
 			    vdev_raidz_pqr_func, &pqr);
 
 			/*
 			 * Treat short columns as though they are full of 0s.
 			 * Note that there's therefore nothing needed for P.
 			 */
 			uint64_t mask;
 			for (uint64_t i = ccnt; i < pcnt; i++) {
 				VDEV_RAIDZ_64MUL_2(q[i], mask);
 				VDEV_RAIDZ_64MUL_4(r[i], mask);
 			}
 		}
 	}
 }
 
 /*
  * Generate RAID parity in the first virtual columns according to the number of
  * parity columns available.
  */
 void
 vdev_raidz_generate_parity_row(raidz_map_t *rm, raidz_row_t *rr)
 {
 	if (rr->rr_cols == 0) {
 		/*
 		 * We are handling this block one row at a time (because
 		 * this block has a different logical vs physical width,
 		 * due to RAIDZ expansion), and this is a pad-only row,
 		 * which has no parity.
 		 */
 		return;
 	}
 
 	/* Generate using the new math implementation */
 	if (vdev_raidz_math_generate(rm, rr) != RAIDZ_ORIGINAL_IMPL)
 		return;
 
 	switch (rr->rr_firstdatacol) {
 	case 1:
 		vdev_raidz_generate_parity_p(rr);
 		break;
 	case 2:
 		vdev_raidz_generate_parity_pq(rr);
 		break;
 	case 3:
 		vdev_raidz_generate_parity_pqr(rr);
 		break;
 	default:
 		cmn_err(CE_PANIC, "invalid RAID-Z configuration");
 	}
 }
 
 void
 vdev_raidz_generate_parity(raidz_map_t *rm)
 {
 	for (int i = 0; i < rm->rm_nrows; i++) {
 		raidz_row_t *rr = rm->rm_row[i];
 		vdev_raidz_generate_parity_row(rm, rr);
 	}
 }
 
 static int
 vdev_raidz_reconst_p_func(void *dbuf, void *sbuf, size_t size, void *private)
 {
 	(void) private;
 	uint64_t *dst = dbuf;
 	uint64_t *src = sbuf;
 	int cnt = size / sizeof (src[0]);
 
 	for (int i = 0; i < cnt; i++) {
 		dst[i] ^= src[i];
 	}
 
 	return (0);
 }
 
 static int
 vdev_raidz_reconst_q_pre_func(void *dbuf, void *sbuf, size_t size,
     void *private)
 {
 	(void) private;
 	uint64_t *dst = dbuf;
 	uint64_t *src = sbuf;
 	uint64_t mask;
 	int cnt = size / sizeof (dst[0]);
 
 	for (int i = 0; i < cnt; i++, dst++, src++) {
 		VDEV_RAIDZ_64MUL_2(*dst, mask);
 		*dst ^= *src;
 	}
 
 	return (0);
 }
 
 static int
 vdev_raidz_reconst_q_pre_tail_func(void *buf, size_t size, void *private)
 {
 	(void) private;
 	uint64_t *dst = buf;
 	uint64_t mask;
 	int cnt = size / sizeof (dst[0]);
 
 	for (int i = 0; i < cnt; i++, dst++) {
 		/* same operation as vdev_raidz_reconst_q_pre_func() on dst */
 		VDEV_RAIDZ_64MUL_2(*dst, mask);
 	}
 
 	return (0);
 }
 
 struct reconst_q_struct {
 	uint64_t *q;
 	int exp;
 };
 
 static int
 vdev_raidz_reconst_q_post_func(void *buf, size_t size, void *private)
 {
 	struct reconst_q_struct *rq = private;
 	uint64_t *dst = buf;
 	int cnt = size / sizeof (dst[0]);
 
 	for (int i = 0; i < cnt; i++, dst++, rq->q++) {
 		int j;
 		uint8_t *b;
 
 		*dst ^= *rq->q;
 		for (j = 0, b = (uint8_t *)dst; j < 8; j++, b++) {
 			*b = vdev_raidz_exp2(*b, rq->exp);
 		}
 	}
 
 	return (0);
 }
 
 struct reconst_pq_struct {
 	uint8_t *p;
 	uint8_t *q;
 	uint8_t *pxy;
 	uint8_t *qxy;
 	int aexp;
 	int bexp;
 };
 
 static int
 vdev_raidz_reconst_pq_func(void *xbuf, void *ybuf, size_t size, void *private)
 {
 	struct reconst_pq_struct *rpq = private;
 	uint8_t *xd = xbuf;
 	uint8_t *yd = ybuf;
 
 	for (int i = 0; i < size;
 	    i++, rpq->p++, rpq->q++, rpq->pxy++, rpq->qxy++, xd++, yd++) {
 		*xd = vdev_raidz_exp2(*rpq->p ^ *rpq->pxy, rpq->aexp) ^
 		    vdev_raidz_exp2(*rpq->q ^ *rpq->qxy, rpq->bexp);
 		*yd = *rpq->p ^ *rpq->pxy ^ *xd;
 	}
 
 	return (0);
 }
 
 static int
 vdev_raidz_reconst_pq_tail_func(void *xbuf, size_t size, void *private)
 {
 	struct reconst_pq_struct *rpq = private;
 	uint8_t *xd = xbuf;
 
 	for (int i = 0; i < size;
 	    i++, rpq->p++, rpq->q++, rpq->pxy++, rpq->qxy++, xd++) {
 		/* same operation as vdev_raidz_reconst_pq_func() on xd */
 		*xd = vdev_raidz_exp2(*rpq->p ^ *rpq->pxy, rpq->aexp) ^
 		    vdev_raidz_exp2(*rpq->q ^ *rpq->qxy, rpq->bexp);
 	}
 
 	return (0);
 }
 
 static void
 vdev_raidz_reconstruct_p(raidz_row_t *rr, int *tgts, int ntgts)
 {
 	int x = tgts[0];
 	abd_t *dst, *src;
 
 	if (zfs_flags & ZFS_DEBUG_RAIDZ_RECONSTRUCT)
 		zfs_dbgmsg("reconstruct_p(rm=%px x=%u)", rr, x);
 
 	ASSERT3U(ntgts, ==, 1);
 	ASSERT3U(x, >=, rr->rr_firstdatacol);
 	ASSERT3U(x, <, rr->rr_cols);
 
 	ASSERT3U(rr->rr_col[x].rc_size, <=, rr->rr_col[VDEV_RAIDZ_P].rc_size);
 
 	src = rr->rr_col[VDEV_RAIDZ_P].rc_abd;
 	dst = rr->rr_col[x].rc_abd;
 
 	abd_copy_from_buf(dst, abd_to_buf(src), rr->rr_col[x].rc_size);
 
 	for (int c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
 		uint64_t size = MIN(rr->rr_col[x].rc_size,
 		    rr->rr_col[c].rc_size);
 
 		src = rr->rr_col[c].rc_abd;
 
 		if (c == x)
 			continue;
 
 		(void) abd_iterate_func2(dst, src, 0, 0, size,
 		    vdev_raidz_reconst_p_func, NULL);
 	}
 }
 
 static void
 vdev_raidz_reconstruct_q(raidz_row_t *rr, int *tgts, int ntgts)
 {
 	int x = tgts[0];
 	int c, exp;
 	abd_t *dst, *src;
 
 	if (zfs_flags & ZFS_DEBUG_RAIDZ_RECONSTRUCT)
 		zfs_dbgmsg("reconstruct_q(rm=%px x=%u)", rr, x);
 
 	ASSERT(ntgts == 1);
 
 	ASSERT(rr->rr_col[x].rc_size <= rr->rr_col[VDEV_RAIDZ_Q].rc_size);
 
 	for (c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
 		uint64_t size = (c == x) ? 0 : MIN(rr->rr_col[x].rc_size,
 		    rr->rr_col[c].rc_size);
 
 		src = rr->rr_col[c].rc_abd;
 		dst = rr->rr_col[x].rc_abd;
 
 		if (c == rr->rr_firstdatacol) {
 			abd_copy(dst, src, size);
 			if (rr->rr_col[x].rc_size > size) {
 				abd_zero_off(dst, size,
 				    rr->rr_col[x].rc_size - size);
 			}
 		} else {
 			ASSERT3U(size, <=, rr->rr_col[x].rc_size);
 			(void) abd_iterate_func2(dst, src, 0, 0, size,
 			    vdev_raidz_reconst_q_pre_func, NULL);
 			(void) abd_iterate_func(dst,
 			    size, rr->rr_col[x].rc_size - size,
 			    vdev_raidz_reconst_q_pre_tail_func, NULL);
 		}
 	}
 
 	src = rr->rr_col[VDEV_RAIDZ_Q].rc_abd;
 	dst = rr->rr_col[x].rc_abd;
 	exp = 255 - (rr->rr_cols - 1 - x);
 
 	struct reconst_q_struct rq = { abd_to_buf(src), exp };
 	(void) abd_iterate_func(dst, 0, rr->rr_col[x].rc_size,
 	    vdev_raidz_reconst_q_post_func, &rq);
 }
 
 static void
 vdev_raidz_reconstruct_pq(raidz_row_t *rr, int *tgts, int ntgts)
 {
 	uint8_t *p, *q, *pxy, *qxy, tmp, a, b, aexp, bexp;
 	abd_t *pdata, *qdata;
 	uint64_t xsize, ysize;
 	int x = tgts[0];
 	int y = tgts[1];
 	abd_t *xd, *yd;
 
 	if (zfs_flags & ZFS_DEBUG_RAIDZ_RECONSTRUCT)
 		zfs_dbgmsg("reconstruct_pq(rm=%px x=%u y=%u)", rr, x, y);
 
 	ASSERT(ntgts == 2);
 	ASSERT(x < y);
 	ASSERT(x >= rr->rr_firstdatacol);
 	ASSERT(y < rr->rr_cols);
 
 	ASSERT(rr->rr_col[x].rc_size >= rr->rr_col[y].rc_size);
 
 	/*
 	 * Move the parity data aside -- we're going to compute parity as
 	 * though columns x and y were full of zeros -- Pxy and Qxy. We want to
 	 * reuse the parity generation mechanism without trashing the actual
 	 * parity so we make those columns appear to be full of zeros by
 	 * setting their lengths to zero.
 	 */
 	pdata = rr->rr_col[VDEV_RAIDZ_P].rc_abd;
 	qdata = rr->rr_col[VDEV_RAIDZ_Q].rc_abd;
 	xsize = rr->rr_col[x].rc_size;
 	ysize = rr->rr_col[y].rc_size;
 
 	rr->rr_col[VDEV_RAIDZ_P].rc_abd =
 	    abd_alloc_linear(rr->rr_col[VDEV_RAIDZ_P].rc_size, B_TRUE);
 	rr->rr_col[VDEV_RAIDZ_Q].rc_abd =
 	    abd_alloc_linear(rr->rr_col[VDEV_RAIDZ_Q].rc_size, B_TRUE);
 	rr->rr_col[x].rc_size = 0;
 	rr->rr_col[y].rc_size = 0;
 
 	vdev_raidz_generate_parity_pq(rr);
 
 	rr->rr_col[x].rc_size = xsize;
 	rr->rr_col[y].rc_size = ysize;
 
 	p = abd_to_buf(pdata);
 	q = abd_to_buf(qdata);
 	pxy = abd_to_buf(rr->rr_col[VDEV_RAIDZ_P].rc_abd);
 	qxy = abd_to_buf(rr->rr_col[VDEV_RAIDZ_Q].rc_abd);
 	xd = rr->rr_col[x].rc_abd;
 	yd = rr->rr_col[y].rc_abd;
 
 	/*
 	 * We now have:
 	 *	Pxy = P + D_x + D_y
 	 *	Qxy = Q + 2^(ndevs - 1 - x) * D_x + 2^(ndevs - 1 - y) * D_y
 	 *
 	 * We can then solve for D_x:
 	 *	D_x = A * (P + Pxy) + B * (Q + Qxy)
 	 * where
 	 *	A = 2^(x - y) * (2^(x - y) + 1)^-1
 	 *	B = 2^(ndevs - 1 - x) * (2^(x - y) + 1)^-1
 	 *
 	 * With D_x in hand, we can easily solve for D_y:
 	 *	D_y = P + Pxy + D_x
 	 */
 
 	a = vdev_raidz_pow2[255 + x - y];
 	b = vdev_raidz_pow2[255 - (rr->rr_cols - 1 - x)];
 	tmp = 255 - vdev_raidz_log2[a ^ 1];
 
 	aexp = vdev_raidz_log2[vdev_raidz_exp2(a, tmp)];
 	bexp = vdev_raidz_log2[vdev_raidz_exp2(b, tmp)];
 
 	ASSERT3U(xsize, >=, ysize);
 	struct reconst_pq_struct rpq = { p, q, pxy, qxy, aexp, bexp };
 
 	(void) abd_iterate_func2(xd, yd, 0, 0, ysize,
 	    vdev_raidz_reconst_pq_func, &rpq);
 	(void) abd_iterate_func(xd, ysize, xsize - ysize,
 	    vdev_raidz_reconst_pq_tail_func, &rpq);
 
 	abd_free(rr->rr_col[VDEV_RAIDZ_P].rc_abd);
 	abd_free(rr->rr_col[VDEV_RAIDZ_Q].rc_abd);
 
 	/*
 	 * Restore the saved parity data.
 	 */
 	rr->rr_col[VDEV_RAIDZ_P].rc_abd = pdata;
 	rr->rr_col[VDEV_RAIDZ_Q].rc_abd = qdata;
 }
 
 /*
  * In the general case of reconstruction, we must solve the system of linear
  * equations defined by the coefficients used to generate parity as well as
  * the contents of the data and parity disks. This can be expressed with
  * vectors for the original data (D) and the actual data (d) and parity (p)
  * and a matrix composed of the identity matrix (I) and a dispersal matrix (V):
  *
  *            __   __                     __     __
  *            |     |         __     __   |  p_0  |
  *            |  V  |         |  D_0  |   | p_m-1 |
  *            |     |    x    |   :   | = |  d_0  |
  *            |  I  |         | D_n-1 |   |   :   |
  *            |     |         ~~     ~~   | d_n-1 |
  *            ~~   ~~                     ~~     ~~
  *
  * I is simply a square identity matrix of size n, and V is a vandermonde
  * matrix defined by the coefficients we chose for the various parity columns
  * (1, 2, 4). Note that these values were chosen both for simplicity, speedy
  * computation as well as linear separability.
  *
  *      __               __               __     __
  *      |   1   ..  1 1 1 |               |  p_0  |
  *      | 2^n-1 ..  4 2 1 |   __     __   |   :   |
  *      | 4^n-1 .. 16 4 1 |   |  D_0  |   | p_m-1 |
  *      |   1   ..  0 0 0 |   |  D_1  |   |  d_0  |
  *      |   0   ..  0 0 0 | x |  D_2  | = |  d_1  |
  *      |   :       : : : |   |   :   |   |  d_2  |
  *      |   0   ..  1 0 0 |   | D_n-1 |   |   :   |
  *      |   0   ..  0 1 0 |   ~~     ~~   |   :   |
  *      |   0   ..  0 0 1 |               | d_n-1 |
  *      ~~               ~~               ~~     ~~
  *
  * Note that I, V, d, and p are known. To compute D, we must invert the
  * matrix and use the known data and parity values to reconstruct the unknown
  * data values. We begin by removing the rows in V|I and d|p that correspond
  * to failed or missing columns; we then make V|I square (n x n) and d|p
  * sized n by removing rows corresponding to unused parity from the bottom up
  * to generate (V|I)' and (d|p)'. We can then generate the inverse of (V|I)'
  * using Gauss-Jordan elimination. In the example below we use m=3 parity
  * columns, n=8 data columns, with errors in d_1, d_2, and p_1:
  *           __                               __
  *           |  1   1   1   1   1   1   1   1  |
  *           | 128  64  32  16  8   4   2   1  | <-----+-+-- missing disks
  *           |  19 205 116  29  64  16  4   1  |      / /
  *           |  1   0   0   0   0   0   0   0  |     / /
  *           |  0   1   0   0   0   0   0   0  | <--' /
  *  (V|I)  = |  0   0   1   0   0   0   0   0  | <---'
  *           |  0   0   0   1   0   0   0   0  |
  *           |  0   0   0   0   1   0   0   0  |
  *           |  0   0   0   0   0   1   0   0  |
  *           |  0   0   0   0   0   0   1   0  |
  *           |  0   0   0   0   0   0   0   1  |
  *           ~~                               ~~
  *           __                               __
  *           |  1   1   1   1   1   1   1   1  |
  *           | 128  64  32  16  8   4   2   1  |
  *           |  19 205 116  29  64  16  4   1  |
  *           |  1   0   0   0   0   0   0   0  |
  *           |  0   1   0   0   0   0   0   0  |
  *  (V|I)' = |  0   0   1   0   0   0   0   0  |
  *           |  0   0   0   1   0   0   0   0  |
  *           |  0   0   0   0   1   0   0   0  |
  *           |  0   0   0   0   0   1   0   0  |
  *           |  0   0   0   0   0   0   1   0  |
  *           |  0   0   0   0   0   0   0   1  |
  *           ~~                               ~~
  *
  * Here we employ Gauss-Jordan elimination to find the inverse of (V|I)'. We
  * have carefully chosen the seed values 1, 2, and 4 to ensure that this
  * matrix is not singular.
  * __                                                                 __
  * |  1   1   1   1   1   1   1   1     1   0   0   0   0   0   0   0  |
  * |  19 205 116  29  64  16  4   1     0   1   0   0   0   0   0   0  |
  * |  1   0   0   0   0   0   0   0     0   0   1   0   0   0   0   0  |
  * |  0   0   0   1   0   0   0   0     0   0   0   1   0   0   0   0  |
  * |  0   0   0   0   1   0   0   0     0   0   0   0   1   0   0   0  |
  * |  0   0   0   0   0   1   0   0     0   0   0   0   0   1   0   0  |
  * |  0   0   0   0   0   0   1   0     0   0   0   0   0   0   1   0  |
  * |  0   0   0   0   0   0   0   1     0   0   0   0   0   0   0   1  |
  * ~~                                                                 ~~
  * __                                                                 __
  * |  1   0   0   0   0   0   0   0     0   0   1   0   0   0   0   0  |
  * |  1   1   1   1   1   1   1   1     1   0   0   0   0   0   0   0  |
  * |  19 205 116  29  64  16  4   1     0   1   0   0   0   0   0   0  |
  * |  0   0   0   1   0   0   0   0     0   0   0   1   0   0   0   0  |
  * |  0   0   0   0   1   0   0   0     0   0   0   0   1   0   0   0  |
  * |  0   0   0   0   0   1   0   0     0   0   0   0   0   1   0   0  |
  * |  0   0   0   0   0   0   1   0     0   0   0   0   0   0   1   0  |
  * |  0   0   0   0   0   0   0   1     0   0   0   0   0   0   0   1  |
  * ~~                                                                 ~~
  * __                                                                 __
  * |  1   0   0   0   0   0   0   0     0   0   1   0   0   0   0   0  |
  * |  0   1   1   0   0   0   0   0     1   0   1   1   1   1   1   1  |
  * |  0  205 116  0   0   0   0   0     0   1   19  29  64  16  4   1  |
  * |  0   0   0   1   0   0   0   0     0   0   0   1   0   0   0   0  |
  * |  0   0   0   0   1   0   0   0     0   0   0   0   1   0   0   0  |
  * |  0   0   0   0   0   1   0   0     0   0   0   0   0   1   0   0  |
  * |  0   0   0   0   0   0   1   0     0   0   0   0   0   0   1   0  |
  * |  0   0   0   0   0   0   0   1     0   0   0   0   0   0   0   1  |
  * ~~                                                                 ~~
  * __                                                                 __
  * |  1   0   0   0   0   0   0   0     0   0   1   0   0   0   0   0  |
  * |  0   1   1   0   0   0   0   0     1   0   1   1   1   1   1   1  |
  * |  0   0  185  0   0   0   0   0    205  1  222 208 141 221 201 204 |
  * |  0   0   0   1   0   0   0   0     0   0   0   1   0   0   0   0  |
  * |  0   0   0   0   1   0   0   0     0   0   0   0   1   0   0   0  |
  * |  0   0   0   0   0   1   0   0     0   0   0   0   0   1   0   0  |
  * |  0   0   0   0   0   0   1   0     0   0   0   0   0   0   1   0  |
  * |  0   0   0   0   0   0   0   1     0   0   0   0   0   0   0   1  |
  * ~~                                                                 ~~
  * __                                                                 __
  * |  1   0   0   0   0   0   0   0     0   0   1   0   0   0   0   0  |
  * |  0   1   1   0   0   0   0   0     1   0   1   1   1   1   1   1  |
  * |  0   0   1   0   0   0   0   0    166 100  4   40 158 168 216 209 |
  * |  0   0   0   1   0   0   0   0     0   0   0   1   0   0   0   0  |
  * |  0   0   0   0   1   0   0   0     0   0   0   0   1   0   0   0  |
  * |  0   0   0   0   0   1   0   0     0   0   0   0   0   1   0   0  |
  * |  0   0   0   0   0   0   1   0     0   0   0   0   0   0   1   0  |
  * |  0   0   0   0   0   0   0   1     0   0   0   0   0   0   0   1  |
  * ~~                                                                 ~~
  * __                                                                 __
  * |  1   0   0   0   0   0   0   0     0   0   1   0   0   0   0   0  |
  * |  0   1   0   0   0   0   0   0    167 100  5   41 159 169 217 208 |
  * |  0   0   1   0   0   0   0   0    166 100  4   40 158 168 216 209 |
  * |  0   0   0   1   0   0   0   0     0   0   0   1   0   0   0   0  |
  * |  0   0   0   0   1   0   0   0     0   0   0   0   1   0   0   0  |
  * |  0   0   0   0   0   1   0   0     0   0   0   0   0   1   0   0  |
  * |  0   0   0   0   0   0   1   0     0   0   0   0   0   0   1   0  |
  * |  0   0   0   0   0   0   0   1     0   0   0   0   0   0   0   1  |
  * ~~                                                                 ~~
  *                   __                               __
  *                   |  0   0   1   0   0   0   0   0  |
  *                   | 167 100  5   41 159 169 217 208 |
  *                   | 166 100  4   40 158 168 216 209 |
  *       (V|I)'^-1 = |  0   0   0   1   0   0   0   0  |
  *                   |  0   0   0   0   1   0   0   0  |
  *                   |  0   0   0   0   0   1   0   0  |
  *                   |  0   0   0   0   0   0   1   0  |
  *                   |  0   0   0   0   0   0   0   1  |
  *                   ~~                               ~~
  *
  * We can then simply compute D = (V|I)'^-1 x (d|p)' to discover the values
  * of the missing data.
  *
  * As is apparent from the example above, the only non-trivial rows in the
  * inverse matrix correspond to the data disks that we're trying to
  * reconstruct. Indeed, those are the only rows we need as the others would
  * only be useful for reconstructing data known or assumed to be valid. For
  * that reason, we only build the coefficients in the rows that correspond to
  * targeted columns.
  */
 
 static void
 vdev_raidz_matrix_init(raidz_row_t *rr, int n, int nmap, int *map,
     uint8_t **rows)
 {
 	int i, j;
 	int pow;
 
 	ASSERT(n == rr->rr_cols - rr->rr_firstdatacol);
 
 	/*
 	 * Fill in the missing rows of interest.
 	 */
 	for (i = 0; i < nmap; i++) {
 		ASSERT3S(0, <=, map[i]);
 		ASSERT3S(map[i], <=, 2);
 
 		pow = map[i] * n;
 		if (pow > 255)
 			pow -= 255;
 		ASSERT(pow <= 255);
 
 		for (j = 0; j < n; j++) {
 			pow -= map[i];
 			if (pow < 0)
 				pow += 255;
 			rows[i][j] = vdev_raidz_pow2[pow];
 		}
 	}
 }
 
 static void
 vdev_raidz_matrix_invert(raidz_row_t *rr, int n, int nmissing, int *missing,
     uint8_t **rows, uint8_t **invrows, const uint8_t *used)
 {
 	int i, j, ii, jj;
 	uint8_t log;
 
 	/*
 	 * Assert that the first nmissing entries from the array of used
 	 * columns correspond to parity columns and that subsequent entries
 	 * correspond to data columns.
 	 */
 	for (i = 0; i < nmissing; i++) {
 		ASSERT3S(used[i], <, rr->rr_firstdatacol);
 	}
 	for (; i < n; i++) {
 		ASSERT3S(used[i], >=, rr->rr_firstdatacol);
 	}
 
 	/*
 	 * First initialize the storage where we'll compute the inverse rows.
 	 */
 	for (i = 0; i < nmissing; i++) {
 		for (j = 0; j < n; j++) {
 			invrows[i][j] = (i == j) ? 1 : 0;
 		}
 	}
 
 	/*
 	 * Subtract all trivial rows from the rows of consequence.
 	 */
 	for (i = 0; i < nmissing; i++) {
 		for (j = nmissing; j < n; j++) {
 			ASSERT3U(used[j], >=, rr->rr_firstdatacol);
 			jj = used[j] - rr->rr_firstdatacol;
 			ASSERT3S(jj, <, n);
 			invrows[i][j] = rows[i][jj];
 			rows[i][jj] = 0;
 		}
 	}
 
 	/*
 	 * For each of the rows of interest, we must normalize it and subtract
 	 * a multiple of it from the other rows.
 	 */
 	for (i = 0; i < nmissing; i++) {
 		for (j = 0; j < missing[i]; j++) {
 			ASSERT0(rows[i][j]);
 		}
 		ASSERT3U(rows[i][missing[i]], !=, 0);
 
 		/*
 		 * Compute the inverse of the first element and multiply each
 		 * element in the row by that value.
 		 */
 		log = 255 - vdev_raidz_log2[rows[i][missing[i]]];
 
 		for (j = 0; j < n; j++) {
 			rows[i][j] = vdev_raidz_exp2(rows[i][j], log);
 			invrows[i][j] = vdev_raidz_exp2(invrows[i][j], log);
 		}
 
 		for (ii = 0; ii < nmissing; ii++) {
 			if (i == ii)
 				continue;
 
 			ASSERT3U(rows[ii][missing[i]], !=, 0);
 
 			log = vdev_raidz_log2[rows[ii][missing[i]]];
 
 			for (j = 0; j < n; j++) {
 				rows[ii][j] ^=
 				    vdev_raidz_exp2(rows[i][j], log);
 				invrows[ii][j] ^=
 				    vdev_raidz_exp2(invrows[i][j], log);
 			}
 		}
 	}
 
 	/*
 	 * Verify that the data that is left in the rows are properly part of
 	 * an identity matrix.
 	 */
 	for (i = 0; i < nmissing; i++) {
 		for (j = 0; j < n; j++) {
 			if (j == missing[i]) {
 				ASSERT3U(rows[i][j], ==, 1);
 			} else {
 				ASSERT0(rows[i][j]);
 			}
 		}
 	}
 }
 
 static void
 vdev_raidz_matrix_reconstruct(raidz_row_t *rr, int n, int nmissing,
     int *missing, uint8_t **invrows, const uint8_t *used)
 {
 	int i, j, x, cc, c;
 	uint8_t *src;
 	uint64_t ccount;
 	uint8_t *dst[VDEV_RAIDZ_MAXPARITY] = { NULL };
 	uint64_t dcount[VDEV_RAIDZ_MAXPARITY] = { 0 };
 	uint8_t log = 0;
 	uint8_t val;
 	int ll;
 	uint8_t *invlog[VDEV_RAIDZ_MAXPARITY];
 	uint8_t *p, *pp;
 	size_t psize;
 
 	psize = sizeof (invlog[0][0]) * n * nmissing;
 	p = kmem_alloc(psize, KM_SLEEP);
 
 	for (pp = p, i = 0; i < nmissing; i++) {
 		invlog[i] = pp;
 		pp += n;
 	}
 
 	for (i = 0; i < nmissing; i++) {
 		for (j = 0; j < n; j++) {
 			ASSERT3U(invrows[i][j], !=, 0);
 			invlog[i][j] = vdev_raidz_log2[invrows[i][j]];
 		}
 	}
 
 	for (i = 0; i < n; i++) {
 		c = used[i];
 		ASSERT3U(c, <, rr->rr_cols);
 
 		ccount = rr->rr_col[c].rc_size;
 		ASSERT(ccount >= rr->rr_col[missing[0]].rc_size || i > 0);
 		if (ccount == 0)
 			continue;
 		src = abd_to_buf(rr->rr_col[c].rc_abd);
 		for (j = 0; j < nmissing; j++) {
 			cc = missing[j] + rr->rr_firstdatacol;
 			ASSERT3U(cc, >=, rr->rr_firstdatacol);
 			ASSERT3U(cc, <, rr->rr_cols);
 			ASSERT3U(cc, !=, c);
 
 			dcount[j] = rr->rr_col[cc].rc_size;
 			if (dcount[j] != 0)
 				dst[j] = abd_to_buf(rr->rr_col[cc].rc_abd);
 		}
 
 		for (x = 0; x < ccount; x++, src++) {
 			if (*src != 0)
 				log = vdev_raidz_log2[*src];
 
 			for (cc = 0; cc < nmissing; cc++) {
 				if (x >= dcount[cc])
 					continue;
 
 				if (*src == 0) {
 					val = 0;
 				} else {
 					if ((ll = log + invlog[cc][i]) >= 255)
 						ll -= 255;
 					val = vdev_raidz_pow2[ll];
 				}
 
 				if (i == 0)
 					dst[cc][x] = val;
 				else
 					dst[cc][x] ^= val;
 			}
 		}
 	}
 
 	kmem_free(p, psize);
 }
 
 static void
 vdev_raidz_reconstruct_general(raidz_row_t *rr, int *tgts, int ntgts)
 {
 	int i, c, t, tt;
 	unsigned int n;
 	unsigned int nmissing_rows;
 	int missing_rows[VDEV_RAIDZ_MAXPARITY];
 	int parity_map[VDEV_RAIDZ_MAXPARITY];
 	uint8_t *p, *pp;
 	size_t psize;
 	uint8_t *rows[VDEV_RAIDZ_MAXPARITY];
 	uint8_t *invrows[VDEV_RAIDZ_MAXPARITY];
 	uint8_t *used;
 
 	abd_t **bufs = NULL;
 
 	if (zfs_flags & ZFS_DEBUG_RAIDZ_RECONSTRUCT)
 		zfs_dbgmsg("reconstruct_general(rm=%px ntgts=%u)", rr, ntgts);
 	/*
 	 * Matrix reconstruction can't use scatter ABDs yet, so we allocate
 	 * temporary linear ABDs if any non-linear ABDs are found.
 	 */
 	for (i = rr->rr_firstdatacol; i < rr->rr_cols; i++) {
 		ASSERT(rr->rr_col[i].rc_abd != NULL);
 		if (!abd_is_linear(rr->rr_col[i].rc_abd)) {
 			bufs = kmem_alloc(rr->rr_cols * sizeof (abd_t *),
 			    KM_PUSHPAGE);
 
 			for (c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
 				raidz_col_t *col = &rr->rr_col[c];
 
 				bufs[c] = col->rc_abd;
 				if (bufs[c] != NULL) {
 					col->rc_abd = abd_alloc_linear(
 					    col->rc_size, B_TRUE);
 					abd_copy(col->rc_abd, bufs[c],
 					    col->rc_size);
 				}
 			}
 
 			break;
 		}
 	}
 
 	n = rr->rr_cols - rr->rr_firstdatacol;
 
 	/*
 	 * Figure out which data columns are missing.
 	 */
 	nmissing_rows = 0;
 	for (t = 0; t < ntgts; t++) {
 		if (tgts[t] >= rr->rr_firstdatacol) {
 			missing_rows[nmissing_rows++] =
 			    tgts[t] - rr->rr_firstdatacol;
 		}
 	}
 
 	/*
 	 * Figure out which parity columns to use to help generate the missing
 	 * data columns.
 	 */
 	for (tt = 0, c = 0, i = 0; i < nmissing_rows; c++) {
 		ASSERT(tt < ntgts);
 		ASSERT(c < rr->rr_firstdatacol);
 
 		/*
 		 * Skip any targeted parity columns.
 		 */
 		if (c == tgts[tt]) {
 			tt++;
 			continue;
 		}
 
 		parity_map[i] = c;
 		i++;
 	}
 
 	psize = (sizeof (rows[0][0]) + sizeof (invrows[0][0])) *
 	    nmissing_rows * n + sizeof (used[0]) * n;
 	p = kmem_alloc(psize, KM_SLEEP);
 
 	for (pp = p, i = 0; i < nmissing_rows; i++) {
 		rows[i] = pp;
 		pp += n;
 		invrows[i] = pp;
 		pp += n;
 	}
 	used = pp;
 
 	for (i = 0; i < nmissing_rows; i++) {
 		used[i] = parity_map[i];
 	}
 
 	for (tt = 0, c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
 		if (tt < nmissing_rows &&
 		    c == missing_rows[tt] + rr->rr_firstdatacol) {
 			tt++;
 			continue;
 		}
 
 		ASSERT3S(i, <, n);
 		used[i] = c;
 		i++;
 	}
 
 	/*
 	 * Initialize the interesting rows of the matrix.
 	 */
 	vdev_raidz_matrix_init(rr, n, nmissing_rows, parity_map, rows);
 
 	/*
 	 * Invert the matrix.
 	 */
 	vdev_raidz_matrix_invert(rr, n, nmissing_rows, missing_rows, rows,
 	    invrows, used);
 
 	/*
 	 * Reconstruct the missing data using the generated matrix.
 	 */
 	vdev_raidz_matrix_reconstruct(rr, n, nmissing_rows, missing_rows,
 	    invrows, used);
 
 	kmem_free(p, psize);
 
 	/*
 	 * copy back from temporary linear abds and free them
 	 */
 	if (bufs) {
 		for (c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
 			raidz_col_t *col = &rr->rr_col[c];
 
 			if (bufs[c] != NULL) {
 				abd_copy(bufs[c], col->rc_abd, col->rc_size);
 				abd_free(col->rc_abd);
 			}
 			col->rc_abd = bufs[c];
 		}
 		kmem_free(bufs, rr->rr_cols * sizeof (abd_t *));
 	}
 }
 
 static void
 vdev_raidz_reconstruct_row(raidz_map_t *rm, raidz_row_t *rr,
     const int *t, int nt)
 {
 	int tgts[VDEV_RAIDZ_MAXPARITY], *dt;
 	int ntgts;
 	int i, c, ret;
 	int nbadparity, nbaddata;
 	int parity_valid[VDEV_RAIDZ_MAXPARITY];
 
 	if (zfs_flags & ZFS_DEBUG_RAIDZ_RECONSTRUCT) {
 		zfs_dbgmsg("reconstruct(rm=%px nt=%u cols=%u md=%u mp=%u)",
 		    rr, nt, (int)rr->rr_cols, (int)rr->rr_missingdata,
 		    (int)rr->rr_missingparity);
 	}
 
 	nbadparity = rr->rr_firstdatacol;
 	nbaddata = rr->rr_cols - nbadparity;
 	ntgts = 0;
 	for (i = 0, c = 0; c < rr->rr_cols; c++) {
 		if (zfs_flags & ZFS_DEBUG_RAIDZ_RECONSTRUCT) {
 			zfs_dbgmsg("reconstruct(rm=%px col=%u devid=%u "
 			    "offset=%llx error=%u)",
 			    rr, c, (int)rr->rr_col[c].rc_devidx,
 			    (long long)rr->rr_col[c].rc_offset,
 			    (int)rr->rr_col[c].rc_error);
 		}
 		if (c < rr->rr_firstdatacol)
 			parity_valid[c] = B_FALSE;
 
 		if (i < nt && c == t[i]) {
 			tgts[ntgts++] = c;
 			i++;
 		} else if (rr->rr_col[c].rc_error != 0) {
 			tgts[ntgts++] = c;
 		} else if (c >= rr->rr_firstdatacol) {
 			nbaddata--;
 		} else {
 			parity_valid[c] = B_TRUE;
 			nbadparity--;
 		}
 	}
 
 	ASSERT(ntgts >= nt);
 	ASSERT(nbaddata >= 0);
 	ASSERT(nbaddata + nbadparity == ntgts);
 
 	dt = &tgts[nbadparity];
 
 	/* Reconstruct using the new math implementation */
 	ret = vdev_raidz_math_reconstruct(rm, rr, parity_valid, dt, nbaddata);
 	if (ret != RAIDZ_ORIGINAL_IMPL)
 		return;
 
 	/*
 	 * See if we can use any of our optimized reconstruction routines.
 	 */
 	switch (nbaddata) {
 	case 1:
 		if (parity_valid[VDEV_RAIDZ_P]) {
 			vdev_raidz_reconstruct_p(rr, dt, 1);
 			return;
 		}
 
 		ASSERT(rr->rr_firstdatacol > 1);
 
 		if (parity_valid[VDEV_RAIDZ_Q]) {
 			vdev_raidz_reconstruct_q(rr, dt, 1);
 			return;
 		}
 
 		ASSERT(rr->rr_firstdatacol > 2);
 		break;
 
 	case 2:
 		ASSERT(rr->rr_firstdatacol > 1);
 
 		if (parity_valid[VDEV_RAIDZ_P] &&
 		    parity_valid[VDEV_RAIDZ_Q]) {
 			vdev_raidz_reconstruct_pq(rr, dt, 2);
 			return;
 		}
 
 		ASSERT(rr->rr_firstdatacol > 2);
 
 		break;
 	}
 
 	vdev_raidz_reconstruct_general(rr, tgts, ntgts);
 }
 
 static int
 vdev_raidz_open(vdev_t *vd, uint64_t *asize, uint64_t *max_asize,
     uint64_t *logical_ashift, uint64_t *physical_ashift)
 {
 	vdev_raidz_t *vdrz = vd->vdev_tsd;
 	uint64_t nparity = vdrz->vd_nparity;
 	int c;
 	int lasterror = 0;
 	int numerrors = 0;
 
 	ASSERT(nparity > 0);
 
 	if (nparity > VDEV_RAIDZ_MAXPARITY ||
 	    vd->vdev_children < nparity + 1) {
 		vd->vdev_stat.vs_aux = VDEV_AUX_BAD_LABEL;
 		return (SET_ERROR(EINVAL));
 	}
 
 	vdev_open_children(vd);
 
 	for (c = 0; c < vd->vdev_children; c++) {
 		vdev_t *cvd = vd->vdev_child[c];
 
 		if (cvd->vdev_open_error != 0) {
 			lasterror = cvd->vdev_open_error;
 			numerrors++;
 			continue;
 		}
 
 		*asize = MIN(*asize - 1, cvd->vdev_asize - 1) + 1;
 		*max_asize = MIN(*max_asize - 1, cvd->vdev_max_asize - 1) + 1;
 		*logical_ashift = MAX(*logical_ashift, cvd->vdev_ashift);
 	}
 	for (c = 0; c < vd->vdev_children; c++) {
 		vdev_t *cvd = vd->vdev_child[c];
 
 		if (cvd->vdev_open_error != 0)
 			continue;
 		*physical_ashift = vdev_best_ashift(*logical_ashift,
 		    *physical_ashift, cvd->vdev_physical_ashift);
 	}
 
 	if (vd->vdev_rz_expanding) {
 		*asize *= vd->vdev_children - 1;
 		*max_asize *= vd->vdev_children - 1;
 
 		vd->vdev_min_asize = *asize;
 	} else {
 		*asize *= vd->vdev_children;
 		*max_asize *= vd->vdev_children;
 	}
 
 	if (numerrors > nparity) {
 		vd->vdev_stat.vs_aux = VDEV_AUX_NO_REPLICAS;
 		return (lasterror);
 	}
 
 	return (0);
 }
 
 static void
 vdev_raidz_close(vdev_t *vd)
 {
 	for (int c = 0; c < vd->vdev_children; c++) {
 		if (vd->vdev_child[c] != NULL)
 			vdev_close(vd->vdev_child[c]);
 	}
 }
 
 /*
  * Return the logical width to use, given the txg in which the allocation
  * happened.  Note that BP_GET_BIRTH() is usually the txg in which the
  * BP was allocated.  Remapped BP's (that were relocated due to device
  * removal, see remap_blkptr_cb()), will have a more recent physical birth
  * which reflects when the BP was relocated, but we can ignore these because
  * they can't be on RAIDZ (device removal doesn't support RAIDZ).
  */
 static uint64_t
 vdev_raidz_get_logical_width(vdev_raidz_t *vdrz, uint64_t txg)
 {
 	reflow_node_t lookup = {
 		.re_txg = txg,
 	};
 	avl_index_t where;
 
 	uint64_t width;
 	mutex_enter(&vdrz->vd_expand_lock);
 	reflow_node_t *re = avl_find(&vdrz->vd_expand_txgs, &lookup, &where);
 	if (re != NULL) {
 		width = re->re_logical_width;
 	} else {
 		re = avl_nearest(&vdrz->vd_expand_txgs, where, AVL_BEFORE);
 		if (re != NULL)
 			width = re->re_logical_width;
 		else
 			width = vdrz->vd_original_width;
 	}
 	mutex_exit(&vdrz->vd_expand_lock);
 	return (width);
 }
 
 /*
  * Note: If the RAIDZ vdev has been expanded, older BP's may have allocated
  * more space due to the lower data-to-parity ratio.  In this case it's
  * important to pass in the correct txg.  Note that vdev_gang_header_asize()
  * relies on a constant asize for psize=SPA_GANGBLOCKSIZE=SPA_MINBLOCKSIZE,
  * regardless of txg.  This is assured because for a single data sector, we
  * allocate P+1 sectors regardless of width ("cols", which is at least P+1).
  */
 static uint64_t
 vdev_raidz_asize(vdev_t *vd, uint64_t psize, uint64_t txg)
 {
 	vdev_raidz_t *vdrz = vd->vdev_tsd;
 	uint64_t asize;
 	uint64_t ashift = vd->vdev_top->vdev_ashift;
 	uint64_t cols = vdrz->vd_original_width;
 	uint64_t nparity = vdrz->vd_nparity;
 
 	cols = vdev_raidz_get_logical_width(vdrz, txg);
 
 	asize = ((psize - 1) >> ashift) + 1;
 	asize += nparity * ((asize + cols - nparity - 1) / (cols - nparity));
 	asize = roundup(asize, nparity + 1) << ashift;
 
 #ifdef ZFS_DEBUG
 	uint64_t asize_new = ((psize - 1) >> ashift) + 1;
 	uint64_t ncols_new = vdrz->vd_physical_width;
 	asize_new += nparity * ((asize_new + ncols_new - nparity - 1) /
 	    (ncols_new - nparity));
 	asize_new = roundup(asize_new, nparity + 1) << ashift;
 	VERIFY3U(asize_new, <=, asize);
 #endif
 
 	return (asize);
 }
 
 /*
  * The allocatable space for a raidz vdev is N * sizeof(smallest child)
  * so each child must provide at least 1/Nth of its asize.
  */
 static uint64_t
 vdev_raidz_min_asize(vdev_t *vd)
 {
 	return ((vd->vdev_min_asize + vd->vdev_children - 1) /
 	    vd->vdev_children);
 }
 
 void
 vdev_raidz_child_done(zio_t *zio)
 {
 	raidz_col_t *rc = zio->io_private;
 
 	ASSERT3P(rc->rc_abd, !=, NULL);
 	rc->rc_error = zio->io_error;
 	rc->rc_tried = 1;
 	rc->rc_skipped = 0;
 }
 
 static void
 vdev_raidz_shadow_child_done(zio_t *zio)
 {
 	raidz_col_t *rc = zio->io_private;
 
 	rc->rc_shadow_error = zio->io_error;
 }
 
 static void
 vdev_raidz_io_verify(zio_t *zio, raidz_map_t *rm, raidz_row_t *rr, int col)
 {
 	(void) rm;
 #ifdef ZFS_DEBUG
 	range_seg64_t logical_rs, physical_rs, remain_rs;
 	logical_rs.rs_start = rr->rr_offset;
 	logical_rs.rs_end = logical_rs.rs_start +
 	    vdev_raidz_asize(zio->io_vd, rr->rr_size,
 	    BP_GET_BIRTH(zio->io_bp));
 
 	raidz_col_t *rc = &rr->rr_col[col];
 	vdev_t *cvd = zio->io_vd->vdev_child[rc->rc_devidx];
 
 	vdev_xlate(cvd, &logical_rs, &physical_rs, &remain_rs);
 	ASSERT(vdev_xlate_is_empty(&remain_rs));
 	if (vdev_xlate_is_empty(&physical_rs)) {
 		/*
 		 * If we are in the middle of expansion, the
 		 * physical->logical mapping is changing so vdev_xlate()
 		 * can't give us a reliable answer.
 		 */
 		return;
 	}
 	ASSERT3U(rc->rc_offset, ==, physical_rs.rs_start);
 	ASSERT3U(rc->rc_offset, <, physical_rs.rs_end);
 	/*
 	 * It would be nice to assert that rs_end is equal
 	 * to rc_offset + rc_size but there might be an
 	 * optional I/O at the end that is not accounted in
 	 * rc_size.
 	 */
 	if (physical_rs.rs_end > rc->rc_offset + rc->rc_size) {
 		ASSERT3U(physical_rs.rs_end, ==, rc->rc_offset +
 		    rc->rc_size + (1 << zio->io_vd->vdev_top->vdev_ashift));
 	} else {
 		ASSERT3U(physical_rs.rs_end, ==, rc->rc_offset + rc->rc_size);
 	}
 #endif
 }
 
 static void
 vdev_raidz_io_start_write(zio_t *zio, raidz_row_t *rr)
 {
 	vdev_t *vd = zio->io_vd;
 	raidz_map_t *rm = zio->io_vsd;
 
 	vdev_raidz_generate_parity_row(rm, rr);
 
 	for (int c = 0; c < rr->rr_scols; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 		vdev_t *cvd = vd->vdev_child[rc->rc_devidx];
 
 		/* Verify physical to logical translation */
 		vdev_raidz_io_verify(zio, rm, rr, c);
 
 		if (rc->rc_size == 0)
 			continue;
 
 		ASSERT3U(rc->rc_offset + rc->rc_size, <,
 		    cvd->vdev_psize - VDEV_LABEL_END_SIZE);
 
 		ASSERT3P(rc->rc_abd, !=, NULL);
 		zio_nowait(zio_vdev_child_io(zio, NULL, cvd,
 		    rc->rc_offset, rc->rc_abd,
 		    abd_get_size(rc->rc_abd), zio->io_type,
 		    zio->io_priority, 0, vdev_raidz_child_done, rc));
 
 		if (rc->rc_shadow_devidx != INT_MAX) {
 			vdev_t *cvd2 = vd->vdev_child[rc->rc_shadow_devidx];
 
 			ASSERT3U(
 			    rc->rc_shadow_offset + abd_get_size(rc->rc_abd), <,
 			    cvd2->vdev_psize - VDEV_LABEL_END_SIZE);
 
 			zio_nowait(zio_vdev_child_io(zio, NULL, cvd2,
 			    rc->rc_shadow_offset, rc->rc_abd,
 			    abd_get_size(rc->rc_abd),
 			    zio->io_type, zio->io_priority, 0,
 			    vdev_raidz_shadow_child_done, rc));
 		}
 	}
 }
 
 /*
  * Generate optional I/Os for skip sectors to improve aggregation contiguity.
  * This only works for vdev_raidz_map_alloc() (not _expanded()).
  */
 static void
 raidz_start_skip_writes(zio_t *zio)
 {
 	vdev_t *vd = zio->io_vd;
 	uint64_t ashift = vd->vdev_top->vdev_ashift;
 	raidz_map_t *rm = zio->io_vsd;
 	ASSERT3U(rm->rm_nrows, ==, 1);
 	raidz_row_t *rr = rm->rm_row[0];
 	for (int c = 0; c < rr->rr_scols; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 		vdev_t *cvd = vd->vdev_child[rc->rc_devidx];
 		if (rc->rc_size != 0)
 			continue;
 		ASSERT3P(rc->rc_abd, ==, NULL);
 
 		ASSERT3U(rc->rc_offset, <,
 		    cvd->vdev_psize - VDEV_LABEL_END_SIZE);
 
 		zio_nowait(zio_vdev_child_io(zio, NULL, cvd, rc->rc_offset,
 		    NULL, 1ULL << ashift, zio->io_type, zio->io_priority,
 		    ZIO_FLAG_NODATA | ZIO_FLAG_OPTIONAL, NULL, NULL));
 	}
 }
 
 static void
 vdev_raidz_io_start_read_row(zio_t *zio, raidz_row_t *rr, boolean_t forceparity)
 {
 	vdev_t *vd = zio->io_vd;
 
 	/*
 	 * Iterate over the columns in reverse order so that we hit the parity
 	 * last -- any errors along the way will force us to read the parity.
 	 */
 	for (int c = rr->rr_cols - 1; c >= 0; c--) {
 		raidz_col_t *rc = &rr->rr_col[c];
 		if (rc->rc_size == 0)
 			continue;
 		vdev_t *cvd = vd->vdev_child[rc->rc_devidx];
 		if (!vdev_readable(cvd)) {
 			if (c >= rr->rr_firstdatacol)
 				rr->rr_missingdata++;
 			else
 				rr->rr_missingparity++;
 			rc->rc_error = SET_ERROR(ENXIO);
 			rc->rc_tried = 1;	/* don't even try */
 			rc->rc_skipped = 1;
 			continue;
 		}
 		if (vdev_dtl_contains(cvd, DTL_MISSING, zio->io_txg, 1)) {
 			if (c >= rr->rr_firstdatacol)
 				rr->rr_missingdata++;
 			else
 				rr->rr_missingparity++;
 			rc->rc_error = SET_ERROR(ESTALE);
 			rc->rc_skipped = 1;
 			continue;
 		}
 		if (forceparity ||
 		    c >= rr->rr_firstdatacol || rr->rr_missingdata > 0 ||
 		    (zio->io_flags & (ZIO_FLAG_SCRUB | ZIO_FLAG_RESILVER))) {
 			zio_nowait(zio_vdev_child_io(zio, NULL, cvd,
 			    rc->rc_offset, rc->rc_abd, rc->rc_size,
 			    zio->io_type, zio->io_priority, 0,
 			    vdev_raidz_child_done, rc));
 		}
 	}
 }
 
 static void
 vdev_raidz_io_start_read_phys_cols(zio_t *zio, raidz_map_t *rm)
 {
 	vdev_t *vd = zio->io_vd;
 
 	for (int i = 0; i < rm->rm_nphys_cols; i++) {
 		raidz_col_t *prc = &rm->rm_phys_col[i];
 		if (prc->rc_size == 0)
 			continue;
 
 		ASSERT3U(prc->rc_devidx, ==, i);
 		vdev_t *cvd = vd->vdev_child[i];
 		if (!vdev_readable(cvd)) {
 			prc->rc_error = SET_ERROR(ENXIO);
 			prc->rc_tried = 1;	/* don't even try */
 			prc->rc_skipped = 1;
 			continue;
 		}
 		if (vdev_dtl_contains(cvd, DTL_MISSING, zio->io_txg, 1)) {
 			prc->rc_error = SET_ERROR(ESTALE);
 			prc->rc_skipped = 1;
 			continue;
 		}
 		zio_nowait(zio_vdev_child_io(zio, NULL, cvd,
 		    prc->rc_offset, prc->rc_abd, prc->rc_size,
 		    zio->io_type, zio->io_priority, 0,
 		    vdev_raidz_child_done, prc));
 	}
 }
 
 static void
 vdev_raidz_io_start_read(zio_t *zio, raidz_map_t *rm)
 {
 	/*
 	 * If there are multiple rows, we will be hitting
 	 * all disks, so go ahead and read the parity so
 	 * that we are reading in decent size chunks.
 	 */
 	boolean_t forceparity = rm->rm_nrows > 1;
 
 	if (rm->rm_phys_col) {
 		vdev_raidz_io_start_read_phys_cols(zio, rm);
 	} else {
 		for (int i = 0; i < rm->rm_nrows; i++) {
 			raidz_row_t *rr = rm->rm_row[i];
 			vdev_raidz_io_start_read_row(zio, rr, forceparity);
 		}
 	}
 }
 
 /*
  * Start an IO operation on a RAIDZ VDev
  *
  * Outline:
  * - For write operations:
  *   1. Generate the parity data
  *   2. Create child zio write operations to each column's vdev, for both
  *      data and parity.
  *   3. If the column skips any sectors for padding, create optional dummy
  *      write zio children for those areas to improve aggregation continuity.
  * - For read operations:
  *   1. Create child zio read operations to each data column's vdev to read
  *      the range of data required for zio.
  *   2. If this is a scrub or resilver operation, or if any of the data
  *      vdevs have had errors, then create zio read operations to the parity
  *      columns' VDevs as well.
  */
 static void
 vdev_raidz_io_start(zio_t *zio)
 {
 	vdev_t *vd = zio->io_vd;
 	vdev_t *tvd = vd->vdev_top;
 	vdev_raidz_t *vdrz = vd->vdev_tsd;
 	raidz_map_t *rm;
 
 	uint64_t logical_width = vdev_raidz_get_logical_width(vdrz,
 	    BP_GET_BIRTH(zio->io_bp));
 	if (logical_width != vdrz->vd_physical_width) {
 		zfs_locked_range_t *lr = NULL;
 		uint64_t synced_offset = UINT64_MAX;
 		uint64_t next_offset = UINT64_MAX;
 		boolean_t use_scratch = B_FALSE;
 		/*
 		 * Note: when the expansion is completing, we set
 		 * vre_state=DSS_FINISHED (in raidz_reflow_complete_sync())
 		 * in a later txg than when we last update spa_ubsync's state
 		 * (see the end of spa_raidz_expand_thread()).  Therefore we
 		 * may see vre_state!=SCANNING before
 		 * VDEV_TOP_ZAP_RAIDZ_EXPAND_STATE=DSS_FINISHED is reflected
 		 * on disk, but the copying progress has been synced to disk
 		 * (and reflected in spa_ubsync).  In this case it's fine to
 		 * treat the expansion as completed, since if we crash there's
 		 * no additional copying to do.
 		 */
 		if (vdrz->vn_vre.vre_state == DSS_SCANNING) {
 			ASSERT3P(vd->vdev_spa->spa_raidz_expand, ==,
 			    &vdrz->vn_vre);
 			lr = zfs_rangelock_enter(&vdrz->vn_vre.vre_rangelock,
 			    zio->io_offset, zio->io_size, RL_READER);
 			use_scratch =
 			    (RRSS_GET_STATE(&vd->vdev_spa->spa_ubsync) ==
 			    RRSS_SCRATCH_VALID);
 			synced_offset =
 			    RRSS_GET_OFFSET(&vd->vdev_spa->spa_ubsync);
 			next_offset = vdrz->vn_vre.vre_offset;
 			/*
 			 * If we haven't resumed expanding since importing the
 			 * pool, vre_offset won't have been set yet.  In
 			 * this case the next offset to be copied is the same
 			 * as what was synced.
 			 */
 			if (next_offset == UINT64_MAX) {
 				next_offset = synced_offset;
 			}
 		}
 		if (use_scratch) {
 			zfs_dbgmsg("zio=%px %s io_offset=%llu offset_synced="
 			    "%lld next_offset=%lld use_scratch=%u",
 			    zio,
 			    zio->io_type == ZIO_TYPE_WRITE ? "WRITE" : "READ",
 			    (long long)zio->io_offset,
 			    (long long)synced_offset,
 			    (long long)next_offset,
 			    use_scratch);
 		}
 
 		rm = vdev_raidz_map_alloc_expanded(zio,
 		    tvd->vdev_ashift, vdrz->vd_physical_width,
 		    logical_width, vdrz->vd_nparity,
 		    synced_offset, next_offset, use_scratch);
 		rm->rm_lr = lr;
 	} else {
 		rm = vdev_raidz_map_alloc(zio,
 		    tvd->vdev_ashift, logical_width, vdrz->vd_nparity);
 	}
 	rm->rm_original_width = vdrz->vd_original_width;
 
 	zio->io_vsd = rm;
 	zio->io_vsd_ops = &vdev_raidz_vsd_ops;
 	if (zio->io_type == ZIO_TYPE_WRITE) {
 		for (int i = 0; i < rm->rm_nrows; i++) {
 			vdev_raidz_io_start_write(zio, rm->rm_row[i]);
 		}
 
 		if (logical_width == vdrz->vd_physical_width) {
 			raidz_start_skip_writes(zio);
 		}
 	} else {
 		ASSERT(zio->io_type == ZIO_TYPE_READ);
 		vdev_raidz_io_start_read(zio, rm);
 	}
 
 	zio_execute(zio);
 }
 
 /*
  * Report a checksum error for a child of a RAID-Z device.
  */
 void
 vdev_raidz_checksum_error(zio_t *zio, raidz_col_t *rc, abd_t *bad_data)
 {
 	vdev_t *vd = zio->io_vd->vdev_child[rc->rc_devidx];
 
 	if (!(zio->io_flags & ZIO_FLAG_SPECULATIVE) &&
 	    zio->io_priority != ZIO_PRIORITY_REBUILD) {
 		zio_bad_cksum_t zbc;
 		raidz_map_t *rm = zio->io_vsd;
 
 		zbc.zbc_has_cksum = 0;
 		zbc.zbc_injected = rm->rm_ecksuminjected;
 
 		mutex_enter(&vd->vdev_stat_lock);
 		vd->vdev_stat.vs_checksum_errors++;
 		mutex_exit(&vd->vdev_stat_lock);
 		(void) zfs_ereport_post_checksum(zio->io_spa, vd,
 		    &zio->io_bookmark, zio, rc->rc_offset, rc->rc_size,
 		    rc->rc_abd, bad_data, &zbc);
 	}
 }
 
 /*
  * We keep track of whether or not there were any injected errors, so that
  * any ereports we generate can note it.
  */
 static int
 raidz_checksum_verify(zio_t *zio)
 {
 	zio_bad_cksum_t zbc = {0};
 	raidz_map_t *rm = zio->io_vsd;
 
 	int ret = zio_checksum_error(zio, &zbc);
+	/*
+	 * Any Direct I/O read that has a checksum error must be treated as
+	 * suspicious as the contents of the buffer could be getting
+	 * manipulated while the I/O is taking place. The checksum verify error
+	 * will be reported to the top-level RAIDZ VDEV.
+	 */
+	if (zio->io_flags & ZIO_FLAG_DIO_READ && ret == ECKSUM) {
+		zio->io_error = ret;
+		zio->io_flags |= ZIO_FLAG_DIO_CHKSUM_ERR;
+		zio_dio_chksum_verify_error_report(zio);
+		zio_checksum_verified(zio);
+		return (0);
+	}
+
 	if (ret != 0 && zbc.zbc_injected != 0)
 		rm->rm_ecksuminjected = 1;
 
 	return (ret);
 }
 
 /*
  * Generate the parity from the data columns. If we tried and were able to
  * read the parity without error, verify that the generated parity matches the
  * data we read. If it doesn't, we fire off a checksum error. Return the
  * number of such failures.
  */
 static int
 raidz_parity_verify(zio_t *zio, raidz_row_t *rr)
 {
 	abd_t *orig[VDEV_RAIDZ_MAXPARITY];
 	int c, ret = 0;
 	raidz_map_t *rm = zio->io_vsd;
 	raidz_col_t *rc;
 
 	blkptr_t *bp = zio->io_bp;
 	enum zio_checksum checksum = (bp == NULL ? zio->io_prop.zp_checksum :
 	    (BP_IS_GANG(bp) ? ZIO_CHECKSUM_GANG_HEADER : BP_GET_CHECKSUM(bp)));
 
 	if (checksum == ZIO_CHECKSUM_NOPARITY)
 		return (ret);
 
 	for (c = 0; c < rr->rr_firstdatacol; c++) {
 		rc = &rr->rr_col[c];
 		if (!rc->rc_tried || rc->rc_error != 0)
 			continue;
 
 		orig[c] = rc->rc_abd;
 		ASSERT3U(abd_get_size(rc->rc_abd), ==, rc->rc_size);
 		rc->rc_abd = abd_alloc_linear(rc->rc_size, B_FALSE);
 	}
 
 	/*
 	 * Verify any empty sectors are zero filled to ensure the parity
 	 * is calculated correctly even if these non-data sectors are damaged.
 	 */
 	if (rr->rr_nempty && rr->rr_abd_empty != NULL)
 		ret += vdev_draid_map_verify_empty(zio, rr);
 
 	/*
 	 * Regenerates parity even for !tried||rc_error!=0 columns.  This
 	 * isn't harmful but it does have the side effect of fixing stuff
 	 * we didn't realize was necessary (i.e. even if we return 0).
 	 */
 	vdev_raidz_generate_parity_row(rm, rr);
 
 	for (c = 0; c < rr->rr_firstdatacol; c++) {
 		rc = &rr->rr_col[c];
 
 		if (!rc->rc_tried || rc->rc_error != 0)
 			continue;
 
 		if (abd_cmp(orig[c], rc->rc_abd) != 0) {
 			zfs_dbgmsg("found error on col=%u devidx=%u off %llx",
 			    c, (int)rc->rc_devidx, (u_longlong_t)rc->rc_offset);
 			vdev_raidz_checksum_error(zio, rc, orig[c]);
 			rc->rc_error = SET_ERROR(ECKSUM);
 			ret++;
 		}
 		abd_free(orig[c]);
 	}
 
 	return (ret);
 }
 
 static int
 vdev_raidz_worst_error(raidz_row_t *rr)
 {
 	int error = 0;
 
 	for (int c = 0; c < rr->rr_cols; c++) {
 		error = zio_worst_error(error, rr->rr_col[c].rc_error);
 		error = zio_worst_error(error, rr->rr_col[c].rc_shadow_error);
 	}
 
 	return (error);
 }
 
 static void
 vdev_raidz_io_done_verified(zio_t *zio, raidz_row_t *rr)
 {
 	int unexpected_errors = 0;
 	int parity_errors = 0;
 	int parity_untried = 0;
 	int data_errors = 0;
 
 	ASSERT3U(zio->io_type, ==, ZIO_TYPE_READ);
 
 	for (int c = 0; c < rr->rr_cols; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 
 		if (rc->rc_error) {
 			if (c < rr->rr_firstdatacol)
 				parity_errors++;
 			else
 				data_errors++;
 
 			if (!rc->rc_skipped)
 				unexpected_errors++;
 		} else if (c < rr->rr_firstdatacol && !rc->rc_tried) {
 			parity_untried++;
 		}
 
 		if (rc->rc_force_repair)
 			unexpected_errors++;
 	}
 
 	/*
 	 * If we read more parity disks than were used for
 	 * reconstruction, confirm that the other parity disks produced
 	 * correct data.
 	 *
 	 * Note that we also regenerate parity when resilvering so we
 	 * can write it out to failed devices later.
 	 */
 	if (parity_errors + parity_untried <
 	    rr->rr_firstdatacol - data_errors ||
 	    (zio->io_flags & ZIO_FLAG_RESILVER)) {
 		int n = raidz_parity_verify(zio, rr);
 		unexpected_errors += n;
 	}
 
 	if (zio->io_error == 0 && spa_writeable(zio->io_spa) &&
 	    (unexpected_errors > 0 || (zio->io_flags & ZIO_FLAG_RESILVER))) {
 		/*
 		 * Use the good data we have in hand to repair damaged children.
 		 */
 		for (int c = 0; c < rr->rr_cols; c++) {
 			raidz_col_t *rc = &rr->rr_col[c];
 			vdev_t *vd = zio->io_vd;
 			vdev_t *cvd = vd->vdev_child[rc->rc_devidx];
 
 			if (!rc->rc_allow_repair) {
 				continue;
 			} else if (!rc->rc_force_repair &&
 			    (rc->rc_error == 0 || rc->rc_size == 0)) {
 				continue;
 			}
+			/*
+			 * We do not allow self healing for Direct I/O reads.
+			 * See comment in vdev_raid_row_alloc().
+			 */
+			ASSERT0(zio->io_flags & ZIO_FLAG_DIO_READ);
 
 			zfs_dbgmsg("zio=%px repairing c=%u devidx=%u "
 			    "offset=%llx",
 			    zio, c, rc->rc_devidx, (long long)rc->rc_offset);
 
 			zio_nowait(zio_vdev_child_io(zio, NULL, cvd,
 			    rc->rc_offset, rc->rc_abd, rc->rc_size,
 			    ZIO_TYPE_WRITE,
 			    zio->io_priority == ZIO_PRIORITY_REBUILD ?
 			    ZIO_PRIORITY_REBUILD : ZIO_PRIORITY_ASYNC_WRITE,
 			    ZIO_FLAG_IO_REPAIR | (unexpected_errors ?
 			    ZIO_FLAG_SELF_HEAL : 0), NULL, NULL));
 		}
 	}
 
 	/*
 	 * Scrub or resilver i/o's: overwrite any shadow locations with the
 	 * good data.  This ensures that if we've already copied this sector,
 	 * it will be corrected if it was damaged.  This writes more than is
 	 * necessary, but since expansion is paused during scrub/resilver, at
 	 * most a single row will have a shadow location.
 	 */
 	if (zio->io_error == 0 && spa_writeable(zio->io_spa) &&
 	    (zio->io_flags & (ZIO_FLAG_RESILVER | ZIO_FLAG_SCRUB))) {
 		for (int c = 0; c < rr->rr_cols; c++) {
 			raidz_col_t *rc = &rr->rr_col[c];
 			vdev_t *vd = zio->io_vd;
 
 			if (rc->rc_shadow_devidx == INT_MAX || rc->rc_size == 0)
 				continue;
 			vdev_t *cvd = vd->vdev_child[rc->rc_shadow_devidx];
 
 			/*
 			 * Note: We don't want to update the repair stats
 			 * because that would incorrectly indicate that there
 			 * was bad data to repair, which we aren't sure about.
 			 * By clearing the SCAN_THREAD flag, we prevent this
 			 * from happening, despite having the REPAIR flag set.
 			 * We need to set SELF_HEAL so that this i/o can't be
 			 * bypassed by zio_vdev_io_start().
 			 */
 			zio_t *cio = zio_vdev_child_io(zio, NULL, cvd,
 			    rc->rc_shadow_offset, rc->rc_abd, rc->rc_size,
 			    ZIO_TYPE_WRITE, ZIO_PRIORITY_ASYNC_WRITE,
 			    ZIO_FLAG_IO_REPAIR | ZIO_FLAG_SELF_HEAL,
 			    NULL, NULL);
 			cio->io_flags &= ~ZIO_FLAG_SCAN_THREAD;
 			zio_nowait(cio);
 		}
 	}
 }
 
 static void
 raidz_restore_orig_data(raidz_map_t *rm)
 {
 	for (int i = 0; i < rm->rm_nrows; i++) {
 		raidz_row_t *rr = rm->rm_row[i];
 		for (int c = 0; c < rr->rr_cols; c++) {
 			raidz_col_t *rc = &rr->rr_col[c];
 			if (rc->rc_need_orig_restore) {
 				abd_copy(rc->rc_abd,
 				    rc->rc_orig_data, rc->rc_size);
 				rc->rc_need_orig_restore = B_FALSE;
 			}
 		}
 	}
 }
 
 /*
  * During raidz_reconstruct() for expanded VDEV, we need special consideration
  * failure simulations.  See note in raidz_reconstruct() on simulating failure
  * of a pre-expansion device.
  *
  * Treating logical child i as failed, return TRUE if the given column should
  * be treated as failed.  The idea of logical children allows us to imagine
  * that a disk silently failed before a RAIDZ expansion (reads from this disk
  * succeed but return the wrong data).  Since the expansion doesn't verify
  * checksums, the incorrect data will be moved to new locations spread among
  * the children (going diagonally across them).
  *
  * Higher "logical child failures" (values of `i`) indicate these
  * "pre-expansion failures".  The first physical_width values imagine that a
  * current child failed; the next physical_width-1 values imagine that a
  * child failed before the most recent expansion; the next physical_width-2
  * values imagine a child failed in the expansion before that, etc.
  */
 static boolean_t
 raidz_simulate_failure(int physical_width, int original_width, int ashift,
     int i, raidz_col_t *rc)
 {
 	uint64_t sector_id =
 	    physical_width * (rc->rc_offset >> ashift) +
 	    rc->rc_devidx;
 
 	for (int w = physical_width; w >= original_width; w--) {
 		if (i < w) {
 			return (sector_id % w == i);
 		} else {
 			i -= w;
 		}
 	}
 	ASSERT(!"invalid logical child id");
 	return (B_FALSE);
 }
 
 /*
  * returns EINVAL if reconstruction of the block will not be possible
  * returns ECKSUM if this specific reconstruction failed
  * returns 0 on successful reconstruction
  */
 static int
 raidz_reconstruct(zio_t *zio, int *ltgts, int ntgts, int nparity)
 {
 	raidz_map_t *rm = zio->io_vsd;
 	int physical_width = zio->io_vd->vdev_children;
 	int original_width = (rm->rm_original_width != 0) ?
 	    rm->rm_original_width : physical_width;
 	int dbgmsg = zfs_flags & ZFS_DEBUG_RAIDZ_RECONSTRUCT;
 
 	if (dbgmsg) {
 		zfs_dbgmsg("raidz_reconstruct_expanded(zio=%px ltgts=%u,%u,%u "
 		    "ntgts=%u", zio, ltgts[0], ltgts[1], ltgts[2], ntgts);
 	}
 
 	/* Reconstruct each row */
 	for (int r = 0; r < rm->rm_nrows; r++) {
 		raidz_row_t *rr = rm->rm_row[r];
 		int my_tgts[VDEV_RAIDZ_MAXPARITY]; /* value is child id */
 		int t = 0;
 		int dead = 0;
 		int dead_data = 0;
 
 		if (dbgmsg)
 			zfs_dbgmsg("raidz_reconstruct_expanded(row=%u)", r);
 
 		for (int c = 0; c < rr->rr_cols; c++) {
 			raidz_col_t *rc = &rr->rr_col[c];
 			ASSERT0(rc->rc_need_orig_restore);
 			if (rc->rc_error != 0) {
 				dead++;
 				if (c >= nparity)
 					dead_data++;
 				continue;
 			}
 			if (rc->rc_size == 0)
 				continue;
 			for (int lt = 0; lt < ntgts; lt++) {
 				if (raidz_simulate_failure(physical_width,
 				    original_width,
 				    zio->io_vd->vdev_top->vdev_ashift,
 				    ltgts[lt], rc)) {
 					if (rc->rc_orig_data == NULL) {
 						rc->rc_orig_data =
 						    abd_alloc_linear(
 						    rc->rc_size, B_TRUE);
 						abd_copy(rc->rc_orig_data,
 						    rc->rc_abd, rc->rc_size);
 					}
 					rc->rc_need_orig_restore = B_TRUE;
 
 					dead++;
 					if (c >= nparity)
 						dead_data++;
 					/*
 					 * Note: simulating failure of a
 					 * pre-expansion device can hit more
 					 * than one column, in which case we
 					 * might try to simulate more failures
 					 * than can be reconstructed, which is
 					 * also more than the size of my_tgts.
 					 * This check prevents accessing past
 					 * the end of my_tgts.  The "dead >
 					 * nparity" check below will fail this
 					 * reconstruction attempt.
 					 */
 					if (t < VDEV_RAIDZ_MAXPARITY) {
 						my_tgts[t++] = c;
 						if (dbgmsg) {
 							zfs_dbgmsg("simulating "
 							    "failure of col %u "
 							    "devidx %u", c,
 							    (int)rc->rc_devidx);
 						}
 					}
 					break;
 				}
 			}
 		}
 		if (dead > nparity) {
 			/* reconstruction not possible */
 			if (dbgmsg) {
 				zfs_dbgmsg("reconstruction not possible; "
 				    "too many failures");
 			}
 			raidz_restore_orig_data(rm);
 			return (EINVAL);
 		}
 		if (dead_data > 0)
 			vdev_raidz_reconstruct_row(rm, rr, my_tgts, t);
 	}
 
 	/* Check for success */
 	if (raidz_checksum_verify(zio) == 0) {
+		if (zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR)
+			return (0);
 
 		/* Reconstruction succeeded - report errors */
 		for (int i = 0; i < rm->rm_nrows; i++) {
 			raidz_row_t *rr = rm->rm_row[i];
 
 			for (int c = 0; c < rr->rr_cols; c++) {
 				raidz_col_t *rc = &rr->rr_col[c];
 				if (rc->rc_need_orig_restore) {
 					/*
 					 * Note: if this is a parity column,
 					 * we don't really know if it's wrong.
 					 * We need to let
 					 * vdev_raidz_io_done_verified() check
 					 * it, and if we set rc_error, it will
 					 * think that it is a "known" error
 					 * that doesn't need to be checked
 					 * or corrected.
 					 */
 					if (rc->rc_error == 0 &&
 					    c >= rr->rr_firstdatacol) {
 						vdev_raidz_checksum_error(zio,
 						    rc, rc->rc_orig_data);
 						rc->rc_error =
 						    SET_ERROR(ECKSUM);
 					}
 					rc->rc_need_orig_restore = B_FALSE;
 				}
 			}
 
 			vdev_raidz_io_done_verified(zio, rr);
 		}
 
 		zio_checksum_verified(zio);
 
 		if (dbgmsg) {
 			zfs_dbgmsg("reconstruction successful "
 			    "(checksum verified)");
 		}
 		return (0);
 	}
 
 	/* Reconstruction failed - restore original data */
 	raidz_restore_orig_data(rm);
 	if (dbgmsg) {
 		zfs_dbgmsg("raidz_reconstruct_expanded(zio=%px) checksum "
 		    "failed", zio);
 	}
 	return (ECKSUM);
 }
 
 /*
  * Iterate over all combinations of N bad vdevs and attempt a reconstruction.
  * Note that the algorithm below is non-optimal because it doesn't take into
  * account how reconstruction is actually performed. For example, with
  * triple-parity RAID-Z the reconstruction procedure is the same if column 4
  * is targeted as invalid as if columns 1 and 4 are targeted since in both
  * cases we'd only use parity information in column 0.
  *
  * The order that we find the various possible combinations of failed
  * disks is dictated by these rules:
  * - Examine each "slot" (the "i" in tgts[i])
  *   - Try to increment this slot (tgts[i] += 1)
  *   - if we can't increment because it runs into the next slot,
  *     reset our slot to the minimum, and examine the next slot
  *
  *  For example, with a 6-wide RAIDZ3, and no known errors (so we have to choose
  *  3 columns to reconstruct), we will generate the following sequence:
  *
  *  STATE        ACTION
  *  0 1 2        special case: skip since these are all parity
  *  0 1   3      first slot: reset to 0; middle slot: increment to 2
  *  0   2 3      first slot: increment to 1
  *    1 2 3      first: reset to 0; middle: reset to 1; last: increment to 4
  *  0 1     4    first: reset to 0; middle: increment to 2
  *  0   2   4    first: increment to 1
  *    1 2   4    first: reset to 0; middle: increment to 3
  *  0     3 4    first: increment to 1
  *    1   3 4    first: increment to 2
  *      2 3 4    first: reset to 0; middle: reset to 1; last: increment to 5
  *  0 1       5  first: reset to 0; middle: increment to 2
  *  0   2     5  first: increment to 1
  *    1 2     5  first: reset to 0; middle: increment to 3
  *  0     3   5  first: increment to 1
  *    1   3   5  first: increment to 2
  *      2 3   5  first: reset to 0; middle: increment to 4
  *  0       4 5  first: increment to 1
  *    1     4 5  first: increment to 2
  *      2   4 5  first: increment to 3
  *        3 4 5  done
  *
  * This strategy works for dRAID but is less efficient when there are a large
  * number of child vdevs and therefore permutations to check. Furthermore,
  * since the raidz_map_t rows likely do not overlap, reconstruction would be
  * possible as long as there are no more than nparity data errors per row.
  * These additional permutations are not currently checked but could be as
  * a future improvement.
  *
  * Returns 0 on success, ECKSUM on failure.
  */
 static int
 vdev_raidz_combrec(zio_t *zio)
 {
 	int nparity = vdev_get_nparity(zio->io_vd);
 	raidz_map_t *rm = zio->io_vsd;
 	int physical_width = zio->io_vd->vdev_children;
 	int original_width = (rm->rm_original_width != 0) ?
 	    rm->rm_original_width : physical_width;
 
 	for (int i = 0; i < rm->rm_nrows; i++) {
 		raidz_row_t *rr = rm->rm_row[i];
 		int total_errors = 0;
 
 		for (int c = 0; c < rr->rr_cols; c++) {
 			if (rr->rr_col[c].rc_error)
 				total_errors++;
 		}
 
 		if (total_errors > nparity)
 			return (vdev_raidz_worst_error(rr));
 	}
 
 	for (int num_failures = 1; num_failures <= nparity; num_failures++) {
 		int tstore[VDEV_RAIDZ_MAXPARITY + 2];
 		int *ltgts = &tstore[1]; /* value is logical child ID */
 
 
 		/*
 		 * Determine number of logical children, n.  See comment
 		 * above raidz_simulate_failure().
 		 */
 		int n = 0;
 		for (int w = physical_width;
 		    w >= original_width; w--) {
 			n += w;
 		}
 
 		ASSERT3U(num_failures, <=, nparity);
 		ASSERT3U(num_failures, <=, VDEV_RAIDZ_MAXPARITY);
 
 		/* Handle corner cases in combrec logic */
 		ltgts[-1] = -1;
 		for (int i = 0; i < num_failures; i++) {
 			ltgts[i] = i;
 		}
 		ltgts[num_failures] = n;
 
 		for (;;) {
 			int err = raidz_reconstruct(zio, ltgts, num_failures,
 			    nparity);
 			if (err == EINVAL) {
 				/*
 				 * Reconstruction not possible with this #
 				 * failures; try more failures.
 				 */
 				break;
 			} else if (err == 0)
 				return (0);
 
 			/* Compute next targets to try */
 			for (int t = 0; ; t++) {
 				ASSERT3U(t, <, num_failures);
 				ltgts[t]++;
 				if (ltgts[t] == n) {
 					/* try more failures */
 					ASSERT3U(t, ==, num_failures - 1);
 					if (zfs_flags &
 					    ZFS_DEBUG_RAIDZ_RECONSTRUCT) {
 						zfs_dbgmsg("reconstruction "
 						    "failed for num_failures="
 						    "%u; tried all "
 						    "combinations",
 						    num_failures);
 					}
 					break;
 				}
 
 				ASSERT3U(ltgts[t], <, n);
 				ASSERT3U(ltgts[t], <=, ltgts[t + 1]);
 
 				/*
 				 * If that spot is available, we're done here.
 				 * Try the next combination.
 				 */
 				if (ltgts[t] != ltgts[t + 1])
 					break; // found next combination
 
 				/*
 				 * Otherwise, reset this tgt to the minimum,
 				 * and move on to the next tgt.
 				 */
 				ltgts[t] = ltgts[t - 1] + 1;
 				ASSERT3U(ltgts[t], ==, t);
 			}
 
 			/* Increase the number of failures and keep trying. */
 			if (ltgts[num_failures - 1] == n)
 				break;
 		}
 	}
 	if (zfs_flags & ZFS_DEBUG_RAIDZ_RECONSTRUCT)
 		zfs_dbgmsg("reconstruction failed for all num_failures");
 	return (ECKSUM);
 }
 
 void
 vdev_raidz_reconstruct(raidz_map_t *rm, const int *t, int nt)
 {
 	for (uint64_t row = 0; row < rm->rm_nrows; row++) {
 		raidz_row_t *rr = rm->rm_row[row];
 		vdev_raidz_reconstruct_row(rm, rr, t, nt);
 	}
 }
 
 /*
  * Complete a write IO operation on a RAIDZ VDev
  *
  * Outline:
  *   1. Check for errors on the child IOs.
  *   2. Return, setting an error code if too few child VDevs were written
  *      to reconstruct the data later.  Note that partial writes are
  *      considered successful if they can be reconstructed at all.
  */
 static void
 vdev_raidz_io_done_write_impl(zio_t *zio, raidz_row_t *rr)
 {
 	int normal_errors = 0;
 	int shadow_errors = 0;
 
 	ASSERT3U(rr->rr_missingparity, <=, rr->rr_firstdatacol);
 	ASSERT3U(rr->rr_missingdata, <=, rr->rr_cols - rr->rr_firstdatacol);
 	ASSERT3U(zio->io_type, ==, ZIO_TYPE_WRITE);
 
 	for (int c = 0; c < rr->rr_cols; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 
 		if (rc->rc_error != 0) {
 			ASSERT(rc->rc_error != ECKSUM);	/* child has no bp */
 			normal_errors++;
 		}
 		if (rc->rc_shadow_error != 0) {
 			ASSERT(rc->rc_shadow_error != ECKSUM);
 			shadow_errors++;
 		}
 	}
 
 	/*
 	 * Treat partial writes as a success. If we couldn't write enough
 	 * columns to reconstruct the data, the I/O failed.  Otherwise, good
 	 * enough.  Note that in the case of a shadow write (during raidz
 	 * expansion), depending on if we crash, either the normal (old) or
 	 * shadow (new) location may become the "real" version of the block,
 	 * so both locations must have sufficient redundancy.
 	 *
 	 * Now that we support write reallocation, it would be better
 	 * to treat partial failure as real failure unless there are
 	 * no non-degraded top-level vdevs left, and not update DTLs
 	 * if we intend to reallocate.
 	 */
 	if (normal_errors > rr->rr_firstdatacol ||
 	    shadow_errors > rr->rr_firstdatacol) {
 		zio->io_error = zio_worst_error(zio->io_error,
 		    vdev_raidz_worst_error(rr));
 	}
 }
 
 static void
 vdev_raidz_io_done_reconstruct_known_missing(zio_t *zio, raidz_map_t *rm,
     raidz_row_t *rr)
 {
 	int parity_errors = 0;
 	int parity_untried = 0;
 	int data_errors = 0;
 	int total_errors = 0;
 
 	ASSERT3U(rr->rr_missingparity, <=, rr->rr_firstdatacol);
 	ASSERT3U(rr->rr_missingdata, <=, rr->rr_cols - rr->rr_firstdatacol);
 
 	for (int c = 0; c < rr->rr_cols; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 
 		/*
 		 * If scrubbing and a replacing/sparing child vdev determined
 		 * that not all of its children have an identical copy of the
 		 * data, then clear the error so the column is treated like
 		 * any other read and force a repair to correct the damage.
 		 */
 		if (rc->rc_error == ECKSUM) {
 			ASSERT(zio->io_flags & ZIO_FLAG_SCRUB);
 			vdev_raidz_checksum_error(zio, rc, rc->rc_abd);
 			rc->rc_force_repair = 1;
 			rc->rc_error = 0;
 		}
 
 		if (rc->rc_error) {
 			if (c < rr->rr_firstdatacol)
 				parity_errors++;
 			else
 				data_errors++;
 
 			total_errors++;
 		} else if (c < rr->rr_firstdatacol && !rc->rc_tried) {
 			parity_untried++;
 		}
 	}
 
 	/*
 	 * If there were data errors and the number of errors we saw was
 	 * correctable -- less than or equal to the number of parity disks read
 	 * -- reconstruct based on the missing data.
 	 */
 	if (data_errors != 0 &&
 	    total_errors <= rr->rr_firstdatacol - parity_untried) {
 		/*
 		 * We either attempt to read all the parity columns or
 		 * none of them. If we didn't try to read parity, we
 		 * wouldn't be here in the correctable case. There must
 		 * also have been fewer parity errors than parity
 		 * columns or, again, we wouldn't be in this code path.
 		 */
 		ASSERT(parity_untried == 0);
 		ASSERT(parity_errors < rr->rr_firstdatacol);
 
 		/*
 		 * Identify the data columns that reported an error.
 		 */
 		int n = 0;
 		int tgts[VDEV_RAIDZ_MAXPARITY];
 		for (int c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
 			raidz_col_t *rc = &rr->rr_col[c];
 			if (rc->rc_error != 0) {
 				ASSERT(n < VDEV_RAIDZ_MAXPARITY);
 				tgts[n++] = c;
 			}
 		}
 
 		ASSERT(rr->rr_firstdatacol >= n);
 
 		vdev_raidz_reconstruct_row(rm, rr, tgts, n);
 	}
 }
 
 /*
  * Return the number of reads issued.
  */
 static int
 vdev_raidz_read_all(zio_t *zio, raidz_row_t *rr)
 {
 	vdev_t *vd = zio->io_vd;
 	int nread = 0;
 
 	rr->rr_missingdata = 0;
 	rr->rr_missingparity = 0;
 
 	/*
 	 * If this rows contains empty sectors which are not required
 	 * for a normal read then allocate an ABD for them now so they
 	 * may be read, verified, and any needed repairs performed.
 	 */
 	if (rr->rr_nempty != 0 && rr->rr_abd_empty == NULL)
 		vdev_draid_map_alloc_empty(zio, rr);
 
 	for (int c = 0; c < rr->rr_cols; c++) {
 		raidz_col_t *rc = &rr->rr_col[c];
 		if (rc->rc_tried || rc->rc_size == 0)
 			continue;
 
 		zio_nowait(zio_vdev_child_io(zio, NULL,
 		    vd->vdev_child[rc->rc_devidx],
 		    rc->rc_offset, rc->rc_abd, rc->rc_size,
 		    zio->io_type, zio->io_priority, 0,
 		    vdev_raidz_child_done, rc));
 		nread++;
 	}
 	return (nread);
 }
 
 /*
  * We're here because either there were too many errors to even attempt
  * reconstruction (total_errors == rm_first_datacol), or vdev_*_combrec()
  * failed. In either case, there is enough bad data to prevent reconstruction.
  * Start checksum ereports for all children which haven't failed.
  */
 static void
 vdev_raidz_io_done_unrecoverable(zio_t *zio)
 {
 	raidz_map_t *rm = zio->io_vsd;
 
 	for (int i = 0; i < rm->rm_nrows; i++) {
 		raidz_row_t *rr = rm->rm_row[i];
 
 		for (int c = 0; c < rr->rr_cols; c++) {
 			raidz_col_t *rc = &rr->rr_col[c];
 			vdev_t *cvd = zio->io_vd->vdev_child[rc->rc_devidx];
 
 			if (rc->rc_error != 0)
 				continue;
 
 			zio_bad_cksum_t zbc;
 			zbc.zbc_has_cksum = 0;
 			zbc.zbc_injected = rm->rm_ecksuminjected;
-
 			mutex_enter(&cvd->vdev_stat_lock);
 			cvd->vdev_stat.vs_checksum_errors++;
 			mutex_exit(&cvd->vdev_stat_lock);
 			(void) zfs_ereport_start_checksum(zio->io_spa,
 			    cvd, &zio->io_bookmark, zio, rc->rc_offset,
 			    rc->rc_size, &zbc);
 		}
 	}
 }
 
 void
 vdev_raidz_io_done(zio_t *zio)
 {
 	raidz_map_t *rm = zio->io_vsd;
 
 	ASSERT(zio->io_bp != NULL);
 	if (zio->io_type == ZIO_TYPE_WRITE) {
 		for (int i = 0; i < rm->rm_nrows; i++) {
 			vdev_raidz_io_done_write_impl(zio, rm->rm_row[i]);
 		}
 	} else {
 		if (rm->rm_phys_col) {
 			/*
 			 * This is an aggregated read.  Copy the data and status
 			 * from the aggregate abd's to the individual rows.
 			 */
 			for (int i = 0; i < rm->rm_nrows; i++) {
 				raidz_row_t *rr = rm->rm_row[i];
 
 				for (int c = 0; c < rr->rr_cols; c++) {
 					raidz_col_t *rc = &rr->rr_col[c];
 					if (rc->rc_tried || rc->rc_size == 0)
 						continue;
 
 					raidz_col_t *prc =
 					    &rm->rm_phys_col[rc->rc_devidx];
 					rc->rc_error = prc->rc_error;
 					rc->rc_tried = prc->rc_tried;
 					rc->rc_skipped = prc->rc_skipped;
 					if (c >= rr->rr_firstdatacol) {
 						/*
 						 * Note: this is slightly faster
 						 * than using abd_copy_off().
 						 */
 						char *physbuf = abd_to_buf(
 						    prc->rc_abd);
 						void *physloc = physbuf +
 						    rc->rc_offset -
 						    prc->rc_offset;
 
 						abd_copy_from_buf(rc->rc_abd,
 						    physloc, rc->rc_size);
 					}
 				}
 			}
 		}
 
 		for (int i = 0; i < rm->rm_nrows; i++) {
 			raidz_row_t *rr = rm->rm_row[i];
 			vdev_raidz_io_done_reconstruct_known_missing(zio,
 			    rm, rr);
 		}
 
 		if (raidz_checksum_verify(zio) == 0) {
+			if (zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR)
+				goto done;
+
 			for (int i = 0; i < rm->rm_nrows; i++) {
 				raidz_row_t *rr = rm->rm_row[i];
 				vdev_raidz_io_done_verified(zio, rr);
 			}
 			zio_checksum_verified(zio);
 		} else {
 			/*
 			 * A sequential resilver has no checksum which makes
 			 * combinatoral reconstruction impossible. This code
 			 * path is unreachable since raidz_checksum_verify()
 			 * has no checksum to verify and must succeed.
 			 */
 			ASSERT3U(zio->io_priority, !=, ZIO_PRIORITY_REBUILD);
 
 			/*
 			 * This isn't a typical situation -- either we got a
 			 * read error or a child silently returned bad data.
 			 * Read every block so we can try again with as much
 			 * data and parity as we can track down. If we've
 			 * already been through once before, all children will
 			 * be marked as tried so we'll proceed to combinatorial
 			 * reconstruction.
 			 */
 			int nread = 0;
 			for (int i = 0; i < rm->rm_nrows; i++) {
 				nread += vdev_raidz_read_all(zio,
 				    rm->rm_row[i]);
 			}
 			if (nread != 0) {
 				/*
 				 * Normally our stage is VDEV_IO_DONE, but if
 				 * we've already called redone(), it will have
 				 * changed to VDEV_IO_START, in which case we
 				 * don't want to call redone() again.
 				 */
 				if (zio->io_stage != ZIO_STAGE_VDEV_IO_START)
 					zio_vdev_io_redone(zio);
 				return;
 			}
 			/*
 			 * It would be too expensive to try every possible
 			 * combination of failed sectors in every row, so
 			 * instead we try every combination of failed current or
 			 * past physical disk. This means that if the incorrect
 			 * sectors were all on Nparity disks at any point in the
 			 * past, we will find the correct data.  The only known
 			 * case where this is less durable than a non-expanded
 			 * RAIDZ, is if we have a silent failure during
 			 * expansion.  In that case, one block could be
 			 * partially in the old format and partially in the
 			 * new format, so we'd lost some sectors from the old
 			 * format and some from the new format.
 			 *
 			 * e.g. logical_width=4 physical_width=6
 			 * the 15 (6+5+4) possible failed disks are:
 			 * width=6 child=0
 			 * width=6 child=1
 			 * width=6 child=2
 			 * width=6 child=3
 			 * width=6 child=4
 			 * width=6 child=5
 			 * width=5 child=0
 			 * width=5 child=1
 			 * width=5 child=2
 			 * width=5 child=3
 			 * width=5 child=4
 			 * width=4 child=0
 			 * width=4 child=1
 			 * width=4 child=2
 			 * width=4 child=3
 			 * And we will try every combination of Nparity of these
 			 * failing.
 			 *
 			 * As a first pass, we can generate every combo,
 			 * and try reconstructing, ignoring any known
 			 * failures.  If any row has too many known + simulated
 			 * failures, then we bail on reconstructing with this
 			 * number of simulated failures.  As an improvement,
 			 * we could detect the number of whole known failures
 			 * (i.e. we have known failures on these disks for
 			 * every row; the disks never succeeded), and
 			 * subtract that from the max # failures to simulate.
 			 * We could go even further like the current
 			 * combrec code, but that doesn't seem like it
 			 * gains us very much.  If we simulate a failure
 			 * that is also a known failure, that's fine.
 			 */
 			zio->io_error = vdev_raidz_combrec(zio);
 			if (zio->io_error == ECKSUM &&
 			    !(zio->io_flags & ZIO_FLAG_SPECULATIVE)) {
 				vdev_raidz_io_done_unrecoverable(zio);
 			}
 		}
 	}
+done:
 	if (rm->rm_lr != NULL) {
 		zfs_rangelock_exit(rm->rm_lr);
 		rm->rm_lr = NULL;
 	}
 }
 
 static void
 vdev_raidz_state_change(vdev_t *vd, int faulted, int degraded)
 {
 	vdev_raidz_t *vdrz = vd->vdev_tsd;
 	if (faulted > vdrz->vd_nparity)
 		vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
 		    VDEV_AUX_NO_REPLICAS);
 	else if (degraded + faulted != 0)
 		vdev_set_state(vd, B_FALSE, VDEV_STATE_DEGRADED, VDEV_AUX_NONE);
 	else
 		vdev_set_state(vd, B_FALSE, VDEV_STATE_HEALTHY, VDEV_AUX_NONE);
 }
 
 /*
  * Determine if any portion of the provided block resides on a child vdev
  * with a dirty DTL and therefore needs to be resilvered.  The function
  * assumes that at least one DTL is dirty which implies that full stripe
  * width blocks must be resilvered.
  */
 static boolean_t
 vdev_raidz_need_resilver(vdev_t *vd, const dva_t *dva, size_t psize,
     uint64_t phys_birth)
 {
 	vdev_raidz_t *vdrz = vd->vdev_tsd;
 
 	/*
 	 * If we're in the middle of a RAIDZ expansion, this block may be in
 	 * the old and/or new location.  For simplicity, always resilver it.
 	 */
 	if (vdrz->vn_vre.vre_state == DSS_SCANNING)
 		return (B_TRUE);
 
 	uint64_t dcols = vd->vdev_children;
 	uint64_t nparity = vdrz->vd_nparity;
 	uint64_t ashift = vd->vdev_top->vdev_ashift;
 	/* The starting RAIDZ (parent) vdev sector of the block. */
 	uint64_t b = DVA_GET_OFFSET(dva) >> ashift;
 	/* The zio's size in units of the vdev's minimum sector size. */
 	uint64_t s = ((psize - 1) >> ashift) + 1;
 	/* The first column for this stripe. */
 	uint64_t f = b % dcols;
 
 	/* Unreachable by sequential resilver. */
 	ASSERT3U(phys_birth, !=, TXG_UNKNOWN);
 
 	if (!vdev_dtl_contains(vd, DTL_PARTIAL, phys_birth, 1))
 		return (B_FALSE);
 
 	if (s + nparity >= dcols)
 		return (B_TRUE);
 
 	for (uint64_t c = 0; c < s + nparity; c++) {
 		uint64_t devidx = (f + c) % dcols;
 		vdev_t *cvd = vd->vdev_child[devidx];
 
 		/*
 		 * dsl_scan_need_resilver() already checked vd with
 		 * vdev_dtl_contains(). So here just check cvd with
 		 * vdev_dtl_empty(), cheaper and a good approximation.
 		 */
 		if (!vdev_dtl_empty(cvd, DTL_PARTIAL))
 			return (B_TRUE);
 	}
 
 	return (B_FALSE);
 }
 
 static void
 vdev_raidz_xlate(vdev_t *cvd, const range_seg64_t *logical_rs,
     range_seg64_t *physical_rs, range_seg64_t *remain_rs)
 {
 	(void) remain_rs;
 
 	vdev_t *raidvd = cvd->vdev_parent;
 	ASSERT(raidvd->vdev_ops == &vdev_raidz_ops);
 
 	vdev_raidz_t *vdrz = raidvd->vdev_tsd;
 
 	if (vdrz->vn_vre.vre_state == DSS_SCANNING) {
 		/*
 		 * We're in the middle of expansion, in which case the
 		 * translation is in flux.  Any answer we give may be wrong
 		 * by the time we return, so it isn't safe for the caller to
 		 * act on it.  Therefore we say that this range isn't present
 		 * on any children.  The only consumers of this are "zpool
 		 * initialize" and trimming, both of which are "best effort"
 		 * anyway.
 		 */
 		physical_rs->rs_start = physical_rs->rs_end = 0;
 		remain_rs->rs_start = remain_rs->rs_end = 0;
 		return;
 	}
 
 	uint64_t width = vdrz->vd_physical_width;
 	uint64_t tgt_col = cvd->vdev_id;
 	uint64_t ashift = raidvd->vdev_top->vdev_ashift;
 
 	/* make sure the offsets are block-aligned */
 	ASSERT0(logical_rs->rs_start % (1 << ashift));
 	ASSERT0(logical_rs->rs_end % (1 << ashift));
 	uint64_t b_start = logical_rs->rs_start >> ashift;
 	uint64_t b_end = logical_rs->rs_end >> ashift;
 
 	uint64_t start_row = 0;
 	if (b_start > tgt_col) /* avoid underflow */
 		start_row = ((b_start - tgt_col - 1) / width) + 1;
 
 	uint64_t end_row = 0;
 	if (b_end > tgt_col)
 		end_row = ((b_end - tgt_col - 1) / width) + 1;
 
 	physical_rs->rs_start = start_row << ashift;
 	physical_rs->rs_end = end_row << ashift;
 
 	ASSERT3U(physical_rs->rs_start, <=, logical_rs->rs_start);
 	ASSERT3U(physical_rs->rs_end - physical_rs->rs_start, <=,
 	    logical_rs->rs_end - logical_rs->rs_start);
 }
 
 static void
 raidz_reflow_sync(void *arg, dmu_tx_t *tx)
 {
 	spa_t *spa = arg;
 	int txgoff = dmu_tx_get_txg(tx) & TXG_MASK;
 	vdev_raidz_expand_t *vre = spa->spa_raidz_expand;
 
 	/*
 	 * Ensure there are no i/os to the range that is being committed.
 	 */
 	uint64_t old_offset = RRSS_GET_OFFSET(&spa->spa_uberblock);
 	ASSERT3U(vre->vre_offset_pertxg[txgoff], >=, old_offset);
 
 	mutex_enter(&vre->vre_lock);
 	uint64_t new_offset =
 	    MIN(vre->vre_offset_pertxg[txgoff], vre->vre_failed_offset);
 	/*
 	 * We should not have committed anything that failed.
 	 */
 	VERIFY3U(vre->vre_failed_offset, >=, old_offset);
 	mutex_exit(&vre->vre_lock);
 
 	zfs_locked_range_t *lr = zfs_rangelock_enter(&vre->vre_rangelock,
 	    old_offset, new_offset - old_offset,
 	    RL_WRITER);
 
 	/*
 	 * Update the uberblock that will be written when this txg completes.
 	 */
 	RAIDZ_REFLOW_SET(&spa->spa_uberblock,
 	    RRSS_SCRATCH_INVALID_SYNCED_REFLOW, new_offset);
 	vre->vre_offset_pertxg[txgoff] = 0;
 	zfs_rangelock_exit(lr);
 
 	mutex_enter(&vre->vre_lock);
 	vre->vre_bytes_copied += vre->vre_bytes_copied_pertxg[txgoff];
 	vre->vre_bytes_copied_pertxg[txgoff] = 0;
 	mutex_exit(&vre->vre_lock);
 
 	vdev_t *vd = vdev_lookup_top(spa, vre->vre_vdev_id);
 	VERIFY0(zap_update(spa->spa_meta_objset,
 	    vd->vdev_top_zap, VDEV_TOP_ZAP_RAIDZ_EXPAND_BYTES_COPIED,
 	    sizeof (vre->vre_bytes_copied), 1, &vre->vre_bytes_copied, tx));
 }
 
 static void
 raidz_reflow_complete_sync(void *arg, dmu_tx_t *tx)
 {
 	spa_t *spa = arg;
 	vdev_raidz_expand_t *vre = spa->spa_raidz_expand;
 	vdev_t *raidvd = vdev_lookup_top(spa, vre->vre_vdev_id);
 	vdev_raidz_t *vdrz = raidvd->vdev_tsd;
 
 	for (int i = 0; i < TXG_SIZE; i++)
 		VERIFY0(vre->vre_offset_pertxg[i]);
 
 	reflow_node_t *re = kmem_zalloc(sizeof (*re), KM_SLEEP);
 	re->re_txg = tx->tx_txg + TXG_CONCURRENT_STATES;
 	re->re_logical_width = vdrz->vd_physical_width;
 	mutex_enter(&vdrz->vd_expand_lock);
 	avl_add(&vdrz->vd_expand_txgs, re);
 	mutex_exit(&vdrz->vd_expand_lock);
 
 	vdev_t *vd = vdev_lookup_top(spa, vre->vre_vdev_id);
 
 	/*
 	 * Dirty the config so that the updated ZPOOL_CONFIG_RAIDZ_EXPAND_TXGS
 	 * will get written (based on vd_expand_txgs).
 	 */
 	vdev_config_dirty(vd);
 
 	/*
 	 * Before we change vre_state, the on-disk state must reflect that we
 	 * have completed all copying, so that vdev_raidz_io_start() can use
 	 * vre_state to determine if the reflow is in progress.  See also the
 	 * end of spa_raidz_expand_thread().
 	 */
 	VERIFY3U(RRSS_GET_OFFSET(&spa->spa_ubsync), ==,
 	    raidvd->vdev_ms_count << raidvd->vdev_ms_shift);
 
 	vre->vre_end_time = gethrestime_sec();
 	vre->vre_state = DSS_FINISHED;
 
 	uint64_t state = vre->vre_state;
 	VERIFY0(zap_update(spa->spa_meta_objset,
 	    vd->vdev_top_zap, VDEV_TOP_ZAP_RAIDZ_EXPAND_STATE,
 	    sizeof (state), 1, &state, tx));
 
 	uint64_t end_time = vre->vre_end_time;
 	VERIFY0(zap_update(spa->spa_meta_objset,
 	    vd->vdev_top_zap, VDEV_TOP_ZAP_RAIDZ_EXPAND_END_TIME,
 	    sizeof (end_time), 1, &end_time, tx));
 
 	spa->spa_uberblock.ub_raidz_reflow_info = 0;
 
 	spa_history_log_internal(spa, "raidz vdev expansion completed",  tx,
 	    "%s vdev %llu new width %llu", spa_name(spa),
 	    (unsigned long long)vd->vdev_id,
 	    (unsigned long long)vd->vdev_children);
 
 	spa->spa_raidz_expand = NULL;
 	raidvd->vdev_rz_expanding = B_FALSE;
 
 	spa_async_request(spa, SPA_ASYNC_INITIALIZE_RESTART);
 	spa_async_request(spa, SPA_ASYNC_TRIM_RESTART);
 	spa_async_request(spa, SPA_ASYNC_AUTOTRIM_RESTART);
 
 	spa_notify_waiters(spa);
 
 	/*
 	 * While we're in syncing context take the opportunity to
 	 * setup a scrub. All the data has been sucessfully copied
 	 * but we have not validated any checksums.
 	 */
 	pool_scan_func_t func = POOL_SCAN_SCRUB;
 	if (zfs_scrub_after_expand && dsl_scan_setup_check(&func, tx) == 0)
 		dsl_scan_setup_sync(&func, tx);
 }
 
 /*
  * Struct for one copy zio.
  */
 typedef struct raidz_reflow_arg {
 	vdev_raidz_expand_t *rra_vre;
 	zfs_locked_range_t *rra_lr;
 	uint64_t rra_txg;
 } raidz_reflow_arg_t;
 
 /*
  * The write of the new location is done.
  */
 static void
 raidz_reflow_write_done(zio_t *zio)
 {
 	raidz_reflow_arg_t *rra = zio->io_private;
 	vdev_raidz_expand_t *vre = rra->rra_vre;
 
 	abd_free(zio->io_abd);
 
 	mutex_enter(&vre->vre_lock);
 	if (zio->io_error != 0) {
 		/* Force a reflow pause on errors */
 		vre->vre_failed_offset =
 		    MIN(vre->vre_failed_offset, rra->rra_lr->lr_offset);
 	}
 	ASSERT3U(vre->vre_outstanding_bytes, >=, zio->io_size);
 	vre->vre_outstanding_bytes -= zio->io_size;
 	if (rra->rra_lr->lr_offset + rra->rra_lr->lr_length <
 	    vre->vre_failed_offset) {
 		vre->vre_bytes_copied_pertxg[rra->rra_txg & TXG_MASK] +=
 		    zio->io_size;
 	}
 	cv_signal(&vre->vre_cv);
 	mutex_exit(&vre->vre_lock);
 
 	zfs_rangelock_exit(rra->rra_lr);
 
 	kmem_free(rra, sizeof (*rra));
 	spa_config_exit(zio->io_spa, SCL_STATE, zio->io_spa);
 }
 
 /*
  * The read of the old location is done.  The parent zio is the write to
  * the new location.  Allow it to start.
  */
 static void
 raidz_reflow_read_done(zio_t *zio)
 {
 	raidz_reflow_arg_t *rra = zio->io_private;
 	vdev_raidz_expand_t *vre = rra->rra_vre;
 
 	/*
 	 * If the read failed, or if it was done on a vdev that is not fully
 	 * healthy (e.g. a child that has a resilver in progress), we may not
 	 * have the correct data.  Note that it's OK if the write proceeds.
 	 * It may write garbage but the location is otherwise unused and we
 	 * will retry later due to vre_failed_offset.
 	 */
 	if (zio->io_error != 0 || !vdev_dtl_empty(zio->io_vd, DTL_MISSING)) {
 		zfs_dbgmsg("reflow read failed off=%llu size=%llu txg=%llu "
 		    "err=%u partial_dtl_empty=%u missing_dtl_empty=%u",
 		    (long long)rra->rra_lr->lr_offset,
 		    (long long)rra->rra_lr->lr_length,
 		    (long long)rra->rra_txg,
 		    zio->io_error,
 		    vdev_dtl_empty(zio->io_vd, DTL_PARTIAL),
 		    vdev_dtl_empty(zio->io_vd, DTL_MISSING));
 		mutex_enter(&vre->vre_lock);
 		/* Force a reflow pause on errors */
 		vre->vre_failed_offset =
 		    MIN(vre->vre_failed_offset, rra->rra_lr->lr_offset);
 		mutex_exit(&vre->vre_lock);
 	}
 
 	zio_nowait(zio_unique_parent(zio));
 }
 
 static void
 raidz_reflow_record_progress(vdev_raidz_expand_t *vre, uint64_t offset,
     dmu_tx_t *tx)
 {
 	int txgoff = dmu_tx_get_txg(tx) & TXG_MASK;
 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
 
 	if (offset == 0)
 		return;
 
 	mutex_enter(&vre->vre_lock);
 	ASSERT3U(vre->vre_offset, <=, offset);
 	vre->vre_offset = offset;
 	mutex_exit(&vre->vre_lock);
 
 	if (vre->vre_offset_pertxg[txgoff] == 0) {
 		dsl_sync_task_nowait(dmu_tx_pool(tx), raidz_reflow_sync,
 		    spa, tx);
 	}
 	vre->vre_offset_pertxg[txgoff] = offset;
 }
 
 static boolean_t
 vdev_raidz_expand_child_replacing(vdev_t *raidz_vd)
 {
 	for (int i = 0; i < raidz_vd->vdev_children; i++) {
 		/* Quick check if a child is being replaced */
 		if (!raidz_vd->vdev_child[i]->vdev_ops->vdev_op_leaf)
 			return (B_TRUE);
 	}
 	return (B_FALSE);
 }
 
 static boolean_t
 raidz_reflow_impl(vdev_t *vd, vdev_raidz_expand_t *vre, range_tree_t *rt,
     dmu_tx_t *tx)
 {
 	spa_t *spa = vd->vdev_spa;
 	int ashift = vd->vdev_top->vdev_ashift;
 	uint64_t offset, size;
 
 	if (!range_tree_find_in(rt, 0, vd->vdev_top->vdev_asize,
 	    &offset, &size)) {
 		return (B_FALSE);
 	}
 	ASSERT(IS_P2ALIGNED(offset, 1 << ashift));
 	ASSERT3U(size, >=, 1 << ashift);
 	uint64_t length = 1 << ashift;
 	int txgoff = dmu_tx_get_txg(tx) & TXG_MASK;
 
 	uint64_t blkid = offset >> ashift;
 
 	int old_children = vd->vdev_children - 1;
 
 	/*
 	 * We can only progress to the point that writes will not overlap
 	 * with blocks whose progress has not yet been recorded on disk.
 	 * Since partially-copied rows are still read from the old location,
 	 * we need to stop one row before the sector-wise overlap, to prevent
 	 * row-wise overlap.
 	 *
 	 * Note that even if we are skipping over a large unallocated region,
 	 * we can't move the on-disk progress to `offset`, because concurrent
 	 * writes/allocations could still use the currently-unallocated
 	 * region.
 	 */
 	uint64_t ubsync_blkid =
 	    RRSS_GET_OFFSET(&spa->spa_ubsync) >> ashift;
 	uint64_t next_overwrite_blkid = ubsync_blkid +
 	    ubsync_blkid / old_children - old_children;
 	VERIFY3U(next_overwrite_blkid, >, ubsync_blkid);
 
 	if (blkid >= next_overwrite_blkid) {
 		raidz_reflow_record_progress(vre,
 		    next_overwrite_blkid << ashift, tx);
 		return (B_TRUE);
 	}
 
 	range_tree_remove(rt, offset, length);
 
 	raidz_reflow_arg_t *rra = kmem_zalloc(sizeof (*rra), KM_SLEEP);
 	rra->rra_vre = vre;
 	rra->rra_lr = zfs_rangelock_enter(&vre->vre_rangelock,
 	    offset, length, RL_WRITER);
 	rra->rra_txg = dmu_tx_get_txg(tx);
 
 	raidz_reflow_record_progress(vre, offset + length, tx);
 
 	mutex_enter(&vre->vre_lock);
 	vre->vre_outstanding_bytes += length;
 	mutex_exit(&vre->vre_lock);
 
 	/*
 	 * SCL_STATE will be released when the read and write are done,
 	 * by raidz_reflow_write_done().
 	 */
 	spa_config_enter(spa, SCL_STATE, spa, RW_READER);
 
 	/* check if a replacing vdev was added, if so treat it as an error */
 	if (vdev_raidz_expand_child_replacing(vd)) {
 		zfs_dbgmsg("replacing vdev encountered, reflow paused at "
 		    "offset=%llu txg=%llu",
 		    (long long)rra->rra_lr->lr_offset,
 		    (long long)rra->rra_txg);
 
 		mutex_enter(&vre->vre_lock);
 		vre->vre_failed_offset =
 		    MIN(vre->vre_failed_offset, rra->rra_lr->lr_offset);
 		cv_signal(&vre->vre_cv);
 		mutex_exit(&vre->vre_lock);
 
 		/* drop everything we acquired */
 		zfs_rangelock_exit(rra->rra_lr);
 		kmem_free(rra, sizeof (*rra));
 		spa_config_exit(spa, SCL_STATE, spa);
 		return (B_TRUE);
 	}
 
 	zio_t *pio = spa->spa_txg_zio[txgoff];
 	abd_t *abd = abd_alloc_for_io(length, B_FALSE);
 	zio_t *write_zio = zio_vdev_child_io(pio, NULL,
 	    vd->vdev_child[blkid % vd->vdev_children],
 	    (blkid / vd->vdev_children) << ashift,
 	    abd, length,
 	    ZIO_TYPE_WRITE, ZIO_PRIORITY_REMOVAL,
 	    ZIO_FLAG_CANFAIL,
 	    raidz_reflow_write_done, rra);
 
 	zio_nowait(zio_vdev_child_io(write_zio, NULL,
 	    vd->vdev_child[blkid % old_children],
 	    (blkid / old_children) << ashift,
 	    abd, length,
 	    ZIO_TYPE_READ, ZIO_PRIORITY_REMOVAL,
 	    ZIO_FLAG_CANFAIL,
 	    raidz_reflow_read_done, rra));
 
 	return (B_FALSE);
 }
 
 /*
  * For testing (ztest specific)
  */
 static void
 raidz_expand_pause(uint_t pause_point)
 {
 	while (raidz_expand_pause_point != 0 &&
 	    raidz_expand_pause_point <= pause_point)
 		delay(hz);
 }
 
 static void
 raidz_scratch_child_done(zio_t *zio)
 {
 	zio_t *pio = zio->io_private;
 
 	mutex_enter(&pio->io_lock);
 	pio->io_error = zio_worst_error(pio->io_error, zio->io_error);
 	mutex_exit(&pio->io_lock);
 }
 
 /*
  * Reflow the beginning portion of the vdev into an intermediate scratch area
  * in memory and on disk. This operation must be persisted on disk before we
  * proceed to overwrite the beginning portion with the reflowed data.
  *
  * This multi-step task can fail to complete if disk errors are encountered
  * and we can return here after a pause (waiting for disk to become healthy).
  */
 static void
 raidz_reflow_scratch_sync(void *arg, dmu_tx_t *tx)
 {
 	vdev_raidz_expand_t *vre = arg;
 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
 	zio_t *pio;
 	int error;
 
 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
 	vdev_t *raidvd = vdev_lookup_top(spa, vre->vre_vdev_id);
 	int ashift = raidvd->vdev_ashift;
 	uint64_t write_size = P2ALIGN_TYPED(VDEV_BOOT_SIZE, 1 << ashift,
 	    uint64_t);
 	uint64_t logical_size = write_size * raidvd->vdev_children;
 	uint64_t read_size =
 	    P2ROUNDUP(DIV_ROUND_UP(logical_size, (raidvd->vdev_children - 1)),
 	    1 << ashift);
 
 	/*
 	 * The scratch space must be large enough to get us to the point
 	 * that one row does not overlap itself when moved.  This is checked
 	 * by vdev_raidz_attach_check().
 	 */
 	VERIFY3U(write_size, >=, raidvd->vdev_children << ashift);
 	VERIFY3U(write_size, <=, VDEV_BOOT_SIZE);
 	VERIFY3U(write_size, <=, read_size);
 
 	zfs_locked_range_t *lr = zfs_rangelock_enter(&vre->vre_rangelock,
 	    0, logical_size, RL_WRITER);
 
 	abd_t **abds = kmem_alloc(raidvd->vdev_children * sizeof (abd_t *),
 	    KM_SLEEP);
 	for (int i = 0; i < raidvd->vdev_children; i++) {
 		abds[i] = abd_alloc_linear(read_size, B_FALSE);
 	}
 
 	raidz_expand_pause(RAIDZ_EXPAND_PAUSE_PRE_SCRATCH_1);
 
 	/*
 	 * If we have already written the scratch area then we must read from
 	 * there, since new writes were redirected there while we were paused
 	 * or the original location may have been partially overwritten with
 	 * reflowed data.
 	 */
 	if (RRSS_GET_STATE(&spa->spa_ubsync) == RRSS_SCRATCH_VALID) {
 		VERIFY3U(RRSS_GET_OFFSET(&spa->spa_ubsync), ==, logical_size);
 		/*
 		 * Read from scratch space.
 		 */
 		pio = zio_root(spa, NULL, NULL, ZIO_FLAG_CANFAIL);
 		for (int i = 0; i < raidvd->vdev_children; i++) {
 			/*
 			 * Note: zio_vdev_child_io() adds VDEV_LABEL_START_SIZE
 			 * to the offset to calculate the physical offset to
 			 * write to.  Passing in a negative offset makes us
 			 * access the scratch area.
 			 */
 			zio_nowait(zio_vdev_child_io(pio, NULL,
 			    raidvd->vdev_child[i],
 			    VDEV_BOOT_OFFSET - VDEV_LABEL_START_SIZE, abds[i],
 			    write_size, ZIO_TYPE_READ, ZIO_PRIORITY_ASYNC_READ,
 			    ZIO_FLAG_CANFAIL, raidz_scratch_child_done, pio));
 		}
 		error = zio_wait(pio);
 		if (error != 0) {
 			zfs_dbgmsg("reflow: error %d reading scratch location",
 			    error);
 			goto io_error_exit;
 		}
 		goto overwrite;
 	}
 
 	/*
 	 * Read from original location.
 	 */
 	pio = zio_root(spa, NULL, NULL, ZIO_FLAG_CANFAIL);
 	for (int i = 0; i < raidvd->vdev_children - 1; i++) {
 		ASSERT0(vdev_is_dead(raidvd->vdev_child[i]));
 		zio_nowait(zio_vdev_child_io(pio, NULL, raidvd->vdev_child[i],
 		    0, abds[i], read_size, ZIO_TYPE_READ,
 		    ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL,
 		    raidz_scratch_child_done, pio));
 	}
 	error = zio_wait(pio);
 	if (error != 0) {
 		zfs_dbgmsg("reflow: error %d reading original location", error);
 io_error_exit:
 		for (int i = 0; i < raidvd->vdev_children; i++)
 			abd_free(abds[i]);
 		kmem_free(abds, raidvd->vdev_children * sizeof (abd_t *));
 		zfs_rangelock_exit(lr);
 		spa_config_exit(spa, SCL_STATE, FTAG);
 		return;
 	}
 
 	raidz_expand_pause(RAIDZ_EXPAND_PAUSE_PRE_SCRATCH_2);
 
 	/*
 	 * Reflow in memory.
 	 */
 	uint64_t logical_sectors = logical_size >> ashift;
 	for (int i = raidvd->vdev_children - 1; i < logical_sectors; i++) {
 		int oldchild = i % (raidvd->vdev_children - 1);
 		uint64_t oldoff = (i / (raidvd->vdev_children - 1)) << ashift;
 
 		int newchild = i % raidvd->vdev_children;
 		uint64_t newoff = (i / raidvd->vdev_children) << ashift;
 
 		/* a single sector should not be copying over itself */
 		ASSERT(!(newchild == oldchild && newoff == oldoff));
 
 		abd_copy_off(abds[newchild], abds[oldchild],
 		    newoff, oldoff, 1 << ashift);
 	}
 
 	/*
 	 * Verify that we filled in everything we intended to (write_size on
 	 * each child).
 	 */
 	VERIFY0(logical_sectors % raidvd->vdev_children);
 	VERIFY3U((logical_sectors / raidvd->vdev_children) << ashift, ==,
 	    write_size);
 
 	/*
 	 * Write to scratch location (boot area).
 	 */
 	pio = zio_root(spa, NULL, NULL, ZIO_FLAG_CANFAIL);
 	for (int i = 0; i < raidvd->vdev_children; i++) {
 		/*
 		 * Note: zio_vdev_child_io() adds VDEV_LABEL_START_SIZE to
 		 * the offset to calculate the physical offset to write to.
 		 * Passing in a negative offset lets us access the boot area.
 		 */
 		zio_nowait(zio_vdev_child_io(pio, NULL, raidvd->vdev_child[i],
 		    VDEV_BOOT_OFFSET - VDEV_LABEL_START_SIZE, abds[i],
 		    write_size, ZIO_TYPE_WRITE, ZIO_PRIORITY_ASYNC_WRITE,
 		    ZIO_FLAG_CANFAIL, raidz_scratch_child_done, pio));
 	}
 	error = zio_wait(pio);
 	if (error != 0) {
 		zfs_dbgmsg("reflow: error %d writing scratch location", error);
 		goto io_error_exit;
 	}
 	pio = zio_root(spa, NULL, NULL, 0);
 	zio_flush(pio, raidvd);
 	zio_wait(pio);
 
 	zfs_dbgmsg("reflow: wrote %llu bytes (logical) to scratch area",
 	    (long long)logical_size);
 
 	raidz_expand_pause(RAIDZ_EXPAND_PAUSE_PRE_SCRATCH_3);
 
 	/*
 	 * Update uberblock to indicate that scratch space is valid.  This is
 	 * needed because after this point, the real location may be
 	 * overwritten.  If we crash, we need to get the data from the
 	 * scratch space, rather than the real location.
 	 *
 	 * Note: ub_timestamp is bumped so that vdev_uberblock_compare()
 	 * will prefer this uberblock.
 	 */
 	RAIDZ_REFLOW_SET(&spa->spa_ubsync, RRSS_SCRATCH_VALID, logical_size);
 	spa->spa_ubsync.ub_timestamp++;
 	ASSERT0(vdev_uberblock_sync_list(&spa->spa_root_vdev, 1,
 	    &spa->spa_ubsync, ZIO_FLAG_CONFIG_WRITER));
 	if (spa_multihost(spa))
 		mmp_update_uberblock(spa, &spa->spa_ubsync);
 
 	zfs_dbgmsg("reflow: uberblock updated "
 	    "(txg %llu, SCRATCH_VALID, size %llu, ts %llu)",
 	    (long long)spa->spa_ubsync.ub_txg,
 	    (long long)logical_size,
 	    (long long)spa->spa_ubsync.ub_timestamp);
 
 	raidz_expand_pause(RAIDZ_EXPAND_PAUSE_SCRATCH_VALID);
 
 	/*
 	 * Overwrite with reflow'ed data.
 	 */
 overwrite:
 	pio = zio_root(spa, NULL, NULL, ZIO_FLAG_CANFAIL);
 	for (int i = 0; i < raidvd->vdev_children; i++) {
 		zio_nowait(zio_vdev_child_io(pio, NULL, raidvd->vdev_child[i],
 		    0, abds[i], write_size, ZIO_TYPE_WRITE,
 		    ZIO_PRIORITY_ASYNC_WRITE, ZIO_FLAG_CANFAIL,
 		    raidz_scratch_child_done, pio));
 	}
 	error = zio_wait(pio);
 	if (error != 0) {
 		/*
 		 * When we exit early here and drop the range lock, new
 		 * writes will go into the scratch area so we'll need to
 		 * read from there when we return after pausing.
 		 */
 		zfs_dbgmsg("reflow: error %d writing real location", error);
 		/*
 		 * Update the uberblock that is written when this txg completes.
 		 */
 		RAIDZ_REFLOW_SET(&spa->spa_uberblock, RRSS_SCRATCH_VALID,
 		    logical_size);
 		goto io_error_exit;
 	}
 	pio = zio_root(spa, NULL, NULL, 0);
 	zio_flush(pio, raidvd);
 	zio_wait(pio);
 
 	zfs_dbgmsg("reflow: overwrote %llu bytes (logical) to real location",
 	    (long long)logical_size);
 	for (int i = 0; i < raidvd->vdev_children; i++)
 		abd_free(abds[i]);
 	kmem_free(abds, raidvd->vdev_children * sizeof (abd_t *));
 
 	raidz_expand_pause(RAIDZ_EXPAND_PAUSE_SCRATCH_REFLOWED);
 
 	/*
 	 * Update uberblock to indicate that the initial part has been
 	 * reflow'ed.  This is needed because after this point (when we exit
 	 * the rangelock), we allow regular writes to this region, which will
 	 * be written to the new location only (because reflow_offset_next ==
 	 * reflow_offset_synced).  If we crashed and re-copied from the
 	 * scratch space, we would lose the regular writes.
 	 */
 	RAIDZ_REFLOW_SET(&spa->spa_ubsync, RRSS_SCRATCH_INVALID_SYNCED,
 	    logical_size);
 	spa->spa_ubsync.ub_timestamp++;
 	ASSERT0(vdev_uberblock_sync_list(&spa->spa_root_vdev, 1,
 	    &spa->spa_ubsync, ZIO_FLAG_CONFIG_WRITER));
 	if (spa_multihost(spa))
 		mmp_update_uberblock(spa, &spa->spa_ubsync);
 
 	zfs_dbgmsg("reflow: uberblock updated "
 	    "(txg %llu, SCRATCH_NOT_IN_USE, size %llu, ts %llu)",
 	    (long long)spa->spa_ubsync.ub_txg,
 	    (long long)logical_size,
 	    (long long)spa->spa_ubsync.ub_timestamp);
 
 	raidz_expand_pause(RAIDZ_EXPAND_PAUSE_SCRATCH_POST_REFLOW_1);
 
 	/*
 	 * Update progress.
 	 */
 	vre->vre_offset = logical_size;
 	zfs_rangelock_exit(lr);
 	spa_config_exit(spa, SCL_STATE, FTAG);
 
 	int txgoff = dmu_tx_get_txg(tx) & TXG_MASK;
 	vre->vre_offset_pertxg[txgoff] = vre->vre_offset;
 	vre->vre_bytes_copied_pertxg[txgoff] = vre->vre_bytes_copied;
 	/*
 	 * Note - raidz_reflow_sync() will update the uberblock state to
 	 * RRSS_SCRATCH_INVALID_SYNCED_REFLOW
 	 */
 	raidz_reflow_sync(spa, tx);
 
 	raidz_expand_pause(RAIDZ_EXPAND_PAUSE_SCRATCH_POST_REFLOW_2);
 }
 
 /*
  * We crashed in the middle of raidz_reflow_scratch_sync(); complete its work
  * here.  No other i/o can be in progress, so we don't need the vre_rangelock.
  */
 void
 vdev_raidz_reflow_copy_scratch(spa_t *spa)
 {
 	vdev_raidz_expand_t *vre = spa->spa_raidz_expand;
 	uint64_t logical_size = RRSS_GET_OFFSET(&spa->spa_uberblock);
 	ASSERT3U(RRSS_GET_STATE(&spa->spa_uberblock), ==, RRSS_SCRATCH_VALID);
 
 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
 	vdev_t *raidvd = vdev_lookup_top(spa, vre->vre_vdev_id);
 	ASSERT0(logical_size % raidvd->vdev_children);
 	uint64_t write_size = logical_size / raidvd->vdev_children;
 
 	zio_t *pio;
 
 	/*
 	 * Read from scratch space.
 	 */
 	abd_t **abds = kmem_alloc(raidvd->vdev_children * sizeof (abd_t *),
 	    KM_SLEEP);
 	for (int i = 0; i < raidvd->vdev_children; i++) {
 		abds[i] = abd_alloc_linear(write_size, B_FALSE);
 	}
 
 	pio = zio_root(spa, NULL, NULL, 0);
 	for (int i = 0; i < raidvd->vdev_children; i++) {
 		/*
 		 * Note: zio_vdev_child_io() adds VDEV_LABEL_START_SIZE to
 		 * the offset to calculate the physical offset to write to.
 		 * Passing in a negative offset lets us access the boot area.
 		 */
 		zio_nowait(zio_vdev_child_io(pio, NULL, raidvd->vdev_child[i],
 		    VDEV_BOOT_OFFSET - VDEV_LABEL_START_SIZE, abds[i],
 		    write_size, ZIO_TYPE_READ,
 		    ZIO_PRIORITY_ASYNC_READ, 0,
 		    raidz_scratch_child_done, pio));
 	}
 	zio_wait(pio);
 
 	/*
 	 * Overwrite real location with reflow'ed data.
 	 */
 	pio = zio_root(spa, NULL, NULL, 0);
 	for (int i = 0; i < raidvd->vdev_children; i++) {
 		zio_nowait(zio_vdev_child_io(pio, NULL, raidvd->vdev_child[i],
 		    0, abds[i], write_size, ZIO_TYPE_WRITE,
 		    ZIO_PRIORITY_ASYNC_WRITE, 0,
 		    raidz_scratch_child_done, pio));
 	}
 	zio_wait(pio);
 	pio = zio_root(spa, NULL, NULL, 0);
 	zio_flush(pio, raidvd);
 	zio_wait(pio);
 
 	zfs_dbgmsg("reflow recovery: overwrote %llu bytes (logical) "
 	    "to real location", (long long)logical_size);
 
 	for (int i = 0; i < raidvd->vdev_children; i++)
 		abd_free(abds[i]);
 	kmem_free(abds, raidvd->vdev_children * sizeof (abd_t *));
 
 	/*
 	 * Update uberblock.
 	 */
 	RAIDZ_REFLOW_SET(&spa->spa_ubsync,
 	    RRSS_SCRATCH_INVALID_SYNCED_ON_IMPORT, logical_size);
 	spa->spa_ubsync.ub_timestamp++;
 	VERIFY0(vdev_uberblock_sync_list(&spa->spa_root_vdev, 1,
 	    &spa->spa_ubsync, ZIO_FLAG_CONFIG_WRITER));
 	if (spa_multihost(spa))
 		mmp_update_uberblock(spa, &spa->spa_ubsync);
 
 	zfs_dbgmsg("reflow recovery: uberblock updated "
 	    "(txg %llu, SCRATCH_NOT_IN_USE, size %llu, ts %llu)",
 	    (long long)spa->spa_ubsync.ub_txg,
 	    (long long)logical_size,
 	    (long long)spa->spa_ubsync.ub_timestamp);
 
 	dmu_tx_t *tx = dmu_tx_create_assigned(spa->spa_dsl_pool,
 	    spa_first_txg(spa));
 	int txgoff = dmu_tx_get_txg(tx) & TXG_MASK;
 	vre->vre_offset = logical_size;
 	vre->vre_offset_pertxg[txgoff] = vre->vre_offset;
 	vre->vre_bytes_copied_pertxg[txgoff] = vre->vre_bytes_copied;
 	/*
 	 * Note that raidz_reflow_sync() will update the uberblock once more
 	 */
 	raidz_reflow_sync(spa, tx);
 
 	dmu_tx_commit(tx);
 
 	spa_config_exit(spa, SCL_STATE, FTAG);
 }
 
 static boolean_t
 spa_raidz_expand_thread_check(void *arg, zthr_t *zthr)
 {
 	(void) zthr;
 	spa_t *spa = arg;
 
 	return (spa->spa_raidz_expand != NULL &&
 	    !spa->spa_raidz_expand->vre_waiting_for_resilver);
 }
 
 /*
  * RAIDZ expansion background thread
  *
  * Can be called multiple times if the reflow is paused
  */
 static void
 spa_raidz_expand_thread(void *arg, zthr_t *zthr)
 {
 	spa_t *spa = arg;
 	vdev_raidz_expand_t *vre = spa->spa_raidz_expand;
 
 	if (RRSS_GET_STATE(&spa->spa_ubsync) == RRSS_SCRATCH_VALID)
 		vre->vre_offset = 0;
 	else
 		vre->vre_offset = RRSS_GET_OFFSET(&spa->spa_ubsync);
 
 	/* Reflow the begining portion using the scratch area */
 	if (vre->vre_offset == 0) {
 		VERIFY0(dsl_sync_task(spa_name(spa),
 		    NULL, raidz_reflow_scratch_sync,
 		    vre, 0, ZFS_SPACE_CHECK_NONE));
 
 		/* if we encountered errors then pause */
 		if (vre->vre_offset == 0) {
 			mutex_enter(&vre->vre_lock);
 			vre->vre_waiting_for_resilver = B_TRUE;
 			mutex_exit(&vre->vre_lock);
 			return;
 		}
 	}
 
 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
 	vdev_t *raidvd = vdev_lookup_top(spa, vre->vre_vdev_id);
 
 	uint64_t guid = raidvd->vdev_guid;
 
 	/* Iterate over all the remaining metaslabs */
 	for (uint64_t i = vre->vre_offset >> raidvd->vdev_ms_shift;
 	    i < raidvd->vdev_ms_count &&
 	    !zthr_iscancelled(zthr) &&
 	    vre->vre_failed_offset == UINT64_MAX; i++) {
 		metaslab_t *msp = raidvd->vdev_ms[i];
 
 		metaslab_disable(msp);
 		mutex_enter(&msp->ms_lock);
 
 		/*
 		 * The metaslab may be newly created (for the expanded
 		 * space), in which case its trees won't exist yet,
 		 * so we need to bail out early.
 		 */
 		if (msp->ms_new) {
 			mutex_exit(&msp->ms_lock);
 			metaslab_enable(msp, B_FALSE, B_FALSE);
 			continue;
 		}
 
 		VERIFY0(metaslab_load(msp));
 
 		/*
 		 * We want to copy everything except the free (allocatable)
 		 * space.  Note that there may be a little bit more free
 		 * space (e.g. in ms_defer), and it's fine to copy that too.
 		 */
 		range_tree_t *rt = range_tree_create(NULL, RANGE_SEG64,
 		    NULL, 0, 0);
 		range_tree_add(rt, msp->ms_start, msp->ms_size);
 		range_tree_walk(msp->ms_allocatable, range_tree_remove, rt);
 		mutex_exit(&msp->ms_lock);
 
 		/*
 		 * Force the last sector of each metaslab to be copied.  This
 		 * ensures that we advance the on-disk progress to the end of
 		 * this metaslab while the metaslab is disabled.  Otherwise, we
 		 * could move past this metaslab without advancing the on-disk
 		 * progress, and then an allocation to this metaslab would not
 		 * be copied.
 		 */
 		int sectorsz = 1 << raidvd->vdev_ashift;
 		uint64_t ms_last_offset = msp->ms_start +
 		    msp->ms_size - sectorsz;
 		if (!range_tree_contains(rt, ms_last_offset, sectorsz)) {
 			range_tree_add(rt, ms_last_offset, sectorsz);
 		}
 
 		/*
 		 * When we are resuming from a paused expansion (i.e.
 		 * when importing a pool with a expansion in progress),
 		 * discard any state that we have already processed.
 		 */
 		range_tree_clear(rt, 0, vre->vre_offset);
 
 		while (!zthr_iscancelled(zthr) &&
 		    !range_tree_is_empty(rt) &&
 		    vre->vre_failed_offset == UINT64_MAX) {
 
 			/*
 			 * We need to periodically drop the config lock so that
 			 * writers can get in.  Additionally, we can't wait
 			 * for a txg to sync while holding a config lock
 			 * (since a waiting writer could cause a 3-way deadlock
 			 * with the sync thread, which also gets a config
 			 * lock for reader).  So we can't hold the config lock
 			 * while calling dmu_tx_assign().
 			 */
 			spa_config_exit(spa, SCL_CONFIG, FTAG);
 
 			/*
 			 * If requested, pause the reflow when the amount
 			 * specified by raidz_expand_max_reflow_bytes is reached
 			 *
 			 * This pause is only used during testing or debugging.
 			 */
 			while (raidz_expand_max_reflow_bytes != 0 &&
 			    raidz_expand_max_reflow_bytes <=
 			    vre->vre_bytes_copied && !zthr_iscancelled(zthr)) {
 				delay(hz);
 			}
 
 			mutex_enter(&vre->vre_lock);
 			while (vre->vre_outstanding_bytes >
 			    raidz_expand_max_copy_bytes) {
 				cv_wait(&vre->vre_cv, &vre->vre_lock);
 			}
 			mutex_exit(&vre->vre_lock);
 
 			dmu_tx_t *tx =
 			    dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir);
 
 			VERIFY0(dmu_tx_assign(tx, TXG_WAIT));
 			uint64_t txg = dmu_tx_get_txg(tx);
 
 			/*
 			 * Reacquire the vdev_config lock.  Theoretically, the
 			 * vdev_t that we're expanding may have changed.
 			 */
 			spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
 			raidvd = vdev_lookup_top(spa, vre->vre_vdev_id);
 
 			boolean_t needsync =
 			    raidz_reflow_impl(raidvd, vre, rt, tx);
 
 			dmu_tx_commit(tx);
 
 			if (needsync) {
 				spa_config_exit(spa, SCL_CONFIG, FTAG);
 				txg_wait_synced(spa->spa_dsl_pool, txg);
 				spa_config_enter(spa, SCL_CONFIG, FTAG,
 				    RW_READER);
 			}
 		}
 
 		spa_config_exit(spa, SCL_CONFIG, FTAG);
 
 		metaslab_enable(msp, B_FALSE, B_FALSE);
 		range_tree_vacate(rt, NULL, NULL);
 		range_tree_destroy(rt);
 
 		spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
 		raidvd = vdev_lookup_top(spa, vre->vre_vdev_id);
 	}
 
 	spa_config_exit(spa, SCL_CONFIG, FTAG);
 
 	/*
 	 * The txg_wait_synced() here ensures that all reflow zio's have
 	 * completed, and vre_failed_offset has been set if necessary.  It
 	 * also ensures that the progress of the last raidz_reflow_sync() is
 	 * written to disk before raidz_reflow_complete_sync() changes the
 	 * in-memory vre_state.  vdev_raidz_io_start() uses vre_state to
 	 * determine if a reflow is in progress, in which case we may need to
 	 * write to both old and new locations.  Therefore we can only change
 	 * vre_state once this is not necessary, which is once the on-disk
 	 * progress (in spa_ubsync) has been set past any possible writes (to
 	 * the end of the last metaslab).
 	 */
 	txg_wait_synced(spa->spa_dsl_pool, 0);
 
 	if (!zthr_iscancelled(zthr) &&
 	    vre->vre_offset == raidvd->vdev_ms_count << raidvd->vdev_ms_shift) {
 		/*
 		 * We are not being canceled or paused, so the reflow must be
 		 * complete. In that case also mark it as completed on disk.
 		 */
 		ASSERT3U(vre->vre_failed_offset, ==, UINT64_MAX);
 		VERIFY0(dsl_sync_task(spa_name(spa), NULL,
 		    raidz_reflow_complete_sync, spa,
 		    0, ZFS_SPACE_CHECK_NONE));
 		(void) vdev_online(spa, guid, ZFS_ONLINE_EXPAND, NULL);
 	} else {
 		/*
 		 * Wait for all copy zio's to complete and for all the
 		 * raidz_reflow_sync() synctasks to be run.
 		 */
 		spa_history_log_internal(spa, "reflow pause",
 		    NULL, "offset=%llu failed_offset=%lld",
 		    (long long)vre->vre_offset,
 		    (long long)vre->vre_failed_offset);
 		mutex_enter(&vre->vre_lock);
 		if (vre->vre_failed_offset != UINT64_MAX) {
 			/*
 			 * Reset progress so that we will retry everything
 			 * after the point that something failed.
 			 */
 			vre->vre_offset = vre->vre_failed_offset;
 			vre->vre_failed_offset = UINT64_MAX;
 			vre->vre_waiting_for_resilver = B_TRUE;
 		}
 		mutex_exit(&vre->vre_lock);
 	}
 }
 
 void
 spa_start_raidz_expansion_thread(spa_t *spa)
 {
 	ASSERT3P(spa->spa_raidz_expand_zthr, ==, NULL);
 	spa->spa_raidz_expand_zthr = zthr_create("raidz_expand",
 	    spa_raidz_expand_thread_check, spa_raidz_expand_thread,
 	    spa, defclsyspri);
 }
 
 void
 raidz_dtl_reassessed(vdev_t *vd)
 {
 	spa_t *spa = vd->vdev_spa;
 	if (spa->spa_raidz_expand != NULL) {
 		vdev_raidz_expand_t *vre = spa->spa_raidz_expand;
 		/*
 		 * we get called often from vdev_dtl_reassess() so make
 		 * sure it's our vdev and any replacing is complete
 		 */
 		if (vd->vdev_top->vdev_id == vre->vre_vdev_id &&
 		    !vdev_raidz_expand_child_replacing(vd->vdev_top)) {
 			mutex_enter(&vre->vre_lock);
 			if (vre->vre_waiting_for_resilver) {
 				vdev_dbgmsg(vd, "DTL reassessed, "
 				    "continuing raidz expansion");
 				vre->vre_waiting_for_resilver = B_FALSE;
 				zthr_wakeup(spa->spa_raidz_expand_zthr);
 			}
 			mutex_exit(&vre->vre_lock);
 		}
 	}
 }
 
 int
 vdev_raidz_attach_check(vdev_t *new_child)
 {
 	vdev_t *raidvd = new_child->vdev_parent;
 	uint64_t new_children = raidvd->vdev_children;
 
 	/*
 	 * We use the "boot" space as scratch space to handle overwriting the
 	 * initial part of the vdev.  If it is too small, then this expansion
 	 * is not allowed.  This would be very unusual (e.g. ashift > 13 and
 	 * >200 children).
 	 */
 	if (new_children << raidvd->vdev_ashift > VDEV_BOOT_SIZE) {
 		return (EINVAL);
 	}
 	return (0);
 }
 
 void
 vdev_raidz_attach_sync(void *arg, dmu_tx_t *tx)
 {
 	vdev_t *new_child = arg;
 	spa_t *spa = new_child->vdev_spa;
 	vdev_t *raidvd = new_child->vdev_parent;
 	vdev_raidz_t *vdrz = raidvd->vdev_tsd;
 	ASSERT3P(raidvd->vdev_ops, ==, &vdev_raidz_ops);
 	ASSERT3P(raidvd->vdev_top, ==, raidvd);
 	ASSERT3U(raidvd->vdev_children, >, vdrz->vd_original_width);
 	ASSERT3U(raidvd->vdev_children, ==, vdrz->vd_physical_width + 1);
 	ASSERT3P(raidvd->vdev_child[raidvd->vdev_children - 1], ==,
 	    new_child);
 
 	spa_feature_incr(spa, SPA_FEATURE_RAIDZ_EXPANSION, tx);
 
 	vdrz->vd_physical_width++;
 
 	VERIFY0(spa->spa_uberblock.ub_raidz_reflow_info);
 	vdrz->vn_vre.vre_vdev_id = raidvd->vdev_id;
 	vdrz->vn_vre.vre_offset = 0;
 	vdrz->vn_vre.vre_failed_offset = UINT64_MAX;
 	spa->spa_raidz_expand = &vdrz->vn_vre;
 	zthr_wakeup(spa->spa_raidz_expand_zthr);
 
 	/*
 	 * Dirty the config so that ZPOOL_CONFIG_RAIDZ_EXPANDING will get
 	 * written to the config.
 	 */
 	vdev_config_dirty(raidvd);
 
 	vdrz->vn_vre.vre_start_time = gethrestime_sec();
 	vdrz->vn_vre.vre_end_time = 0;
 	vdrz->vn_vre.vre_state = DSS_SCANNING;
 	vdrz->vn_vre.vre_bytes_copied = 0;
 
 	uint64_t state = vdrz->vn_vre.vre_state;
 	VERIFY0(zap_update(spa->spa_meta_objset,
 	    raidvd->vdev_top_zap, VDEV_TOP_ZAP_RAIDZ_EXPAND_STATE,
 	    sizeof (state), 1, &state, tx));
 
 	uint64_t start_time = vdrz->vn_vre.vre_start_time;
 	VERIFY0(zap_update(spa->spa_meta_objset,
 	    raidvd->vdev_top_zap, VDEV_TOP_ZAP_RAIDZ_EXPAND_START_TIME,
 	    sizeof (start_time), 1, &start_time, tx));
 
 	(void) zap_remove(spa->spa_meta_objset,
 	    raidvd->vdev_top_zap, VDEV_TOP_ZAP_RAIDZ_EXPAND_END_TIME, tx);
 	(void) zap_remove(spa->spa_meta_objset,
 	    raidvd->vdev_top_zap, VDEV_TOP_ZAP_RAIDZ_EXPAND_BYTES_COPIED, tx);
 
 	spa_history_log_internal(spa, "raidz vdev expansion started",  tx,
 	    "%s vdev %llu new width %llu", spa_name(spa),
 	    (unsigned long long)raidvd->vdev_id,
 	    (unsigned long long)raidvd->vdev_children);
 }
 
 int
 vdev_raidz_load(vdev_t *vd)
 {
 	vdev_raidz_t *vdrz = vd->vdev_tsd;
 	int err;
 
 	uint64_t state = DSS_NONE;
 	uint64_t start_time = 0;
 	uint64_t end_time = 0;
 	uint64_t bytes_copied = 0;
 
 	if (vd->vdev_top_zap != 0) {
 		err = zap_lookup(vd->vdev_spa->spa_meta_objset,
 		    vd->vdev_top_zap, VDEV_TOP_ZAP_RAIDZ_EXPAND_STATE,
 		    sizeof (state), 1, &state);
 		if (err != 0 && err != ENOENT)
 			return (err);
 
 		err = zap_lookup(vd->vdev_spa->spa_meta_objset,
 		    vd->vdev_top_zap, VDEV_TOP_ZAP_RAIDZ_EXPAND_START_TIME,
 		    sizeof (start_time), 1, &start_time);
 		if (err != 0 && err != ENOENT)
 			return (err);
 
 		err = zap_lookup(vd->vdev_spa->spa_meta_objset,
 		    vd->vdev_top_zap, VDEV_TOP_ZAP_RAIDZ_EXPAND_END_TIME,
 		    sizeof (end_time), 1, &end_time);
 		if (err != 0 && err != ENOENT)
 			return (err);
 
 		err = zap_lookup(vd->vdev_spa->spa_meta_objset,
 		    vd->vdev_top_zap, VDEV_TOP_ZAP_RAIDZ_EXPAND_BYTES_COPIED,
 		    sizeof (bytes_copied), 1, &bytes_copied);
 		if (err != 0 && err != ENOENT)
 			return (err);
 	}
 
 	/*
 	 * If we are in the middle of expansion, vre_state should have
 	 * already been set by vdev_raidz_init().
 	 */
 	EQUIV(vdrz->vn_vre.vre_state == DSS_SCANNING, state == DSS_SCANNING);
 	vdrz->vn_vre.vre_state = (dsl_scan_state_t)state;
 	vdrz->vn_vre.vre_start_time = start_time;
 	vdrz->vn_vre.vre_end_time = end_time;
 	vdrz->vn_vre.vre_bytes_copied = bytes_copied;
 
 	return (0);
 }
 
 int
 spa_raidz_expand_get_stats(spa_t *spa, pool_raidz_expand_stat_t *pres)
 {
 	vdev_raidz_expand_t *vre = spa->spa_raidz_expand;
 
 	if (vre == NULL) {
 		/* no removal in progress; find most recent completed */
 		for (int c = 0; c < spa->spa_root_vdev->vdev_children; c++) {
 			vdev_t *vd = spa->spa_root_vdev->vdev_child[c];
 			if (vd->vdev_ops == &vdev_raidz_ops) {
 				vdev_raidz_t *vdrz = vd->vdev_tsd;
 
 				if (vdrz->vn_vre.vre_end_time != 0 &&
 				    (vre == NULL ||
 				    vdrz->vn_vre.vre_end_time >
 				    vre->vre_end_time)) {
 					vre = &vdrz->vn_vre;
 				}
 			}
 		}
 	}
 
 	if (vre == NULL) {
 		return (SET_ERROR(ENOENT));
 	}
 
 	pres->pres_state = vre->vre_state;
 	pres->pres_expanding_vdev = vre->vre_vdev_id;
 
 	vdev_t *vd = vdev_lookup_top(spa, vre->vre_vdev_id);
 	pres->pres_to_reflow = vd->vdev_stat.vs_alloc;
 
 	mutex_enter(&vre->vre_lock);
 	pres->pres_reflowed = vre->vre_bytes_copied;
 	for (int i = 0; i < TXG_SIZE; i++)
 		pres->pres_reflowed += vre->vre_bytes_copied_pertxg[i];
 	mutex_exit(&vre->vre_lock);
 
 	pres->pres_start_time = vre->vre_start_time;
 	pres->pres_end_time = vre->vre_end_time;
 	pres->pres_waiting_for_resilver = vre->vre_waiting_for_resilver;
 
 	return (0);
 }
 
 /*
  * Initialize private RAIDZ specific fields from the nvlist.
  */
 static int
 vdev_raidz_init(spa_t *spa, nvlist_t *nv, void **tsd)
 {
 	uint_t children;
 	nvlist_t **child;
 	int error = nvlist_lookup_nvlist_array(nv,
 	    ZPOOL_CONFIG_CHILDREN, &child, &children);
 	if (error != 0)
 		return (SET_ERROR(EINVAL));
 
 	uint64_t nparity;
 	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY, &nparity) == 0) {
 		if (nparity == 0 || nparity > VDEV_RAIDZ_MAXPARITY)
 			return (SET_ERROR(EINVAL));
 
 		/*
 		 * Previous versions could only support 1 or 2 parity
 		 * device.
 		 */
 		if (nparity > 1 && spa_version(spa) < SPA_VERSION_RAIDZ2)
 			return (SET_ERROR(EINVAL));
 		else if (nparity > 2 && spa_version(spa) < SPA_VERSION_RAIDZ3)
 			return (SET_ERROR(EINVAL));
 	} else {
 		/*
 		 * We require the parity to be specified for SPAs that
 		 * support multiple parity levels.
 		 */
 		if (spa_version(spa) >= SPA_VERSION_RAIDZ2)
 			return (SET_ERROR(EINVAL));
 
 		/*
 		 * Otherwise, we default to 1 parity device for RAID-Z.
 		 */
 		nparity = 1;
 	}
 
 	vdev_raidz_t *vdrz = kmem_zalloc(sizeof (*vdrz), KM_SLEEP);
 	vdrz->vn_vre.vre_vdev_id = -1;
 	vdrz->vn_vre.vre_offset = UINT64_MAX;
 	vdrz->vn_vre.vre_failed_offset = UINT64_MAX;
 	mutex_init(&vdrz->vn_vre.vre_lock, NULL, MUTEX_DEFAULT, NULL);
 	cv_init(&vdrz->vn_vre.vre_cv, NULL, CV_DEFAULT, NULL);
 	zfs_rangelock_init(&vdrz->vn_vre.vre_rangelock, NULL, NULL);
 	mutex_init(&vdrz->vd_expand_lock, NULL, MUTEX_DEFAULT, NULL);
 	avl_create(&vdrz->vd_expand_txgs, vdev_raidz_reflow_compare,
 	    sizeof (reflow_node_t), offsetof(reflow_node_t, re_link));
 
 	vdrz->vd_physical_width = children;
 	vdrz->vd_nparity = nparity;
 
 	/* note, the ID does not exist when creating a pool */
 	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ID,
 	    &vdrz->vn_vre.vre_vdev_id);
 
 	boolean_t reflow_in_progress =
 	    nvlist_exists(nv, ZPOOL_CONFIG_RAIDZ_EXPANDING);
 	if (reflow_in_progress) {
 		spa->spa_raidz_expand = &vdrz->vn_vre;
 		vdrz->vn_vre.vre_state = DSS_SCANNING;
 	}
 
 	vdrz->vd_original_width = children;
 	uint64_t *txgs;
 	unsigned int txgs_size = 0;
 	error = nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_RAIDZ_EXPAND_TXGS,
 	    &txgs, &txgs_size);
 	if (error == 0) {
 		for (int i = 0; i < txgs_size; i++) {
 			reflow_node_t *re = kmem_zalloc(sizeof (*re), KM_SLEEP);
 			re->re_txg = txgs[txgs_size - i - 1];
 			re->re_logical_width = vdrz->vd_physical_width - i;
 
 			if (reflow_in_progress)
 				re->re_logical_width--;
 
 			avl_add(&vdrz->vd_expand_txgs, re);
 		}
 
 		vdrz->vd_original_width = vdrz->vd_physical_width - txgs_size;
 	}
 	if (reflow_in_progress) {
 		vdrz->vd_original_width--;
 		zfs_dbgmsg("reflow_in_progress, %u wide, %d prior expansions",
 		    children, txgs_size);
 	}
 
 	*tsd = vdrz;
 
 	return (0);
 }
 
 static void
 vdev_raidz_fini(vdev_t *vd)
 {
 	vdev_raidz_t *vdrz = vd->vdev_tsd;
 	if (vd->vdev_spa->spa_raidz_expand == &vdrz->vn_vre)
 		vd->vdev_spa->spa_raidz_expand = NULL;
 	reflow_node_t *re;
 	void *cookie = NULL;
 	avl_tree_t *tree = &vdrz->vd_expand_txgs;
 	while ((re = avl_destroy_nodes(tree, &cookie)) != NULL)
 		kmem_free(re, sizeof (*re));
 	avl_destroy(&vdrz->vd_expand_txgs);
 	mutex_destroy(&vdrz->vd_expand_lock);
 	mutex_destroy(&vdrz->vn_vre.vre_lock);
 	cv_destroy(&vdrz->vn_vre.vre_cv);
 	zfs_rangelock_fini(&vdrz->vn_vre.vre_rangelock);
 	kmem_free(vdrz, sizeof (*vdrz));
 }
 
 /*
  * Add RAIDZ specific fields to the config nvlist.
  */
 static void
 vdev_raidz_config_generate(vdev_t *vd, nvlist_t *nv)
 {
 	ASSERT3P(vd->vdev_ops, ==, &vdev_raidz_ops);
 	vdev_raidz_t *vdrz = vd->vdev_tsd;
 
 	/*
 	 * Make sure someone hasn't managed to sneak a fancy new vdev
 	 * into a crufty old storage pool.
 	 */
 	ASSERT(vdrz->vd_nparity == 1 ||
 	    (vdrz->vd_nparity <= 2 &&
 	    spa_version(vd->vdev_spa) >= SPA_VERSION_RAIDZ2) ||
 	    (vdrz->vd_nparity <= 3 &&
 	    spa_version(vd->vdev_spa) >= SPA_VERSION_RAIDZ3));
 
 	/*
 	 * Note that we'll add these even on storage pools where they
 	 * aren't strictly required -- older software will just ignore
 	 * it.
 	 */
 	fnvlist_add_uint64(nv, ZPOOL_CONFIG_NPARITY, vdrz->vd_nparity);
 
 	if (vdrz->vn_vre.vre_state == DSS_SCANNING) {
 		fnvlist_add_boolean(nv, ZPOOL_CONFIG_RAIDZ_EXPANDING);
 	}
 
 	mutex_enter(&vdrz->vd_expand_lock);
 	if (!avl_is_empty(&vdrz->vd_expand_txgs)) {
 		uint64_t count = avl_numnodes(&vdrz->vd_expand_txgs);
 		uint64_t *txgs = kmem_alloc(sizeof (uint64_t) * count,
 		    KM_SLEEP);
 		uint64_t i = 0;
 
 		for (reflow_node_t *re = avl_first(&vdrz->vd_expand_txgs);
 		    re != NULL; re = AVL_NEXT(&vdrz->vd_expand_txgs, re)) {
 			txgs[i++] = re->re_txg;
 		}
 
 		fnvlist_add_uint64_array(nv, ZPOOL_CONFIG_RAIDZ_EXPAND_TXGS,
 		    txgs, count);
 
 		kmem_free(txgs, sizeof (uint64_t) * count);
 	}
 	mutex_exit(&vdrz->vd_expand_lock);
 }
 
 static uint64_t
 vdev_raidz_nparity(vdev_t *vd)
 {
 	vdev_raidz_t *vdrz = vd->vdev_tsd;
 	return (vdrz->vd_nparity);
 }
 
 static uint64_t
 vdev_raidz_ndisks(vdev_t *vd)
 {
 	return (vd->vdev_children);
 }
 
 vdev_ops_t vdev_raidz_ops = {
 	.vdev_op_init = vdev_raidz_init,
 	.vdev_op_fini = vdev_raidz_fini,
 	.vdev_op_open = vdev_raidz_open,
 	.vdev_op_close = vdev_raidz_close,
 	.vdev_op_asize = vdev_raidz_asize,
 	.vdev_op_min_asize = vdev_raidz_min_asize,
 	.vdev_op_min_alloc = NULL,
 	.vdev_op_io_start = vdev_raidz_io_start,
 	.vdev_op_io_done = vdev_raidz_io_done,
 	.vdev_op_state_change = vdev_raidz_state_change,
 	.vdev_op_need_resilver = vdev_raidz_need_resilver,
 	.vdev_op_hold = NULL,
 	.vdev_op_rele = NULL,
 	.vdev_op_remap = NULL,
 	.vdev_op_xlate = vdev_raidz_xlate,
 	.vdev_op_rebuild_asize = NULL,
 	.vdev_op_metaslab_init = NULL,
 	.vdev_op_config_generate = vdev_raidz_config_generate,
 	.vdev_op_nparity = vdev_raidz_nparity,
 	.vdev_op_ndisks = vdev_raidz_ndisks,
 	.vdev_op_type = VDEV_TYPE_RAIDZ,	/* name of this vdev type */
 	.vdev_op_leaf = B_FALSE			/* not a leaf vdev */
 };
 
 /* BEGIN CSTYLED */
 ZFS_MODULE_PARAM(zfs_vdev, raidz_, expand_max_reflow_bytes, ULONG, ZMOD_RW,
 	"For testing, pause RAIDZ expansion after reflowing this many bytes");
 ZFS_MODULE_PARAM(zfs_vdev, raidz_, expand_max_copy_bytes, ULONG, ZMOD_RW,
 	"Max amount of concurrent i/o for RAIDZ expansion");
 ZFS_MODULE_PARAM(zfs_vdev, raidz_, io_aggregate_rows, ULONG, ZMOD_RW,
 	"For expanded RAIDZ, aggregate reads that have more rows than this");
 ZFS_MODULE_PARAM(zfs, zfs_, scrub_after_expand, INT, ZMOD_RW,
 	"For expanded RAIDZ, automatically start a pool scrub when expansion "
 	"completes");
 /* END CSTYLED */
diff --git a/sys/contrib/openzfs/module/zfs/zfs_vnops.c b/sys/contrib/openzfs/module/zfs/zfs_vnops.c
index a96f508ffac0..0799f17758bf 100644
--- a/sys/contrib/openzfs/module/zfs/zfs_vnops.c
+++ b/sys/contrib/openzfs/module/zfs/zfs_vnops.c
@@ -1,1815 +1,1844 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 
 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
  * Copyright (c) 2015 by Chunwei Chen. All rights reserved.
  * Copyright 2017 Nexenta Systems, Inc.
  * Copyright (c) 2021, 2022 by Pawel Jakub Dawidek
  */
 
 /* 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/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/dsl_crypt.h>
 #include <sys/spa.h>
 #include <sys/txg.h>
 #include <sys/dbuf.h>
 #include <sys/policy.h>
 #include <sys/zfeature.h>
 #include <sys/zfs_vnops.h>
 #include <sys/zfs_quota.h>
 #include <sys/zfs_vfsops.h>
 #include <sys/zfs_znode.h>
 
 /*
  * Enable the experimental block cloning feature.  If this setting is 0, then
  * even if feature@block_cloning is enabled, attempts to clone blocks will act
  * as though the feature is disabled.
  */
 int zfs_bclone_enabled = 1;
 
 /*
  * When set zfs_clone_range() waits for dirty data to be written to disk.
  * This allows the clone operation to reliably succeed when a file is modified
  * and then immediately cloned. For small files this may be slower than making
  * a copy of the file and is therefore not the default.  However, in certain
  * scenarios this behavior may be desirable so a tunable is provided.
  */
 static int zfs_bclone_wait_dirty = 0;
 
 /*
  * Enable Direct I/O. If this setting is 0, then all I/O requests will be
  * directed through the ARC acting as though the dataset property direct was
  * set to disabled.
+ *
+ * Disabled by default on FreeBSD until a potential range locking issue in
+ * zfs_getpages() can be resolved.
  */
+#ifdef __FreeBSD__
 static int zfs_dio_enabled = 0;
+#else
+static int zfs_dio_enabled = 1;
+#endif
 
 
 /*
  * Maximum bytes to read per chunk in zfs_read().
  */
 static uint64_t zfs_vnops_read_chunk_size = 1024 * 1024;
 
 int
 zfs_fsync(znode_t *zp, int syncflag, cred_t *cr)
 {
 	int error = 0;
 	zfsvfs_t *zfsvfs = ZTOZSB(zp);
 
 	if (zfsvfs->z_os->os_sync != ZFS_SYNC_DISABLED) {
 		if ((error = zfs_enter_verify_zp(zfsvfs, zp, FTAG)) != 0)
 			return (error);
 		atomic_inc_32(&zp->z_sync_writes_cnt);
 		zil_commit(zfsvfs->z_log, zp->z_id);
 		atomic_dec_32(&zp->z_sync_writes_cnt);
 		zfs_exit(zfsvfs, FTAG);
 	}
 	return (error);
 }
 
 
 #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, 0, file_sz - 1))
 		zn_flush_cached_data(zp, B_TRUE);
 
 	lr = zfs_rangelock_enter(&zp->z_rangelock, 0, UINT64_MAX, 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 */
 	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;
 
 	if ((error = zfs_enter_verify_zp(zfsvfs, zp, FTAG)) != 0)
 		return (error);
 
 	error = zfs_holey_common(zp, cmd, off);
 
 	zfs_exit(zfsvfs, FTAG);
 	return (error);
 }
 #endif /* SEEK_HOLE && SEEK_DATA */
 
 int
 zfs_access(znode_t *zp, int mode, int flag, cred_t *cr)
 {
 	zfsvfs_t *zfsvfs = ZTOZSB(zp);
 	int error;
 
 	if ((error = zfs_enter_verify_zp(zfsvfs, zp, FTAG)) != 0)
 		return (error);
 
 	if (flag & V_ACE_MASK)
 #if defined(__linux__)
 		error = zfs_zaccess(zp, mode, flag, B_FALSE, cr,
 		    zfs_init_idmap);
 #else
 		error = zfs_zaccess(zp, mode, flag, B_FALSE, cr,
 		    NULL);
 #endif
 	else
 #if defined(__linux__)
 		error = zfs_zaccess_rwx(zp, mode, flag, cr, zfs_init_idmap);
 #else
 		error = zfs_zaccess_rwx(zp, mode, flag, cr, NULL);
 #endif
 
 	zfs_exit(zfsvfs, FTAG);
 	return (error);
 }
 
 /*
  * Determine if Direct I/O has been requested (either via the O_DIRECT flag or
  * the "direct" dataset property). When inherited by the property only apply
  * the O_DIRECT flag to correctly aligned IO requests. The rational for this
  * is it allows the property to be safely set on a dataset without forcing
  * all of the applications to be aware of the alignment restrictions. When
  * O_DIRECT is explicitly requested by an application return EINVAL if the
  * request is unaligned.  In all cases, if the range for this request has
  * been mmap'ed then we will perform buffered I/O to keep the mapped region
  * synhronized with the ARC.
  *
  * It is possible that a file's pages could be mmap'ed after it is checked
  * here. If so, that is handled coorarding in zfs_write(). See comments in the
  * following area for how this is handled:
  * zfs_write() -> update_pages()
  */
 static int
 zfs_setup_direct(struct znode *zp, zfs_uio_t *uio, zfs_uio_rw_t rw,
     int *ioflagp)
 {
 	zfsvfs_t *zfsvfs = ZTOZSB(zp);
 	objset_t *os = zfsvfs->z_os;
 	int ioflag = *ioflagp;
 	int error = 0;
 
 	if (!zfs_dio_enabled || os->os_direct == ZFS_DIRECT_DISABLED ||
 	    zn_has_cached_data(zp, zfs_uio_offset(uio),
 	    zfs_uio_offset(uio) + zfs_uio_resid(uio) - 1)) {
 		/*
 		 * Direct I/O is disabled or the region is mmap'ed. In either
 		 * case the I/O request will just directed through the ARC.
 		 */
 		ioflag &= ~O_DIRECT;
 		goto out;
 	} else if (os->os_direct == ZFS_DIRECT_ALWAYS &&
 	    zfs_uio_page_aligned(uio) &&
 	    zfs_uio_aligned(uio, PAGE_SIZE)) {
 		if ((rw == UIO_WRITE && zfs_uio_resid(uio) >= zp->z_blksz) ||
 		    (rw == UIO_READ)) {
 			ioflag |= O_DIRECT;
 		}
 	} else if (os->os_direct == ZFS_DIRECT_ALWAYS && (ioflag & O_DIRECT)) {
 		/*
 		 * Direct I/O was requested through the direct=always, but it
 		 * is not properly PAGE_SIZE aligned. The request will be
 		 * directed through the ARC.
 		 */
 		ioflag &= ~O_DIRECT;
 	}
 
 	if (ioflag & O_DIRECT) {
 		if (!zfs_uio_page_aligned(uio) ||
 		    !zfs_uio_aligned(uio, PAGE_SIZE)) {
 			error = SET_ERROR(EINVAL);
 			goto out;
 		}
 
 		error = zfs_uio_get_dio_pages_alloc(uio, rw);
 		if (error) {
 			goto out;
 		}
 	}
 
 	IMPLY(ioflag & O_DIRECT, uio->uio_extflg & UIO_DIRECT);
 	ASSERT0(error);
 
 out:
 	*ioflagp = ioflag;
 	return (error);
 }
 
 /*
  * 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
  */
 int
 zfs_read(struct znode *zp, zfs_uio_t *uio, int ioflag, cred_t *cr)
 {
 	(void) cr;
 	int error = 0;
 	boolean_t frsync = B_FALSE;
+	boolean_t dio_checksum_failure = B_FALSE;
 
 	zfsvfs_t *zfsvfs = ZTOZSB(zp);
 	if ((error = zfs_enter_verify_zp(zfsvfs, zp, FTAG)) != 0)
 		return (error);
 
 	if (zp->z_pflags & ZFS_AV_QUARANTINED) {
 		zfs_exit(zfsvfs, FTAG);
 		return (SET_ERROR(EACCES));
 	}
 
 	/* We don't copy out anything useful for directories. */
 	if (Z_ISDIR(ZTOTYPE(zp))) {
 		zfs_exit(zfsvfs, FTAG);
 		return (SET_ERROR(EISDIR));
 	}
 
 	/*
 	 * Validate file offset
 	 */
 	if (zfs_uio_offset(uio) < (offset_t)0) {
 		zfs_exit(zfsvfs, FTAG);
 		return (SET_ERROR(EINVAL));
 	}
 
 	/*
 	 * Fasttrack empty reads
 	 */
 	if (zfs_uio_resid(uio) == 0) {
 		zfs_exit(zfsvfs, FTAG);
 		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);
 
 	/*
 	 * Setting up Direct I/O if requested.
 	 */
 	error = zfs_setup_direct(zp, uio, UIO_READ, &ioflag);
 	if (error) {
 		goto out;
 	}
 
 #if defined(__linux__)
 	ssize_t start_offset = zfs_uio_offset(uio);
 #endif
 	ssize_t chunk_size = zfs_vnops_read_chunk_size;
 	ssize_t n = MIN(zfs_uio_resid(uio), zp->z_size - zfs_uio_offset(uio));
 	ssize_t start_resid = n;
 	ssize_t dio_remaining_resid = 0;
 
 	if (uio->uio_extflg & UIO_DIRECT) {
 		/*
 		 * All pages for an O_DIRECT request ahve already been mapped
 		 * so there's no compelling reason to handle this uio in
 		 * smaller chunks.
 		 */
 		chunk_size = DMU_MAX_ACCESS;
 
 		/*
 		 * In the event that the O_DIRECT request is reading the entire
 		 * file, it is possible file's length is not page sized
 		 * aligned. However, lower layers expect that the Direct I/O
 		 * request is page-aligned. In this case, as much of the file
 		 * that can be read using Direct I/O happens and the remaining
 		 * amount will be read through the ARC.
 		 *
 		 * This is still consistent with the semantics of Direct I/O in
 		 * ZFS as at a minimum the I/O request must be page-aligned.
 		 */
 		dio_remaining_resid = n - P2ALIGN_TYPED(n, PAGE_SIZE, ssize_t);
 		if (dio_remaining_resid != 0)
 			n -= dio_remaining_resid;
 	}
 
 	while (n > 0) {
 		ssize_t nbytes = MIN(n, chunk_size -
 		    P2PHASE(zfs_uio_offset(uio), 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, zfs_uio_offset(uio),
 		    zfs_uio_offset(uio) + nbytes - 1)) {
 			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);
+			if (error == ECKSUM) {
+				/*
+				 * If a Direct I/O read returned a checksum
+				 * verify error, then it must be treated as
+				 * suspicious. The contents of the buffer could
+				 * have beeen manipulated while the I/O was in
+				 * flight. In this case, the remainder of I/O
+				 * request will just be reissued through the
+				 * ARC.
+				 */
+				if (uio->uio_extflg & UIO_DIRECT) {
+					dio_checksum_failure = B_TRUE;
+					uio->uio_extflg &= ~UIO_DIRECT;
+					n += dio_remaining_resid;
+					dio_remaining_resid = 0;
+					continue;
+				} else {
+					error = SET_ERROR(EIO);
+				}
+			}
 
 #if defined(__linux__)
 			/*
 			 * if we actually read some bytes, bubbling EFAULT
 			 * up to become EAGAIN isn't what we want here...
 			 *
 			 * ...on Linux, at least. On FBSD, doing this breaks.
 			 */
 			if (error == EFAULT &&
 			    (zfs_uio_offset(uio) - start_offset) != 0)
 				error = 0;
 #endif
 			break;
 		}
 
 		n -= nbytes;
 	}
 
 	if (error == 0 && (uio->uio_extflg & UIO_DIRECT) &&
 	    dio_remaining_resid != 0) {
 		/*
 		 * Temporarily remove the UIO_DIRECT flag from the UIO so the
 		 * remainder of the file can be read using the ARC.
 		 */
 		uio->uio_extflg &= ~UIO_DIRECT;
 
 		if (zn_has_cached_data(zp, zfs_uio_offset(uio),
 		    zfs_uio_offset(uio) + dio_remaining_resid - 1)) {
 			error = mappedread(zp, dio_remaining_resid, uio);
 		} else {
 			error = dmu_read_uio_dbuf(sa_get_db(zp->z_sa_hdl), uio,
 			    dio_remaining_resid);
 		}
 		uio->uio_extflg |= UIO_DIRECT;
 
 		if (error != 0)
 			n += dio_remaining_resid;
 	} else if (error && (uio->uio_extflg & UIO_DIRECT)) {
 		n += dio_remaining_resid;
 	}
 	int64_t nread = start_resid - n;
 
 	dataset_kstats_update_read_kstats(&zfsvfs->z_kstat, nread);
 out:
 	zfs_rangelock_exit(lr);
 
+	if (dio_checksum_failure == B_TRUE)
+		uio->uio_extflg |= UIO_DIRECT;
+
 	/*
 	 * Cleanup for Direct I/O if requested.
 	 */
 	if (uio->uio_extflg & UIO_DIRECT)
 		zfs_uio_free_dio_pages(uio, UIO_READ);
 
 	ZFS_ACCESSTIME_STAMP(zfsvfs, zp);
 	zfs_exit(zfsvfs, FTAG);
 	return (error);
 }
 
 static void
 zfs_clear_setid_bits_if_necessary(zfsvfs_t *zfsvfs, znode_t *zp, cred_t *cr,
     uint64_t *clear_setid_bits_txgp, dmu_tx_t *tx)
 {
 	zilog_t *zilog = zfsvfs->z_log;
 	const uint64_t uid = KUID_TO_SUID(ZTOUID(zp));
 
 	ASSERT(clear_setid_bits_txgp != NULL);
 	ASSERT(tx != NULL);
 
 	/*
 	 * 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);
 
 		/*
 		 * Make sure SUID/SGID bits will be removed when we replay the
 		 * log. If the setid bits are keep coming back, don't log more
 		 * than one TX_SETATTR per transaction group.
 		 */
 		if (*clear_setid_bits_txgp != dmu_tx_get_txg(tx)) {
 			vattr_t va = {0};
 
 			va.va_mask = ATTR_MODE;
 			va.va_nodeid = zp->z_id;
 			va.va_mode = newmode;
 			zfs_log_setattr(zilog, tx, TX_SETATTR, zp, &va,
 			    ATTR_MODE, NULL);
 			*clear_setid_bits_txgp = dmu_tx_get_txg(tx);
 		}
 	} else {
 		mutex_exit(&zp->z_acl_lock);
 	}
 }
 
 /*
  * 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
  */
 int
 zfs_write(znode_t *zp, zfs_uio_t *uio, int ioflag, cred_t *cr)
 {
 	int error = 0, error1;
 	ssize_t start_resid = zfs_uio_resid(uio);
 	uint64_t clear_setid_bits_txg = 0;
 	boolean_t o_direct_defer = B_FALSE;
 
 	/*
 	 * Fasttrack empty write
 	 */
 	ssize_t n = start_resid;
 	if (n == 0)
 		return (0);
 
 	zfsvfs_t *zfsvfs = ZTOZSB(zp);
 	if ((error = zfs_enter_verify_zp(zfsvfs, zp, FTAG)) != 0)
 		return (error);
 
 	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, FTAG);
 		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, FTAG);
 		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, FTAG);
 		return (SET_ERROR(EINVAL));
 	}
 
 	/*
 	 * Setting up Direct I/O if requested.
 	 */
 	error = zfs_setup_direct(zp, uio, UIO_WRITE, &ioflag);
 	if (error) {
 		zfs_exit(zfsvfs, FTAG);
 		return (SET_ERROR(error));
 	}
 
 	/*
 	 * Pre-fault the pages to ensure slow (eg NFS) pages
 	 * don't hold up txg.
 	 */
 	ssize_t pfbytes = MIN(n, DMU_MAX_ACCESS >> 1);
 	if (zfs_uio_prefaultpages(pfbytes, uio)) {
 		zfs_exit(zfsvfs, FTAG);
 		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);
 		/*
 		 * We need to update the starting offset as well because it is
 		 * set previously in the ZPL (Linux) and VNOPS (FreeBSD)
 		 * layers.
 		 */
 		zfs_uio_setsoffset(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_uio(zp, uio)) {
 		zfs_rangelock_exit(lr);
 		zfs_exit(zfsvfs, FTAG);
 		return (SET_ERROR(EFBIG));
 	}
 
 	const rlim64_t limit = MAXOFFSET_T;
 
 	if (woff >= limit) {
 		zfs_rangelock_exit(lr);
 		zfs_exit(zfsvfs, FTAG);
 		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;
 	boolean_t commit = (ioflag & (O_SYNC | O_DSYNC)) ||
 	    (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS);
 
 	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;
 
 	/*
 	 * In the event we are increasing the file block size
 	 * (lr_length == UINT64_MAX), we will direct the write to the ARC.
 	 * Because zfs_grow_blocksize() will read from the ARC in order to
 	 * grow the dbuf, we avoid doing Direct I/O here as that would cause
 	 * data written to disk to be overwritten by data in the ARC during
 	 * the sync phase. Besides writing data twice to disk, we also
 	 * want to avoid consistency concerns between data in the the ARC and
 	 * on disk while growing the file's blocksize.
 	 *
 	 * We will only temporarily remove Direct I/O and put it back after
 	 * we have grown the blocksize. We do this in the event a request
 	 * is larger than max_blksz, so further requests to
 	 * dmu_write_uio_dbuf() will still issue the requests using Direct
 	 * IO.
 	 *
 	 * As an example:
 	 * The first block to file is being written as a 4k request with
 	 * a recorsize of 1K. The first 1K issued in the loop below will go
 	 * through the ARC; however, the following 3 1K requests will
 	 * use Direct I/O.
 	 */
 	if (uio->uio_extflg & UIO_DIRECT && lr->lr_length == UINT64_MAX) {
 		uio->uio_extflg &= ~UIO_DIRECT;
 		o_direct_defer = B_TRUE;
 	}
 
 	/*
 	 * 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;
 		}
 
 		uint64_t blksz;
 		if (lr->lr_length == UINT64_MAX && zp->z_size <= zp->z_blksz) {
 			if (zp->z_blksz > zfsvfs->z_max_blksz &&
 			    !ISP2(zp->z_blksz)) {
 				/*
 				 * File's blocksize is already larger than the
 				 * "recordsize" property.  Only let it grow to
 				 * the next power of 2.
 				 */
 				blksz = 1 << highbit64(zp->z_blksz);
 			} else {
 				blksz = zfsvfs->z_max_blksz;
 			}
 			blksz = MIN(blksz, P2ROUNDUP(end_size,
 			    SPA_MINBLOCKSIZE));
 			blksz = MAX(blksz, zp->z_blksz);
 		} else {
 			blksz = zp->z_blksz;
 		}
 
 		arc_buf_t *abuf = NULL;
 		ssize_t nbytes = n;
 		if (n >= blksz && woff >= zp->z_size &&
 		    P2PHASE(woff, blksz) == 0 &&
 		    !(uio->uio_extflg & UIO_DIRECT) &&
 		    (blksz >= SPA_OLD_MAXBLOCKSIZE || n < 4 * 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).
 			 */
 			abuf = dmu_request_arcbuf(sa_get_db(zp->z_sa_hdl),
 			    blksz);
 			ASSERT(abuf != NULL);
 			ASSERT(arc_buf_size(abuf) == blksz);
 			if ((error = zfs_uiocopy(abuf->b_data, blksz,
 			    UIO_WRITE, uio, &nbytes))) {
 				dmu_return_arcbuf(abuf);
 				break;
 			}
 			ASSERT3S(nbytes, ==, blksz);
 		} else {
 			nbytes = MIN(n, (DMU_MAX_ACCESS >> 1) -
 			    P2PHASE(woff, blksz));
 			if (pfbytes < nbytes) {
 				if (zfs_uio_prefaultpages(nbytes, uio)) {
 					error = SET_ERROR(EFAULT);
 					break;
 				}
 				pfbytes = nbytes;
 			}
 		}
 
 		/*
 		 * 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, nbytes);
 		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;
 		}
 
 		/*
 		 * NB: We must call zfs_clear_setid_bits_if_necessary before
 		 * committing the transaction!
 		 */
 
 		/*
 		 * 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) {
 			zfs_grow_blocksize(zp, blksz, tx);
 			zfs_rangelock_reduce(lr, woff, n);
 		}
 
 		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) {
 				zfs_clear_setid_bits_if_necessary(zfsvfs, zp,
 				    cr, &clear_setid_bits_txg, tx);
 				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.
 				 */
 				n -= tx_bytes - zfs_uio_resid(uio);
 				pfbytes -= tx_bytes - zfs_uio_resid(uio);
 				continue;
 			}
 #endif
 			/*
 			 * On FreeBSD, EFAULT should be propagated back to the
 			 * VFS, which will handle faulting and will retry.
 			 */
 			if (error != 0 && error != EFAULT) {
 				zfs_clear_setid_bits_if_necessary(zfsvfs, zp,
 				    cr, &clear_setid_bits_txg, tx);
 				dmu_tx_commit(tx);
 				break;
 			}
 			tx_bytes -= zfs_uio_resid(uio);
 		} else {
 			/*
 			 * 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) {
 				/*
 				 * XXX This might not be necessary if
 				 * dmu_assign_arcbuf_by_dbuf is guaranteed
 				 * to be atomic.
 				 */
 				zfs_clear_setid_bits_if_necessary(zfsvfs, zp,
 				    cr, &clear_setid_bits_txg, tx);
 				dmu_return_arcbuf(abuf);
 				dmu_tx_commit(tx);
 				break;
 			}
 			ASSERT3S(nbytes, <=, zfs_uio_resid(uio));
 			zfs_uioskip(uio, nbytes);
 			tx_bytes = nbytes;
 		}
 		/*
 		 * There is a window where a file's pages can be mmap'ed after
 		 * zfs_setup_direct() is called. This is due to the fact that
 		 * the rangelock in this function is acquired after calling
 		 * zfs_setup_direct(). This is done so that
 		 * zfs_uio_prefaultpages() does not attempt to fault in pages
 		 * on Linux for Direct I/O requests. This is not necessary as
 		 * the pages are pinned in memory and can not be faulted out.
 		 * Ideally, the rangelock would be held before calling
 		 * zfs_setup_direct() and zfs_uio_prefaultpages(); however,
 		 * this can lead to a deadlock as zfs_getpage() also acquires
 		 * the rangelock as a RL_WRITER and prefaulting the pages can
 		 * lead to zfs_getpage() being called.
 		 *
 		 * In the case of the pages being mapped after
 		 * zfs_setup_direct() is called, the call to update_pages()
 		 * will still be made to make sure there is consistency between
 		 * the ARC and the Linux page cache. This is an ufortunate
 		 * situation as the data will be read back into the ARC after
 		 * the Direct I/O write has completed, but this is the penality
 		 * for writing to a mmap'ed region of a file using Direct I/O.
 		 */
 		if (tx_bytes &&
 		    zn_has_cached_data(zp, woff, woff + tx_bytes - 1)) {
 			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;
 		}
 
 		zfs_clear_setid_bits_if_necessary(zfsvfs, zp, cr,
 		    &clear_setid_bits_txg, tx);
 
 		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 || error == EFAULT);
 		}
 		/*
 		 * 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;
 
 		error1 = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
 		if (error1 != 0)
 			/* Avoid clobbering EFAULT. */
 			error = error1;
 
 		/*
 		 * NB: During replay, the TX_SETATTR record logged by
 		 * zfs_clear_setid_bits_if_necessary must precede any of
 		 * the TX_WRITE records logged here.
 		 */
 		zfs_log_write(zilog, tx, TX_WRITE, zp, woff, tx_bytes, commit,
 		    uio->uio_extflg & UIO_DIRECT ? B_TRUE : B_FALSE, NULL,
 		    NULL);
 
 		dmu_tx_commit(tx);
 
 		/*
 		 * Direct I/O was deferred in order to grow the first block.
 		 * At this point it can be re-enabled for subsequent writes.
 		 */
 		if (o_direct_defer) {
 			ASSERT(ioflag & O_DIRECT);
 			uio->uio_extflg |= UIO_DIRECT;
 			o_direct_defer = B_FALSE;
 		}
 
 		if (error != 0)
 			break;
 		ASSERT3S(tx_bytes, ==, nbytes);
 		n -= nbytes;
 		pfbytes -= nbytes;
 	}
 
 	if (o_direct_defer) {
 		ASSERT(ioflag & O_DIRECT);
 		uio->uio_extflg |= UIO_DIRECT;
 		o_direct_defer = B_FALSE;
 	}
 
 	zfs_znode_update_vfs(zp);
 	zfs_rangelock_exit(lr);
 
 	/*
 	 * Cleanup for Direct I/O if requested.
 	 */
 	if (uio->uio_extflg & UIO_DIRECT)
 		zfs_uio_free_dio_pages(uio, UIO_WRITE);
 
 	/*
 	 * 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, FTAG);
 		return (error);
 	}
 
 	if (commit)
 		zil_commit(zilog, zp->z_id);
 
 	int64_t nwritten = start_resid - zfs_uio_resid(uio);
 	dataset_kstats_update_write_kstats(&zfsvfs->z_kstat, nwritten);
 
 	zfs_exit(zfsvfs, FTAG);
 	return (0);
 }
 
 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;
 
 	if ((error = zfs_enter_verify_zp(zfsvfs, zp, FTAG)) != 0)
 		return (error);
 	error = zfs_getacl(zp, vsecp, skipaclchk, cr);
 	zfs_exit(zfsvfs, FTAG);
 
 	return (error);
 }
 
 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;
 
 	if ((error = zfs_enter_verify_zp(zfsvfs, zp, FTAG)) != 0)
 		return (error);
 	zilog = zfsvfs->z_log;
 	error = zfs_setacl(zp, vsecp, skipaclchk, cr);
 
 	if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
 		zil_commit(zilog, 0);
 
 	zfs_exit(zfsvfs, FTAG);
 	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;
 	zgd_t *zgd;
 	int error = 0;
 	uint64_t zp_gen;
 
 	ASSERT3P(lwb, !=, 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 = 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 */
 		ASSERT3P(zio, !=, NULL);
 		/*
 		 * 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
 
 		dmu_buf_t *dbp;
 		if (error == 0)
 			error = dmu_buf_hold_noread(os, object, offset, zgd,
 			    &dbp);
 
 		if (error == 0) {
 			zgd->zgd_db = dbp;
 			dmu_buf_impl_t *db = (dmu_buf_impl_t *)dbp;
 			boolean_t direct_write = B_FALSE;
 			mutex_enter(&db->db_mtx);
 			dbuf_dirty_record_t *dr =
 			    dbuf_find_dirty_eq(db, lr->lr_common.lrc_txg);
 			if (dr != NULL && dr->dt.dl.dr_diowrite)
 				direct_write = B_TRUE;
 			mutex_exit(&db->db_mtx);
 
 			/*
 			 * All Direct I/O writes will have already completed and
 			 * the block pointer can be immediately stored in the
 			 * log record.
 			 */
 			if (direct_write) {
 				/*
 				 * A Direct I/O write always covers an entire
 				 * block.
 				 */
 				ASSERT3U(dbp->db_size, ==, zp->z_blksz);
 				lr->lr_blkptr = dr->dt.dl.dr_overridden_by;
 				zfs_get_done(zgd, 0);
 				return (0);
 			}
 
 			blkptr_t *bp = &lr->lr_blkptr;
 			zgd->zgd_bp = bp;
 
 			ASSERT3U(dbp->db_offset, ==, offset);
 			ASSERT3U(dbp->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);
 }
 
 static void
 zfs_get_done(zgd_t *zgd, int error)
 {
 	(void) 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));
 }
 
 static int
 zfs_enter_two(zfsvfs_t *zfsvfs1, zfsvfs_t *zfsvfs2, const char *tag)
 {
 	int error;
 
 	/* Swap. Not sure if the order of zfs_enter()s is important. */
 	if (zfsvfs1 > zfsvfs2) {
 		zfsvfs_t *tmpzfsvfs;
 
 		tmpzfsvfs = zfsvfs2;
 		zfsvfs2 = zfsvfs1;
 		zfsvfs1 = tmpzfsvfs;
 	}
 
 	error = zfs_enter(zfsvfs1, tag);
 	if (error != 0)
 		return (error);
 	if (zfsvfs1 != zfsvfs2) {
 		error = zfs_enter(zfsvfs2, tag);
 		if (error != 0) {
 			zfs_exit(zfsvfs1, tag);
 			return (error);
 		}
 	}
 
 	return (0);
 }
 
 static void
 zfs_exit_two(zfsvfs_t *zfsvfs1, zfsvfs_t *zfsvfs2, const char *tag)
 {
 
 	zfs_exit(zfsvfs1, tag);
 	if (zfsvfs1 != zfsvfs2)
 		zfs_exit(zfsvfs2, tag);
 }
 
 /*
  * We split each clone request in chunks that can fit into a single ZIL
  * log entry. Each ZIL log entry can fit 130816 bytes for a block cloning
  * operation (see zil_max_log_data() and zfs_log_clone_range()). This gives
  * us room for storing 1022 block pointers.
  *
  * On success, the function return the number of bytes copied in *lenp.
  * Note, it doesn't return how much bytes are left to be copied.
  * On errors which are caused by any file system limitations or
  * brt limitations `EINVAL` is returned. In the most cases a user
  * requested bad parameters, it could be possible to clone the file but
  * some parameters don't match the requirements.
  */
 int
 zfs_clone_range(znode_t *inzp, uint64_t *inoffp, znode_t *outzp,
     uint64_t *outoffp, uint64_t *lenp, cred_t *cr)
 {
 	zfsvfs_t	*inzfsvfs, *outzfsvfs;
 	objset_t	*inos, *outos;
 	zfs_locked_range_t *inlr, *outlr;
 	dmu_buf_impl_t	*db;
 	dmu_tx_t	*tx;
 	zilog_t		*zilog;
 	uint64_t	inoff, outoff, len, done;
 	uint64_t	outsize, size;
 	int		error;
 	int		count = 0;
 	sa_bulk_attr_t	bulk[3];
 	uint64_t	mtime[2], ctime[2];
 	uint64_t	uid, gid, projid;
 	blkptr_t	*bps;
 	size_t		maxblocks, nbps;
 	uint_t		inblksz;
 	uint64_t	clear_setid_bits_txg = 0;
 	uint64_t	last_synced_txg = 0;
 
 	inoff = *inoffp;
 	outoff = *outoffp;
 	len = *lenp;
 	done = 0;
 
 	inzfsvfs = ZTOZSB(inzp);
 	outzfsvfs = ZTOZSB(outzp);
 
 	/*
 	 * We need to call zfs_enter() potentially on two different datasets,
 	 * so we need a dedicated function for that.
 	 */
 	error = zfs_enter_two(inzfsvfs, outzfsvfs, FTAG);
 	if (error != 0)
 		return (error);
 
 	inos = inzfsvfs->z_os;
 	outos = outzfsvfs->z_os;
 
 	/*
 	 * Both source and destination have to belong to the same storage pool.
 	 */
 	if (dmu_objset_spa(inos) != dmu_objset_spa(outos)) {
 		zfs_exit_two(inzfsvfs, outzfsvfs, FTAG);
 		return (SET_ERROR(EXDEV));
 	}
 
 	/*
 	 * outos and inos belongs to the same storage pool.
 	 * see a few lines above, only one check.
 	 */
 	if (!spa_feature_is_enabled(dmu_objset_spa(outos),
 	    SPA_FEATURE_BLOCK_CLONING)) {
 		zfs_exit_two(inzfsvfs, outzfsvfs, FTAG);
 		return (SET_ERROR(EOPNOTSUPP));
 	}
 
 	ASSERT(!outzfsvfs->z_replay);
 
 	/*
 	 * Block cloning from an unencrypted dataset into an encrypted
 	 * dataset and vice versa is not supported.
 	 */
 	if (inos->os_encrypted != outos->os_encrypted) {
 		zfs_exit_two(inzfsvfs, outzfsvfs, FTAG);
 		return (SET_ERROR(EXDEV));
 	}
 
 	/*
 	 * Cloning across encrypted datasets is possible only if they
 	 * share the same master key.
 	 */
 	if (inos != outos && inos->os_encrypted &&
 	    !dmu_objset_crypto_key_equal(inos, outos)) {
 		zfs_exit_two(inzfsvfs, outzfsvfs, FTAG);
 		return (SET_ERROR(EXDEV));
 	}
 
 	error = zfs_verify_zp(inzp);
 	if (error == 0)
 		error = zfs_verify_zp(outzp);
 	if (error != 0) {
 		zfs_exit_two(inzfsvfs, outzfsvfs, FTAG);
 		return (error);
 	}
 
 	/*
 	 * We don't copy source file's flags that's why we don't allow to clone
 	 * files that are in quarantine.
 	 */
 	if (inzp->z_pflags & ZFS_AV_QUARANTINED) {
 		zfs_exit_two(inzfsvfs, outzfsvfs, FTAG);
 		return (SET_ERROR(EACCES));
 	}
 
 	if (inoff >= inzp->z_size) {
 		*lenp = 0;
 		zfs_exit_two(inzfsvfs, outzfsvfs, FTAG);
 		return (0);
 	}
 	if (len > inzp->z_size - inoff) {
 		len = inzp->z_size - inoff;
 	}
 	if (len == 0) {
 		*lenp = 0;
 		zfs_exit_two(inzfsvfs, outzfsvfs, FTAG);
 		return (0);
 	}
 
 	/*
 	 * Callers might not be able to detect properly that we are read-only,
 	 * so check it explicitly here.
 	 */
 	if (zfs_is_readonly(outzfsvfs)) {
 		zfs_exit_two(inzfsvfs, outzfsvfs, FTAG);
 		return (SET_ERROR(EROFS));
 	}
 
 	/*
 	 * If immutable or not appending then return EPERM.
 	 * Intentionally allow ZFS_READONLY through here.
 	 * See zfs_zaccess_common()
 	 */
 	if ((outzp->z_pflags & ZFS_IMMUTABLE) != 0) {
 		zfs_exit_two(inzfsvfs, outzfsvfs, FTAG);
 		return (SET_ERROR(EPERM));
 	}
 
 	/*
 	 * No overlapping if we are cloning within the same file.
 	 */
 	if (inzp == outzp) {
 		if (inoff < outoff + len && outoff < inoff + len) {
 			zfs_exit_two(inzfsvfs, outzfsvfs, FTAG);
 			return (SET_ERROR(EINVAL));
 		}
 	}
 
 	/* Flush any mmap()'d data to disk */
 	if (zn_has_cached_data(inzp, inoff, inoff + len - 1))
 		zn_flush_cached_data(inzp, B_TRUE);
 
 	/*
 	 * Maintain predictable lock order.
 	 */
 	if (inzp < outzp || (inzp == outzp && inoff < outoff)) {
 		inlr = zfs_rangelock_enter(&inzp->z_rangelock, inoff, len,
 		    RL_READER);
 		outlr = zfs_rangelock_enter(&outzp->z_rangelock, outoff, len,
 		    RL_WRITER);
 	} else {
 		outlr = zfs_rangelock_enter(&outzp->z_rangelock, outoff, len,
 		    RL_WRITER);
 		inlr = zfs_rangelock_enter(&inzp->z_rangelock, inoff, len,
 		    RL_READER);
 	}
 
 	inblksz = inzp->z_blksz;
 
 	/*
 	 * We cannot clone into a file with different block size if we can't
 	 * grow it (block size is already bigger, has more than one block, or
 	 * not locked for growth).  There are other possible reasons for the
 	 * grow to fail, but we cover what we can before opening transaction
 	 * and the rest detect after we try to do it.
 	 */
 	if (inblksz < outzp->z_blksz) {
 		error = SET_ERROR(EINVAL);
 		goto unlock;
 	}
 	if (inblksz != outzp->z_blksz && (outzp->z_size > outzp->z_blksz ||
 	    outlr->lr_length != UINT64_MAX)) {
 		error = SET_ERROR(EINVAL);
 		goto unlock;
 	}
 
 	/*
 	 * Block size must be power-of-2 if destination offset != 0.
 	 * There can be no multiple blocks of non-power-of-2 size.
 	 */
 	if (outoff != 0 && !ISP2(inblksz)) {
 		error = SET_ERROR(EINVAL);
 		goto unlock;
 	}
 
 	/*
 	 * Offsets and len must be at block boundries.
 	 */
 	if ((inoff % inblksz) != 0 || (outoff % inblksz) != 0) {
 		error = SET_ERROR(EINVAL);
 		goto unlock;
 	}
 	/*
 	 * Length must be multipe of blksz, except for the end of the file.
 	 */
 	if ((len % inblksz) != 0 &&
 	    (len < inzp->z_size - inoff || len < outzp->z_size - outoff)) {
 		error = SET_ERROR(EINVAL);
 		goto unlock;
 	}
 
 	/*
 	 * If we are copying only one block and it is smaller than recordsize
 	 * property, do not allow destination to grow beyond one block if it
 	 * is not there yet.  Otherwise the destination will get stuck with
 	 * that block size forever, that can be as small as 512 bytes, no
 	 * matter how big the destination grow later.
 	 */
 	if (len <= inblksz && inblksz < outzfsvfs->z_max_blksz &&
 	    outzp->z_size <= inblksz && outoff + len > inblksz) {
 		error = SET_ERROR(EINVAL);
 		goto unlock;
 	}
 
 	error = zn_rlimit_fsize(outoff + len);
 	if (error != 0) {
 		goto unlock;
 	}
 
 	if (inoff >= MAXOFFSET_T || outoff >= MAXOFFSET_T) {
 		error = SET_ERROR(EFBIG);
 		goto unlock;
 	}
 
 	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(outzfsvfs), NULL,
 	    &mtime, 16);
 	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(outzfsvfs), NULL,
 	    &ctime, 16);
 	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(outzfsvfs), NULL,
 	    &outzp->z_size, 8);
 
 	zilog = outzfsvfs->z_log;
 	maxblocks = zil_max_log_data(zilog, sizeof (lr_clone_range_t)) /
 	    sizeof (bps[0]);
 
 	uid = KUID_TO_SUID(ZTOUID(outzp));
 	gid = KGID_TO_SGID(ZTOGID(outzp));
 	projid = outzp->z_projid;
 
 	bps = vmem_alloc(sizeof (bps[0]) * maxblocks, KM_SLEEP);
 
 	/*
 	 * Clone the file in reasonable size chunks.  Each chunk is cloned
 	 * in a separate transaction; this keeps the intent log records small
 	 * and allows us to do more fine-grained space accounting.
 	 */
 	while (len > 0) {
 		size = MIN(inblksz * maxblocks, len);
 
 		if (zfs_id_overblockquota(outzfsvfs, DMU_USERUSED_OBJECT,
 		    uid) ||
 		    zfs_id_overblockquota(outzfsvfs, DMU_GROUPUSED_OBJECT,
 		    gid) ||
 		    (projid != ZFS_DEFAULT_PROJID &&
 		    zfs_id_overblockquota(outzfsvfs, DMU_PROJECTUSED_OBJECT,
 		    projid))) {
 			error = SET_ERROR(EDQUOT);
 			break;
 		}
 
 		nbps = maxblocks;
 		last_synced_txg = spa_last_synced_txg(dmu_objset_spa(inos));
 		error = dmu_read_l0_bps(inos, inzp->z_id, inoff, size, bps,
 		    &nbps);
 		if (error != 0) {
 			/*
 			 * If we are trying to clone a block that was created
 			 * in the current transaction group, the error will be
 			 * EAGAIN here.  Based on zfs_bclone_wait_dirty either
 			 * return a shortened range to the caller so it can
 			 * fallback, or wait for the next TXG and check again.
 			 */
 			if (error == EAGAIN && zfs_bclone_wait_dirty) {
 				txg_wait_synced(dmu_objset_pool(inos),
 				    last_synced_txg + 1);
 				continue;
 			}
 
 			break;
 		}
 
 		/*
 		 * Start a transaction.
 		 */
 		tx = dmu_tx_create(outos);
 		dmu_tx_hold_sa(tx, outzp->z_sa_hdl, B_FALSE);
 		db = (dmu_buf_impl_t *)sa_get_db(outzp->z_sa_hdl);
 		DB_DNODE_ENTER(db);
 		dmu_tx_hold_clone_by_dnode(tx, DB_DNODE(db), outoff, size);
 		DB_DNODE_EXIT(db);
 		zfs_sa_upgrade_txholds(tx, outzp);
 		error = dmu_tx_assign(tx, TXG_WAIT);
 		if (error != 0) {
 			dmu_tx_abort(tx);
 			break;
 		}
 
 		/*
 		 * Copy source znode's block size. This is done only if the
 		 * whole znode is locked (see zfs_rangelock_cb()) and only
 		 * on the first iteration since zfs_rangelock_reduce() will
 		 * shrink down lr_length to the appropriate size.
 		 */
 		if (outlr->lr_length == UINT64_MAX) {
 			zfs_grow_blocksize(outzp, inblksz, tx);
 
 			/*
 			 * Block growth may fail for many reasons we can not
 			 * predict here.  If it happen the cloning is doomed.
 			 */
 			if (inblksz != outzp->z_blksz) {
 				error = SET_ERROR(EINVAL);
 				dmu_tx_abort(tx);
 				break;
 			}
 
 			/*
 			 * Round range lock up to the block boundary, so we
 			 * prevent appends until we are done.
 			 */
 			zfs_rangelock_reduce(outlr, outoff,
 			    ((len - 1) / inblksz + 1) * inblksz);
 		}
 
 		error = dmu_brt_clone(outos, outzp->z_id, outoff, size, tx,
 		    bps, nbps);
 		if (error != 0) {
 			dmu_tx_commit(tx);
 			break;
 		}
 
 		if (zn_has_cached_data(outzp, outoff, outoff + size - 1)) {
 			update_pages(outzp, outoff, size, outos);
 		}
 
 		zfs_clear_setid_bits_if_necessary(outzfsvfs, outzp, cr,
 		    &clear_setid_bits_txg, tx);
 
 		zfs_tstamp_update_setup(outzp, CONTENT_MODIFIED, mtime, ctime);
 
 		/*
 		 * Update the file size (zp_size) if it has changed;
 		 * account for possible concurrent updates.
 		 */
 		while ((outsize = outzp->z_size) < outoff + size) {
 			(void) atomic_cas_64(&outzp->z_size, outsize,
 			    outoff + size);
 		}
 
 		error = sa_bulk_update(outzp->z_sa_hdl, bulk, count, tx);
 
 		zfs_log_clone_range(zilog, tx, TX_CLONE_RANGE, outzp, outoff,
 		    size, inblksz, bps, nbps);
 
 		dmu_tx_commit(tx);
 
 		if (error != 0)
 			break;
 
 		inoff += size;
 		outoff += size;
 		len -= size;
 		done += size;
 
 		if (issig()) {
 			error = SET_ERROR(EINTR);
 			break;
 		}
 	}
 
 	vmem_free(bps, sizeof (bps[0]) * maxblocks);
 	zfs_znode_update_vfs(outzp);
 
 unlock:
 	zfs_rangelock_exit(outlr);
 	zfs_rangelock_exit(inlr);
 
 	if (done > 0) {
 		/*
 		 * If we have made at least partial progress, reset the error.
 		 */
 		error = 0;
 
 		ZFS_ACCESSTIME_STAMP(inzfsvfs, inzp);
 
 		if (outos->os_sync == ZFS_SYNC_ALWAYS) {
 			zil_commit(zilog, outzp->z_id);
 		}
 
 		*inoffp += done;
 		*outoffp += done;
 		*lenp = done;
 	} else {
 		/*
 		 * If we made no progress, there must be a good reason.
 		 * EOF is handled explicitly above, before the loop.
 		 */
 		ASSERT3S(error, !=, 0);
 	}
 
 	zfs_exit_two(inzfsvfs, outzfsvfs, FTAG);
 
 	return (error);
 }
 
 /*
  * Usual pattern would be to call zfs_clone_range() from zfs_replay_clone(),
  * but we cannot do that, because when replaying we don't have source znode
  * available. This is why we need a dedicated replay function.
  */
 int
 zfs_clone_range_replay(znode_t *zp, uint64_t off, uint64_t len, uint64_t blksz,
     const blkptr_t *bps, size_t nbps)
 {
 	zfsvfs_t	*zfsvfs;
 	dmu_buf_impl_t	*db;
 	dmu_tx_t	*tx;
 	int		error;
 	int		count = 0;
 	sa_bulk_attr_t	bulk[3];
 	uint64_t	mtime[2], ctime[2];
 
 	ASSERT3U(off, <, MAXOFFSET_T);
 	ASSERT3U(len, >, 0);
 	ASSERT3U(nbps, >, 0);
 
 	zfsvfs = ZTOZSB(zp);
 
 	ASSERT(spa_feature_is_enabled(dmu_objset_spa(zfsvfs->z_os),
 	    SPA_FEATURE_BLOCK_CLONING));
 
 	if ((error = zfs_enter_verify_zp(zfsvfs, zp, FTAG)) != 0)
 		return (error);
 
 	ASSERT(zfsvfs->z_replay);
 	ASSERT(!zfs_is_readonly(zfsvfs));
 
 	if ((off % blksz) != 0) {
 		zfs_exit(zfsvfs, FTAG);
 		return (SET_ERROR(EINVAL));
 	}
 
 	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);
 
 	/*
 	 * Start a transaction.
 	 */
 	tx = dmu_tx_create(zfsvfs->z_os);
 
 	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
 	db = (dmu_buf_impl_t *)sa_get_db(zp->z_sa_hdl);
 	DB_DNODE_ENTER(db);
 	dmu_tx_hold_clone_by_dnode(tx, DB_DNODE(db), off, len);
 	DB_DNODE_EXIT(db);
 	zfs_sa_upgrade_txholds(tx, zp);
 	error = dmu_tx_assign(tx, TXG_WAIT);
 	if (error != 0) {
 		dmu_tx_abort(tx);
 		zfs_exit(zfsvfs, FTAG);
 		return (error);
 	}
 
 	if (zp->z_blksz < blksz)
 		zfs_grow_blocksize(zp, blksz, tx);
 
 	dmu_brt_clone(zfsvfs->z_os, zp->z_id, off, len, tx, bps, nbps);
 
 	zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime);
 
 	if (zp->z_size < off + len)
 		zp->z_size = off + len;
 
 	error = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
 
 	/*
 	 * zil_replaying() not only check if we are replaying ZIL, but also
 	 * updates the ZIL header to record replay progress.
 	 */
 	VERIFY(zil_replaying(zfsvfs->z_log, tx));
 
 	dmu_tx_commit(tx);
 
 	zfs_znode_update_vfs(zp);
 
 	zfs_exit(zfsvfs, FTAG);
 
 	return (error);
 }
 
 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);
 EXPORT_SYMBOL(zfs_clone_range);
 EXPORT_SYMBOL(zfs_clone_range_replay);
 
 ZFS_MODULE_PARAM(zfs_vnops, zfs_vnops_, read_chunk_size, U64, ZMOD_RW,
 	"Bytes to read per chunk");
 
 ZFS_MODULE_PARAM(zfs, zfs_, bclone_enabled, INT, ZMOD_RW,
 	"Enable block cloning");
 
 ZFS_MODULE_PARAM(zfs, zfs_, bclone_wait_dirty, INT, ZMOD_RW,
 	"Wait for dirty blocks when cloning");
 
 ZFS_MODULE_PARAM(zfs, zfs_, dio_enabled, INT, ZMOD_RW,
 	"Enable Direct I/O");
diff --git a/sys/contrib/openzfs/module/zfs/zio.c b/sys/contrib/openzfs/module/zfs/zio.c
index b26f5e80abfb..a5daf73d59ba 100644
--- a/sys/contrib/openzfs/module/zfs/zio.c
+++ b/sys/contrib/openzfs/module/zfs/zio.c
@@ -1,5686 +1,5736 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2011, 2022 by Delphix. All rights reserved.
  * Copyright (c) 2011 Nexenta Systems, Inc. All rights reserved.
  * Copyright (c) 2017, Intel Corporation.
  * Copyright (c) 2019, 2023, 2024, Klara Inc.
  * Copyright (c) 2019, Allan Jude
  * Copyright (c) 2021, Datto, Inc.
  * Copyright (c) 2021, 2024 by George Melikov. All rights reserved.
  */
 
 #include <sys/sysmacros.h>
 #include <sys/zfs_context.h>
 #include <sys/fm/fs/zfs.h>
 #include <sys/spa.h>
 #include <sys/txg.h>
 #include <sys/spa_impl.h>
 #include <sys/vdev_impl.h>
 #include <sys/vdev_trim.h>
 #include <sys/zio_impl.h>
 #include <sys/zio_compress.h>
 #include <sys/zio_checksum.h>
 #include <sys/dmu_objset.h>
 #include <sys/arc.h>
 #include <sys/brt.h>
 #include <sys/ddt.h>
 #include <sys/blkptr.h>
 #include <sys/zfeature.h>
 #include <sys/dsl_scan.h>
 #include <sys/metaslab_impl.h>
 #include <sys/time.h>
 #include <sys/trace_zfs.h>
 #include <sys/abd.h>
 #include <sys/dsl_crypt.h>
 #include <cityhash.h>
 
 /*
  * ==========================================================================
  * I/O type descriptions
  * ==========================================================================
  */
 const char *const zio_type_name[ZIO_TYPES] = {
 	/*
 	 * Note: Linux kernel thread name length is limited
 	 * so these names will differ from upstream open zfs.
 	 */
 	"z_null", "z_rd", "z_wr", "z_fr", "z_cl", "z_flush", "z_trim"
 };
 
 int zio_dva_throttle_enabled = B_TRUE;
 static int zio_deadman_log_all = B_FALSE;
 
 /*
  * ==========================================================================
  * I/O kmem caches
  * ==========================================================================
  */
 static kmem_cache_t *zio_cache;
 static kmem_cache_t *zio_link_cache;
 kmem_cache_t *zio_buf_cache[SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT];
 kmem_cache_t *zio_data_buf_cache[SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT];
 #if defined(ZFS_DEBUG) && !defined(_KERNEL)
 static uint64_t zio_buf_cache_allocs[SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT];
 static uint64_t zio_buf_cache_frees[SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT];
 #endif
 
 /* Mark IOs as "slow" if they take longer than 30 seconds */
 static uint_t zio_slow_io_ms = (30 * MILLISEC);
 
 #define	BP_SPANB(indblkshift, level) \
 	(((uint64_t)1) << ((level) * ((indblkshift) - SPA_BLKPTRSHIFT)))
 #define	COMPARE_META_LEVEL	0x80000000ul
 /*
  * The following actions directly effect the spa's sync-to-convergence logic.
  * The values below define the sync pass when we start performing the action.
  * Care should be taken when changing these values as they directly impact
  * spa_sync() performance. Tuning these values may introduce subtle performance
  * pathologies and should only be done in the context of performance analysis.
  * These tunables will eventually be removed and replaced with #defines once
  * enough analysis has been done to determine optimal values.
  *
  * The 'zfs_sync_pass_deferred_free' pass must be greater than 1 to ensure that
  * regular blocks are not deferred.
  *
  * Starting in sync pass 8 (zfs_sync_pass_dont_compress), we disable
  * compression (including of metadata).  In practice, we don't have this
  * many sync passes, so this has no effect.
  *
  * The original intent was that disabling compression would help the sync
  * passes to converge. However, in practice disabling compression increases
  * the average number of sync passes, because when we turn compression off, a
  * lot of block's size will change and thus we have to re-allocate (not
  * overwrite) them. It also increases the number of 128KB allocations (e.g.
  * for indirect blocks and spacemaps) because these will not be compressed.
  * The 128K allocations are especially detrimental to performance on highly
  * fragmented systems, which may have very few free segments of this size,
  * and may need to load new metaslabs to satisfy 128K allocations.
  */
 
 /* defer frees starting in this pass */
 uint_t zfs_sync_pass_deferred_free = 2;
 
 /* don't compress starting in this pass */
 static uint_t zfs_sync_pass_dont_compress = 8;
 
 /* rewrite new bps starting in this pass */
 static uint_t zfs_sync_pass_rewrite = 2;
 
 /*
  * An allocating zio is one that either currently has the DVA allocate
  * stage set or will have it later in its lifetime.
  */
 #define	IO_IS_ALLOCATING(zio) ((zio)->io_orig_pipeline & ZIO_STAGE_DVA_ALLOCATE)
 
 /*
  * Enable smaller cores by excluding metadata
  * allocations as well.
  */
 int zio_exclude_metadata = 0;
 static int zio_requeue_io_start_cut_in_line = 1;
 
 #ifdef ZFS_DEBUG
 static const int zio_buf_debug_limit = 16384;
 #else
 static const int zio_buf_debug_limit = 0;
 #endif
 
 static inline void __zio_execute(zio_t *zio);
 
 static void zio_taskq_dispatch(zio_t *, zio_taskq_type_t, boolean_t);
 
 void
 zio_init(void)
 {
 	size_t c;
 
 	zio_cache = kmem_cache_create("zio_cache",
 	    sizeof (zio_t), 0, NULL, NULL, NULL, NULL, NULL, 0);
 	zio_link_cache = kmem_cache_create("zio_link_cache",
 	    sizeof (zio_link_t), 0, NULL, NULL, NULL, NULL, NULL, 0);
 
 	for (c = 0; c < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT; c++) {
 		size_t size = (c + 1) << SPA_MINBLOCKSHIFT;
 		size_t align, cflags, data_cflags;
 		char name[32];
 
 		/*
 		 * Create cache for each half-power of 2 size, starting from
 		 * SPA_MINBLOCKSIZE.  It should give us memory space efficiency
 		 * of ~7/8, sufficient for transient allocations mostly using
 		 * these caches.
 		 */
 		size_t p2 = size;
 		while (!ISP2(p2))
 			p2 &= p2 - 1;
 		if (!IS_P2ALIGNED(size, p2 / 2))
 			continue;
 
 #ifndef _KERNEL
 		/*
 		 * If we are using watchpoints, put each buffer on its own page,
 		 * to eliminate the performance overhead of trapping to the
 		 * kernel when modifying a non-watched buffer that shares the
 		 * page with a watched buffer.
 		 */
 		if (arc_watch && !IS_P2ALIGNED(size, PAGESIZE))
 			continue;
 #endif
 
 		if (IS_P2ALIGNED(size, PAGESIZE))
 			align = PAGESIZE;
 		else
 			align = 1 << (highbit64(size ^ (size - 1)) - 1);
 
 		cflags = (zio_exclude_metadata || size > zio_buf_debug_limit) ?
 		    KMC_NODEBUG : 0;
 		data_cflags = KMC_NODEBUG;
 		if (abd_size_alloc_linear(size)) {
 			cflags |= KMC_RECLAIMABLE;
 			data_cflags |= KMC_RECLAIMABLE;
 		}
 		if (cflags == data_cflags) {
 			/*
 			 * Resulting kmem caches would be identical.
 			 * Save memory by creating only one.
 			 */
 			(void) snprintf(name, sizeof (name),
 			    "zio_buf_comb_%lu", (ulong_t)size);
 			zio_buf_cache[c] = kmem_cache_create(name, size, align,
 			    NULL, NULL, NULL, NULL, NULL, cflags);
 			zio_data_buf_cache[c] = zio_buf_cache[c];
 			continue;
 		}
 		(void) snprintf(name, sizeof (name), "zio_buf_%lu",
 		    (ulong_t)size);
 		zio_buf_cache[c] = kmem_cache_create(name, size, align,
 		    NULL, NULL, NULL, NULL, NULL, cflags);
 
 		(void) snprintf(name, sizeof (name), "zio_data_buf_%lu",
 		    (ulong_t)size);
 		zio_data_buf_cache[c] = kmem_cache_create(name, size, align,
 		    NULL, NULL, NULL, NULL, NULL, data_cflags);
 	}
 
 	while (--c != 0) {
 		ASSERT(zio_buf_cache[c] != NULL);
 		if (zio_buf_cache[c - 1] == NULL)
 			zio_buf_cache[c - 1] = zio_buf_cache[c];
 
 		ASSERT(zio_data_buf_cache[c] != NULL);
 		if (zio_data_buf_cache[c - 1] == NULL)
 			zio_data_buf_cache[c - 1] = zio_data_buf_cache[c];
 	}
 
 	zio_inject_init();
 
 	lz4_init();
 }
 
 void
 zio_fini(void)
 {
 	size_t n = SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT;
 
 #if defined(ZFS_DEBUG) && !defined(_KERNEL)
 	for (size_t i = 0; i < n; i++) {
 		if (zio_buf_cache_allocs[i] != zio_buf_cache_frees[i])
 			(void) printf("zio_fini: [%d] %llu != %llu\n",
 			    (int)((i + 1) << SPA_MINBLOCKSHIFT),
 			    (long long unsigned)zio_buf_cache_allocs[i],
 			    (long long unsigned)zio_buf_cache_frees[i]);
 	}
 #endif
 
 	/*
 	 * The same kmem cache can show up multiple times in both zio_buf_cache
 	 * and zio_data_buf_cache. Do a wasteful but trivially correct scan to
 	 * sort it out.
 	 */
 	for (size_t i = 0; i < n; i++) {
 		kmem_cache_t *cache = zio_buf_cache[i];
 		if (cache == NULL)
 			continue;
 		for (size_t j = i; j < n; j++) {
 			if (cache == zio_buf_cache[j])
 				zio_buf_cache[j] = NULL;
 			if (cache == zio_data_buf_cache[j])
 				zio_data_buf_cache[j] = NULL;
 		}
 		kmem_cache_destroy(cache);
 	}
 
 	for (size_t i = 0; i < n; i++) {
 		kmem_cache_t *cache = zio_data_buf_cache[i];
 		if (cache == NULL)
 			continue;
 		for (size_t j = i; j < n; j++) {
 			if (cache == zio_data_buf_cache[j])
 				zio_data_buf_cache[j] = NULL;
 		}
 		kmem_cache_destroy(cache);
 	}
 
 	for (size_t i = 0; i < n; i++) {
 		VERIFY3P(zio_buf_cache[i], ==, NULL);
 		VERIFY3P(zio_data_buf_cache[i], ==, NULL);
 	}
 
 	kmem_cache_destroy(zio_link_cache);
 	kmem_cache_destroy(zio_cache);
 
 	zio_inject_fini();
 
 	lz4_fini();
 }
 
 /*
  * ==========================================================================
  * Allocate and free I/O buffers
  * ==========================================================================
  */
 
 #if defined(ZFS_DEBUG) && defined(_KERNEL)
 #define	ZFS_ZIO_BUF_CANARY	1
 #endif
 
 #ifdef ZFS_ZIO_BUF_CANARY
 static const ulong_t zio_buf_canary = (ulong_t)0xdeadc0dedead210b;
 
 /*
  * Use empty space after the buffer to detect overflows.
  *
  * Since zio_init() creates kmem caches only for certain set of buffer sizes,
  * allocations of different sizes may have some unused space after the data.
  * Filling part of that space with a known pattern on allocation and checking
  * it on free should allow us to detect some buffer overflows.
  */
 static void
 zio_buf_put_canary(ulong_t *p, size_t size, kmem_cache_t **cache, size_t c)
 {
 	size_t off = P2ROUNDUP(size, sizeof (ulong_t));
 	ulong_t *canary = p + off / sizeof (ulong_t);
 	size_t asize = (c + 1) << SPA_MINBLOCKSHIFT;
 	if (c + 1 < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT &&
 	    cache[c] == cache[c + 1])
 		asize = (c + 2) << SPA_MINBLOCKSHIFT;
 	for (; off < asize; canary++, off += sizeof (ulong_t))
 		*canary = zio_buf_canary;
 }
 
 static void
 zio_buf_check_canary(ulong_t *p, size_t size, kmem_cache_t **cache, size_t c)
 {
 	size_t off = P2ROUNDUP(size, sizeof (ulong_t));
 	ulong_t *canary = p + off / sizeof (ulong_t);
 	size_t asize = (c + 1) << SPA_MINBLOCKSHIFT;
 	if (c + 1 < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT &&
 	    cache[c] == cache[c + 1])
 		asize = (c + 2) << SPA_MINBLOCKSHIFT;
 	for (; off < asize; canary++, off += sizeof (ulong_t)) {
 		if (unlikely(*canary != zio_buf_canary)) {
 			PANIC("ZIO buffer overflow %p (%zu) + %zu %#lx != %#lx",
 			    p, size, (canary - p) * sizeof (ulong_t),
 			    *canary, zio_buf_canary);
 		}
 	}
 }
 #endif
 
 /*
  * Use zio_buf_alloc to allocate ZFS metadata.  This data will appear in a
  * crashdump if the kernel panics, so use it judiciously.  Obviously, it's
  * useful to inspect ZFS metadata, but if possible, we should avoid keeping
  * excess / transient data in-core during a crashdump.
  */
 void *
 zio_buf_alloc(size_t size)
 {
 	size_t c = (size - 1) >> SPA_MINBLOCKSHIFT;
 
 	VERIFY3U(c, <, SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT);
 #if defined(ZFS_DEBUG) && !defined(_KERNEL)
 	atomic_add_64(&zio_buf_cache_allocs[c], 1);
 #endif
 
 	void *p = kmem_cache_alloc(zio_buf_cache[c], KM_PUSHPAGE);
 #ifdef ZFS_ZIO_BUF_CANARY
 	zio_buf_put_canary(p, size, zio_buf_cache, c);
 #endif
 	return (p);
 }
 
 /*
  * Use zio_data_buf_alloc to allocate data.  The data will not appear in a
  * crashdump if the kernel panics.  This exists so that we will limit the amount
  * of ZFS data that shows up in a kernel crashdump.  (Thus reducing the amount
  * of kernel heap dumped to disk when the kernel panics)
  */
 void *
 zio_data_buf_alloc(size_t size)
 {
 	size_t c = (size - 1) >> SPA_MINBLOCKSHIFT;
 
 	VERIFY3U(c, <, SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT);
 
 	void *p = kmem_cache_alloc(zio_data_buf_cache[c], KM_PUSHPAGE);
 #ifdef ZFS_ZIO_BUF_CANARY
 	zio_buf_put_canary(p, size, zio_data_buf_cache, c);
 #endif
 	return (p);
 }
 
 void
 zio_buf_free(void *buf, size_t size)
 {
 	size_t c = (size - 1) >> SPA_MINBLOCKSHIFT;
 
 	VERIFY3U(c, <, SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT);
 #if defined(ZFS_DEBUG) && !defined(_KERNEL)
 	atomic_add_64(&zio_buf_cache_frees[c], 1);
 #endif
 
 #ifdef ZFS_ZIO_BUF_CANARY
 	zio_buf_check_canary(buf, size, zio_buf_cache, c);
 #endif
 	kmem_cache_free(zio_buf_cache[c], buf);
 }
 
 void
 zio_data_buf_free(void *buf, size_t size)
 {
 	size_t c = (size - 1) >> SPA_MINBLOCKSHIFT;
 
 	VERIFY3U(c, <, SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT);
 
 #ifdef ZFS_ZIO_BUF_CANARY
 	zio_buf_check_canary(buf, size, zio_data_buf_cache, c);
 #endif
 	kmem_cache_free(zio_data_buf_cache[c], buf);
 }
 
 static void
 zio_abd_free(void *abd, size_t size)
 {
 	(void) size;
 	abd_free((abd_t *)abd);
 }
 
 /*
  * ==========================================================================
  * Push and pop I/O transform buffers
  * ==========================================================================
  */
 void
 zio_push_transform(zio_t *zio, abd_t *data, uint64_t size, uint64_t bufsize,
     zio_transform_func_t *transform)
 {
 	zio_transform_t *zt = kmem_alloc(sizeof (zio_transform_t), KM_SLEEP);
 
 	zt->zt_orig_abd = zio->io_abd;
 	zt->zt_orig_size = zio->io_size;
 	zt->zt_bufsize = bufsize;
 	zt->zt_transform = transform;
 
 	zt->zt_next = zio->io_transform_stack;
 	zio->io_transform_stack = zt;
 
 	zio->io_abd = data;
 	zio->io_size = size;
 }
 
 void
 zio_pop_transforms(zio_t *zio)
 {
 	zio_transform_t *zt;
 
 	while ((zt = zio->io_transform_stack) != NULL) {
 		if (zt->zt_transform != NULL)
 			zt->zt_transform(zio,
 			    zt->zt_orig_abd, zt->zt_orig_size);
 
 		if (zt->zt_bufsize != 0)
 			abd_free(zio->io_abd);
 
 		zio->io_abd = zt->zt_orig_abd;
 		zio->io_size = zt->zt_orig_size;
 		zio->io_transform_stack = zt->zt_next;
 
 		kmem_free(zt, sizeof (zio_transform_t));
 	}
 }
 
 /*
  * ==========================================================================
  * I/O transform callbacks for subblocks, decompression, and decryption
  * ==========================================================================
  */
 static void
 zio_subblock(zio_t *zio, abd_t *data, uint64_t size)
 {
 	ASSERT(zio->io_size > size);
 
 	if (zio->io_type == ZIO_TYPE_READ)
 		abd_copy(data, zio->io_abd, size);
 }
 
 static void
 zio_decompress(zio_t *zio, abd_t *data, uint64_t size)
 {
 	if (zio->io_error == 0) {
 		int ret = zio_decompress_data(BP_GET_COMPRESS(zio->io_bp),
 		    zio->io_abd, data, zio->io_size, size,
 		    &zio->io_prop.zp_complevel);
 
 		if (zio_injection_enabled && ret == 0)
 			ret = zio_handle_fault_injection(zio, EINVAL);
 
 		if (ret != 0)
 			zio->io_error = SET_ERROR(EIO);
 	}
 }
 
 static void
 zio_decrypt(zio_t *zio, abd_t *data, uint64_t size)
 {
 	int ret;
 	void *tmp;
 	blkptr_t *bp = zio->io_bp;
 	spa_t *spa = zio->io_spa;
 	uint64_t dsobj = zio->io_bookmark.zb_objset;
 	uint64_t lsize = BP_GET_LSIZE(bp);
 	dmu_object_type_t ot = BP_GET_TYPE(bp);
 	uint8_t salt[ZIO_DATA_SALT_LEN];
 	uint8_t iv[ZIO_DATA_IV_LEN];
 	uint8_t mac[ZIO_DATA_MAC_LEN];
 	boolean_t no_crypt = B_FALSE;
 
 	ASSERT(BP_USES_CRYPT(bp));
 	ASSERT3U(size, !=, 0);
 
 	if (zio->io_error != 0)
 		return;
 
 	/*
 	 * Verify the cksum of MACs stored in an indirect bp. It will always
 	 * be possible to verify this since it does not require an encryption
 	 * key.
 	 */
 	if (BP_HAS_INDIRECT_MAC_CKSUM(bp)) {
 		zio_crypt_decode_mac_bp(bp, mac);
 
 		if (BP_GET_COMPRESS(bp) != ZIO_COMPRESS_OFF) {
 			/*
 			 * We haven't decompressed the data yet, but
 			 * zio_crypt_do_indirect_mac_checksum() requires
 			 * decompressed data to be able to parse out the MACs
 			 * from the indirect block. We decompress it now and
 			 * throw away the result after we are finished.
 			 */
 			abd_t *abd = abd_alloc_linear(lsize, B_TRUE);
 			ret = zio_decompress_data(BP_GET_COMPRESS(bp),
 			    zio->io_abd, abd, zio->io_size, lsize,
 			    &zio->io_prop.zp_complevel);
 			if (ret != 0) {
 				abd_free(abd);
 				ret = SET_ERROR(EIO);
 				goto error;
 			}
 			ret = zio_crypt_do_indirect_mac_checksum_abd(B_FALSE,
 			    abd, lsize, BP_SHOULD_BYTESWAP(bp), mac);
 			abd_free(abd);
 		} else {
 			ret = zio_crypt_do_indirect_mac_checksum_abd(B_FALSE,
 			    zio->io_abd, size, BP_SHOULD_BYTESWAP(bp), mac);
 		}
 		abd_copy(data, zio->io_abd, size);
 
 		if (zio_injection_enabled && ot != DMU_OT_DNODE && ret == 0) {
 			ret = zio_handle_decrypt_injection(spa,
 			    &zio->io_bookmark, ot, ECKSUM);
 		}
 		if (ret != 0)
 			goto error;
 
 		return;
 	}
 
 	/*
 	 * If this is an authenticated block, just check the MAC. It would be
 	 * nice to separate this out into its own flag, but when this was done,
 	 * we had run out of bits in what is now zio_flag_t. Future cleanup
 	 * could make this a flag bit.
 	 */
 	if (BP_IS_AUTHENTICATED(bp)) {
 		if (ot == DMU_OT_OBJSET) {
 			ret = spa_do_crypt_objset_mac_abd(B_FALSE, spa,
 			    dsobj, zio->io_abd, size, BP_SHOULD_BYTESWAP(bp));
 		} else {
 			zio_crypt_decode_mac_bp(bp, mac);
 			ret = spa_do_crypt_mac_abd(B_FALSE, spa, dsobj,
 			    zio->io_abd, size, mac);
 			if (zio_injection_enabled && ret == 0) {
 				ret = zio_handle_decrypt_injection(spa,
 				    &zio->io_bookmark, ot, ECKSUM);
 			}
 		}
 		abd_copy(data, zio->io_abd, size);
 
 		if (ret != 0)
 			goto error;
 
 		return;
 	}
 
 	zio_crypt_decode_params_bp(bp, salt, iv);
 
 	if (ot == DMU_OT_INTENT_LOG) {
 		tmp = abd_borrow_buf_copy(zio->io_abd, sizeof (zil_chain_t));
 		zio_crypt_decode_mac_zil(tmp, mac);
 		abd_return_buf(zio->io_abd, tmp, sizeof (zil_chain_t));
 	} else {
 		zio_crypt_decode_mac_bp(bp, mac);
 	}
 
 	ret = spa_do_crypt_abd(B_FALSE, spa, &zio->io_bookmark, BP_GET_TYPE(bp),
 	    BP_GET_DEDUP(bp), BP_SHOULD_BYTESWAP(bp), salt, iv, mac, size, data,
 	    zio->io_abd, &no_crypt);
 	if (no_crypt)
 		abd_copy(data, zio->io_abd, size);
 
 	if (ret != 0)
 		goto error;
 
 	return;
 
 error:
 	/* assert that the key was found unless this was speculative */
 	ASSERT(ret != EACCES || (zio->io_flags & ZIO_FLAG_SPECULATIVE));
 
 	/*
 	 * If there was a decryption / authentication error return EIO as
 	 * the io_error. If this was not a speculative zio, create an ereport.
 	 */
 	if (ret == ECKSUM) {
 		zio->io_error = SET_ERROR(EIO);
 		if ((zio->io_flags & ZIO_FLAG_SPECULATIVE) == 0) {
 			spa_log_error(spa, &zio->io_bookmark,
 			    BP_GET_LOGICAL_BIRTH(zio->io_bp));
 			(void) zfs_ereport_post(FM_EREPORT_ZFS_AUTHENTICATION,
 			    spa, NULL, &zio->io_bookmark, zio, 0);
 		}
 	} else {
 		zio->io_error = ret;
 	}
 }
 
 /*
  * ==========================================================================
  * I/O parent/child relationships and pipeline interlocks
  * ==========================================================================
  */
 zio_t *
 zio_walk_parents(zio_t *cio, zio_link_t **zl)
 {
 	list_t *pl = &cio->io_parent_list;
 
 	*zl = (*zl == NULL) ? list_head(pl) : list_next(pl, *zl);
 	if (*zl == NULL)
 		return (NULL);
 
 	ASSERT((*zl)->zl_child == cio);
 	return ((*zl)->zl_parent);
 }
 
 zio_t *
 zio_walk_children(zio_t *pio, zio_link_t **zl)
 {
 	list_t *cl = &pio->io_child_list;
 
 	ASSERT(MUTEX_HELD(&pio->io_lock));
 
 	*zl = (*zl == NULL) ? list_head(cl) : list_next(cl, *zl);
 	if (*zl == NULL)
 		return (NULL);
 
 	ASSERT((*zl)->zl_parent == pio);
 	return ((*zl)->zl_child);
 }
 
 zio_t *
 zio_unique_parent(zio_t *cio)
 {
 	zio_link_t *zl = NULL;
 	zio_t *pio = zio_walk_parents(cio, &zl);
 
 	VERIFY3P(zio_walk_parents(cio, &zl), ==, NULL);
 	return (pio);
 }
 
 void
 zio_add_child(zio_t *pio, zio_t *cio)
 {
 	/*
 	 * Logical I/Os can have logical, gang, or vdev children.
 	 * Gang I/Os can have gang or vdev children.
 	 * Vdev I/Os can only have vdev children.
 	 * The following ASSERT captures all of these constraints.
 	 */
 	ASSERT3S(cio->io_child_type, <=, pio->io_child_type);
 
 	/* Parent should not have READY stage if child doesn't have it. */
 	IMPLY((cio->io_pipeline & ZIO_STAGE_READY) == 0 &&
 	    (cio->io_child_type != ZIO_CHILD_VDEV),
 	    (pio->io_pipeline & ZIO_STAGE_READY) == 0);
 
 	zio_link_t *zl = kmem_cache_alloc(zio_link_cache, KM_SLEEP);
 	zl->zl_parent = pio;
 	zl->zl_child = cio;
 
 	mutex_enter(&pio->io_lock);
 	mutex_enter(&cio->io_lock);
 
 	ASSERT(pio->io_state[ZIO_WAIT_DONE] == 0);
 
 	uint64_t *countp = pio->io_children[cio->io_child_type];
 	for (int w = 0; w < ZIO_WAIT_TYPES; w++)
 		countp[w] += !cio->io_state[w];
 
 	list_insert_head(&pio->io_child_list, zl);
 	list_insert_head(&cio->io_parent_list, zl);
 
 	mutex_exit(&cio->io_lock);
 	mutex_exit(&pio->io_lock);
 }
 
 void
 zio_add_child_first(zio_t *pio, zio_t *cio)
 {
 	/*
 	 * Logical I/Os can have logical, gang, or vdev children.
 	 * Gang I/Os can have gang or vdev children.
 	 * Vdev I/Os can only have vdev children.
 	 * The following ASSERT captures all of these constraints.
 	 */
 	ASSERT3S(cio->io_child_type, <=, pio->io_child_type);
 
 	/* Parent should not have READY stage if child doesn't have it. */
 	IMPLY((cio->io_pipeline & ZIO_STAGE_READY) == 0 &&
 	    (cio->io_child_type != ZIO_CHILD_VDEV),
 	    (pio->io_pipeline & ZIO_STAGE_READY) == 0);
 
 	zio_link_t *zl = kmem_cache_alloc(zio_link_cache, KM_SLEEP);
 	zl->zl_parent = pio;
 	zl->zl_child = cio;
 
 	ASSERT(list_is_empty(&cio->io_parent_list));
 	list_insert_head(&cio->io_parent_list, zl);
 
 	mutex_enter(&pio->io_lock);
 
 	ASSERT(pio->io_state[ZIO_WAIT_DONE] == 0);
 
 	uint64_t *countp = pio->io_children[cio->io_child_type];
 	for (int w = 0; w < ZIO_WAIT_TYPES; w++)
 		countp[w] += !cio->io_state[w];
 
 	list_insert_head(&pio->io_child_list, zl);
 
 	mutex_exit(&pio->io_lock);
 }
 
 static void
 zio_remove_child(zio_t *pio, zio_t *cio, zio_link_t *zl)
 {
 	ASSERT(zl->zl_parent == pio);
 	ASSERT(zl->zl_child == cio);
 
 	mutex_enter(&pio->io_lock);
 	mutex_enter(&cio->io_lock);
 
 	list_remove(&pio->io_child_list, zl);
 	list_remove(&cio->io_parent_list, zl);
 
 	mutex_exit(&cio->io_lock);
 	mutex_exit(&pio->io_lock);
 	kmem_cache_free(zio_link_cache, zl);
 }
 
 static boolean_t
 zio_wait_for_children(zio_t *zio, uint8_t childbits, enum zio_wait_type wait)
 {
 	boolean_t waiting = B_FALSE;
 
 	mutex_enter(&zio->io_lock);
 	ASSERT(zio->io_stall == NULL);
 	for (int c = 0; c < ZIO_CHILD_TYPES; c++) {
 		if (!(ZIO_CHILD_BIT_IS_SET(childbits, c)))
 			continue;
 
 		uint64_t *countp = &zio->io_children[c][wait];
 		if (*countp != 0) {
 			zio->io_stage >>= 1;
 			ASSERT3U(zio->io_stage, !=, ZIO_STAGE_OPEN);
 			zio->io_stall = countp;
 			waiting = B_TRUE;
 			break;
 		}
 	}
 	mutex_exit(&zio->io_lock);
 	return (waiting);
 }
 
 __attribute__((always_inline))
 static inline void
 zio_notify_parent(zio_t *pio, zio_t *zio, enum zio_wait_type wait,
     zio_t **next_to_executep)
 {
 	uint64_t *countp = &pio->io_children[zio->io_child_type][wait];
 	int *errorp = &pio->io_child_error[zio->io_child_type];
 
 	mutex_enter(&pio->io_lock);
 	if (zio->io_error && !(zio->io_flags & ZIO_FLAG_DONT_PROPAGATE))
 		*errorp = zio_worst_error(*errorp, zio->io_error);
 	pio->io_reexecute |= zio->io_reexecute;
 	ASSERT3U(*countp, >, 0);
 
-	if (zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR) {
-		ASSERT3U(*errorp, ==, EIO);
-		ASSERT3U(pio->io_child_type, ==, ZIO_CHILD_LOGICAL);
+	/*
+	 * Propogate the Direct I/O checksum verify failure to the parent.
+	 */
+	if (zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR)
 		pio->io_flags |= ZIO_FLAG_DIO_CHKSUM_ERR;
-	}
 
 	(*countp)--;
 
 	if (*countp == 0 && pio->io_stall == countp) {
 		zio_taskq_type_t type =
 		    pio->io_stage < ZIO_STAGE_VDEV_IO_START ? ZIO_TASKQ_ISSUE :
 		    ZIO_TASKQ_INTERRUPT;
 		pio->io_stall = NULL;
 		mutex_exit(&pio->io_lock);
 
 		/*
 		 * If we can tell the caller to execute this parent next, do
 		 * so. We do this if the parent's zio type matches the child's
 		 * type, or if it's a zio_null() with no done callback, and so
 		 * has no actual work to do. Otherwise dispatch the parent zio
 		 * in its own taskq.
 		 *
 		 * Having the caller execute the parent when possible reduces
 		 * locking on the zio taskq's, reduces context switch
 		 * overhead, and has no recursion penalty.  Note that one
 		 * read from disk typically causes at least 3 zio's: a
 		 * zio_null(), the logical zio_read(), and then a physical
 		 * zio.  When the physical ZIO completes, we are able to call
 		 * zio_done() on all 3 of these zio's from one invocation of
 		 * zio_execute() by returning the parent back to
 		 * zio_execute().  Since the parent isn't executed until this
 		 * thread returns back to zio_execute(), the caller should do
 		 * so promptly.
 		 *
 		 * In other cases, dispatching the parent prevents
 		 * overflowing the stack when we have deeply nested
 		 * parent-child relationships, as we do with the "mega zio"
 		 * of writes for spa_sync(), and the chain of ZIL blocks.
 		 */
 		if (next_to_executep != NULL && *next_to_executep == NULL &&
 		    (pio->io_type == zio->io_type ||
 		    (pio->io_type == ZIO_TYPE_NULL && !pio->io_done))) {
 			*next_to_executep = pio;
 		} else {
 			zio_taskq_dispatch(pio, type, B_FALSE);
 		}
 	} else {
 		mutex_exit(&pio->io_lock);
 	}
 }
 
 static void
 zio_inherit_child_errors(zio_t *zio, enum zio_child c)
 {
 	if (zio->io_child_error[c] != 0 && zio->io_error == 0)
 		zio->io_error = zio->io_child_error[c];
 }
 
 int
 zio_bookmark_compare(const void *x1, const void *x2)
 {
 	const zio_t *z1 = x1;
 	const zio_t *z2 = x2;
 
 	if (z1->io_bookmark.zb_objset < z2->io_bookmark.zb_objset)
 		return (-1);
 	if (z1->io_bookmark.zb_objset > z2->io_bookmark.zb_objset)
 		return (1);
 
 	if (z1->io_bookmark.zb_object < z2->io_bookmark.zb_object)
 		return (-1);
 	if (z1->io_bookmark.zb_object > z2->io_bookmark.zb_object)
 		return (1);
 
 	if (z1->io_bookmark.zb_level < z2->io_bookmark.zb_level)
 		return (-1);
 	if (z1->io_bookmark.zb_level > z2->io_bookmark.zb_level)
 		return (1);
 
 	if (z1->io_bookmark.zb_blkid < z2->io_bookmark.zb_blkid)
 		return (-1);
 	if (z1->io_bookmark.zb_blkid > z2->io_bookmark.zb_blkid)
 		return (1);
 
 	if (z1 < z2)
 		return (-1);
 	if (z1 > z2)
 		return (1);
 
 	return (0);
 }
 
 /*
  * ==========================================================================
  * Create the various types of I/O (read, write, free, etc)
  * ==========================================================================
  */
 static zio_t *
 zio_create(zio_t *pio, spa_t *spa, uint64_t txg, const blkptr_t *bp,
     abd_t *data, uint64_t lsize, uint64_t psize, zio_done_func_t *done,
     void *private, zio_type_t type, zio_priority_t priority,
     zio_flag_t flags, vdev_t *vd, uint64_t offset,
     const zbookmark_phys_t *zb, enum zio_stage stage,
     enum zio_stage pipeline)
 {
 	zio_t *zio;
 
 	IMPLY(type != ZIO_TYPE_TRIM, psize <= SPA_MAXBLOCKSIZE);
 	ASSERT(P2PHASE(psize, SPA_MINBLOCKSIZE) == 0);
 	ASSERT(P2PHASE(offset, SPA_MINBLOCKSIZE) == 0);
 
 	ASSERT(!vd || spa_config_held(spa, SCL_STATE_ALL, RW_READER));
 	ASSERT(!bp || !(flags & ZIO_FLAG_CONFIG_WRITER));
 	ASSERT(vd || stage == ZIO_STAGE_OPEN);
 
 	IMPLY(lsize != psize, (flags & ZIO_FLAG_RAW_COMPRESS) != 0);
 
 	zio = kmem_cache_alloc(zio_cache, KM_SLEEP);
 	memset(zio, 0, sizeof (zio_t));
 
 	mutex_init(&zio->io_lock, NULL, MUTEX_NOLOCKDEP, NULL);
 	cv_init(&zio->io_cv, NULL, CV_DEFAULT, NULL);
 
 	list_create(&zio->io_parent_list, sizeof (zio_link_t),
 	    offsetof(zio_link_t, zl_parent_node));
 	list_create(&zio->io_child_list, sizeof (zio_link_t),
 	    offsetof(zio_link_t, zl_child_node));
 	metaslab_trace_init(&zio->io_alloc_list);
 
 	if (vd != NULL)
 		zio->io_child_type = ZIO_CHILD_VDEV;
 	else if (flags & ZIO_FLAG_GANG_CHILD)
 		zio->io_child_type = ZIO_CHILD_GANG;
 	else if (flags & ZIO_FLAG_DDT_CHILD)
 		zio->io_child_type = ZIO_CHILD_DDT;
 	else
 		zio->io_child_type = ZIO_CHILD_LOGICAL;
 
 	if (bp != NULL) {
 		if (type != ZIO_TYPE_WRITE ||
 		    zio->io_child_type == ZIO_CHILD_DDT) {
 			zio->io_bp_copy = *bp;
 			zio->io_bp = &zio->io_bp_copy;	/* so caller can free */
 		} else {
 			zio->io_bp = (blkptr_t *)bp;
 		}
 		zio->io_bp_orig = *bp;
 		if (zio->io_child_type == ZIO_CHILD_LOGICAL)
 			zio->io_logical = zio;
 		if (zio->io_child_type > ZIO_CHILD_GANG && BP_IS_GANG(bp))
 			pipeline |= ZIO_GANG_STAGES;
 	}
 
 	zio->io_spa = spa;
 	zio->io_txg = txg;
 	zio->io_done = done;
 	zio->io_private = private;
 	zio->io_type = type;
 	zio->io_priority = priority;
 	zio->io_vd = vd;
 	zio->io_offset = offset;
 	zio->io_orig_abd = zio->io_abd = data;
 	zio->io_orig_size = zio->io_size = psize;
 	zio->io_lsize = lsize;
 	zio->io_orig_flags = zio->io_flags = flags;
 	zio->io_orig_stage = zio->io_stage = stage;
 	zio->io_orig_pipeline = zio->io_pipeline = pipeline;
 	zio->io_pipeline_trace = ZIO_STAGE_OPEN;
 	zio->io_allocator = ZIO_ALLOCATOR_NONE;
 
 	zio->io_state[ZIO_WAIT_READY] = (stage >= ZIO_STAGE_READY) ||
 	    (pipeline & ZIO_STAGE_READY) == 0;
 	zio->io_state[ZIO_WAIT_DONE] = (stage >= ZIO_STAGE_DONE);
 
 	if (zb != NULL)
 		zio->io_bookmark = *zb;
 
 	if (pio != NULL) {
 		zio->io_metaslab_class = pio->io_metaslab_class;
 		if (zio->io_logical == NULL)
 			zio->io_logical = pio->io_logical;
 		if (zio->io_child_type == ZIO_CHILD_GANG)
 			zio->io_gang_leader = pio->io_gang_leader;
 		zio_add_child_first(pio, zio);
 	}
 
 	taskq_init_ent(&zio->io_tqent);
 
 	return (zio);
 }
 
 void
 zio_destroy(zio_t *zio)
 {
 	metaslab_trace_fini(&zio->io_alloc_list);
 	list_destroy(&zio->io_parent_list);
 	list_destroy(&zio->io_child_list);
 	mutex_destroy(&zio->io_lock);
 	cv_destroy(&zio->io_cv);
 	kmem_cache_free(zio_cache, zio);
 }
 
 /*
  * ZIO intended to be between others.  Provides synchronization at READY
  * and DONE pipeline stages and calls the respective callbacks.
  */
 zio_t *
 zio_null(zio_t *pio, spa_t *spa, vdev_t *vd, zio_done_func_t *done,
     void *private, zio_flag_t flags)
 {
 	zio_t *zio;
 
 	zio = zio_create(pio, spa, 0, NULL, NULL, 0, 0, done, private,
 	    ZIO_TYPE_NULL, ZIO_PRIORITY_NOW, flags, vd, 0, NULL,
 	    ZIO_STAGE_OPEN, ZIO_INTERLOCK_PIPELINE);
 
 	return (zio);
 }
 
 /*
  * ZIO intended to be a root of a tree.  Unlike null ZIO does not have a
  * READY pipeline stage (is ready on creation), so it should not be used
  * as child of any ZIO that may need waiting for grandchildren READY stage
  * (any other ZIO type).
  */
 zio_t *
 zio_root(spa_t *spa, zio_done_func_t *done, void *private, zio_flag_t flags)
 {
 	zio_t *zio;
 
 	zio = zio_create(NULL, spa, 0, NULL, NULL, 0, 0, done, private,
 	    ZIO_TYPE_NULL, ZIO_PRIORITY_NOW, flags, NULL, 0, NULL,
 	    ZIO_STAGE_OPEN, ZIO_ROOT_PIPELINE);
 
 	return (zio);
 }
 
 static int
 zfs_blkptr_verify_log(spa_t *spa, const blkptr_t *bp,
     enum blk_verify_flag blk_verify, const char *fmt, ...)
 {
 	va_list adx;
 	char buf[256];
 
 	va_start(adx, fmt);
 	(void) vsnprintf(buf, sizeof (buf), fmt, adx);
 	va_end(adx);
 
 	zfs_dbgmsg("bad blkptr at %px: "
 	    "DVA[0]=%#llx/%#llx "
 	    "DVA[1]=%#llx/%#llx "
 	    "DVA[2]=%#llx/%#llx "
 	    "prop=%#llx "
 	    "pad=%#llx,%#llx "
 	    "phys_birth=%#llx "
 	    "birth=%#llx "
 	    "fill=%#llx "
 	    "cksum=%#llx/%#llx/%#llx/%#llx",
 	    bp,
 	    (long long)bp->blk_dva[0].dva_word[0],
 	    (long long)bp->blk_dva[0].dva_word[1],
 	    (long long)bp->blk_dva[1].dva_word[0],
 	    (long long)bp->blk_dva[1].dva_word[1],
 	    (long long)bp->blk_dva[2].dva_word[0],
 	    (long long)bp->blk_dva[2].dva_word[1],
 	    (long long)bp->blk_prop,
 	    (long long)bp->blk_pad[0],
 	    (long long)bp->blk_pad[1],
 	    (long long)BP_GET_PHYSICAL_BIRTH(bp),
 	    (long long)BP_GET_LOGICAL_BIRTH(bp),
 	    (long long)bp->blk_fill,
 	    (long long)bp->blk_cksum.zc_word[0],
 	    (long long)bp->blk_cksum.zc_word[1],
 	    (long long)bp->blk_cksum.zc_word[2],
 	    (long long)bp->blk_cksum.zc_word[3]);
 	switch (blk_verify) {
 	case BLK_VERIFY_HALT:
 		zfs_panic_recover("%s: %s", spa_name(spa), buf);
 		break;
 	case BLK_VERIFY_LOG:
 		zfs_dbgmsg("%s: %s", spa_name(spa), buf);
 		break;
 	case BLK_VERIFY_ONLY:
 		break;
 	}
 
 	return (1);
 }
 
 /*
  * Verify the block pointer fields contain reasonable values.  This means
  * it only contains known object types, checksum/compression identifiers,
  * block sizes within the maximum allowed limits, valid DVAs, etc.
  *
  * If everything checks out B_TRUE is returned.  The zfs_blkptr_verify
  * argument controls the behavior when an invalid field is detected.
  *
  * Values for blk_verify_flag:
  *   BLK_VERIFY_ONLY: evaluate the block
  *   BLK_VERIFY_LOG: evaluate the block and log problems
  *   BLK_VERIFY_HALT: call zfs_panic_recover on error
  *
  * Values for blk_config_flag:
  *   BLK_CONFIG_HELD: caller holds SCL_VDEV for writer
  *   BLK_CONFIG_NEEDED: caller holds no config lock, SCL_VDEV will be
  *   obtained for reader
  *   BLK_CONFIG_SKIP: skip checks which require SCL_VDEV, for better
  *   performance
  */
 boolean_t
 zfs_blkptr_verify(spa_t *spa, const blkptr_t *bp,
     enum blk_config_flag blk_config, enum blk_verify_flag blk_verify)
 {
 	int errors = 0;
 
 	if (unlikely(!DMU_OT_IS_VALID(BP_GET_TYPE(bp)))) {
 		errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
 		    "blkptr at %px has invalid TYPE %llu",
 		    bp, (longlong_t)BP_GET_TYPE(bp));
 	}
 	if (unlikely(BP_GET_COMPRESS(bp) >= ZIO_COMPRESS_FUNCTIONS)) {
 		errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
 		    "blkptr at %px has invalid COMPRESS %llu",
 		    bp, (longlong_t)BP_GET_COMPRESS(bp));
 	}
 	if (unlikely(BP_GET_LSIZE(bp) > SPA_MAXBLOCKSIZE)) {
 		errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
 		    "blkptr at %px has invalid LSIZE %llu",
 		    bp, (longlong_t)BP_GET_LSIZE(bp));
 	}
 	if (BP_IS_EMBEDDED(bp)) {
 		if (unlikely(BPE_GET_ETYPE(bp) >= NUM_BP_EMBEDDED_TYPES)) {
 			errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
 			    "blkptr at %px has invalid ETYPE %llu",
 			    bp, (longlong_t)BPE_GET_ETYPE(bp));
 		}
 		if (unlikely(BPE_GET_PSIZE(bp) > BPE_PAYLOAD_SIZE)) {
 			errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
 			    "blkptr at %px has invalid PSIZE %llu",
 			    bp, (longlong_t)BPE_GET_PSIZE(bp));
 		}
 		return (errors == 0);
 	}
 	if (unlikely(BP_GET_CHECKSUM(bp) >= ZIO_CHECKSUM_FUNCTIONS)) {
 		errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
 		    "blkptr at %px has invalid CHECKSUM %llu",
 		    bp, (longlong_t)BP_GET_CHECKSUM(bp));
 	}
 	if (unlikely(BP_GET_PSIZE(bp) > SPA_MAXBLOCKSIZE)) {
 		errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
 		    "blkptr at %px has invalid PSIZE %llu",
 		    bp, (longlong_t)BP_GET_PSIZE(bp));
 	}
 
 	/*
 	 * Do not verify individual DVAs if the config is not trusted. This
 	 * will be done once the zio is executed in vdev_mirror_map_alloc.
 	 */
 	if (unlikely(!spa->spa_trust_config))
 		return (errors == 0);
 
 	switch (blk_config) {
 	case BLK_CONFIG_HELD:
 		ASSERT(spa_config_held(spa, SCL_VDEV, RW_WRITER));
 		break;
 	case BLK_CONFIG_NEEDED:
 		spa_config_enter(spa, SCL_VDEV, bp, RW_READER);
 		break;
 	case BLK_CONFIG_SKIP:
 		return (errors == 0);
 	default:
 		panic("invalid blk_config %u", blk_config);
 	}
 
 	/*
 	 * Pool-specific checks.
 	 *
 	 * Note: it would be nice to verify that the logical birth
 	 * and physical birth are not too large.  However,
 	 * spa_freeze() allows the birth time of log blocks (and
 	 * dmu_sync()-ed blocks that are in the log) to be arbitrarily
 	 * large.
 	 */
 	for (int i = 0; i < BP_GET_NDVAS(bp); i++) {
 		const dva_t *dva = &bp->blk_dva[i];
 		uint64_t vdevid = DVA_GET_VDEV(dva);
 
 		if (unlikely(vdevid >= spa->spa_root_vdev->vdev_children)) {
 			errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
 			    "blkptr at %px DVA %u has invalid VDEV %llu",
 			    bp, i, (longlong_t)vdevid);
 			continue;
 		}
 		vdev_t *vd = spa->spa_root_vdev->vdev_child[vdevid];
 		if (unlikely(vd == NULL)) {
 			errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
 			    "blkptr at %px DVA %u has invalid VDEV %llu",
 			    bp, i, (longlong_t)vdevid);
 			continue;
 		}
 		if (unlikely(vd->vdev_ops == &vdev_hole_ops)) {
 			errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
 			    "blkptr at %px DVA %u has hole VDEV %llu",
 			    bp, i, (longlong_t)vdevid);
 			continue;
 		}
 		if (vd->vdev_ops == &vdev_missing_ops) {
 			/*
 			 * "missing" vdevs are valid during import, but we
 			 * don't have their detailed info (e.g. asize), so
 			 * we can't perform any more checks on them.
 			 */
 			continue;
 		}
 		uint64_t offset = DVA_GET_OFFSET(dva);
 		uint64_t asize = DVA_GET_ASIZE(dva);
 		if (DVA_GET_GANG(dva))
 			asize = vdev_gang_header_asize(vd);
 		if (unlikely(offset + asize > vd->vdev_asize)) {
 			errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
 			    "blkptr at %px DVA %u has invalid OFFSET %llu",
 			    bp, i, (longlong_t)offset);
 		}
 	}
 	if (blk_config == BLK_CONFIG_NEEDED)
 		spa_config_exit(spa, SCL_VDEV, bp);
 
 	return (errors == 0);
 }
 
 boolean_t
 zfs_dva_valid(spa_t *spa, const dva_t *dva, const blkptr_t *bp)
 {
 	(void) bp;
 	uint64_t vdevid = DVA_GET_VDEV(dva);
 
 	if (vdevid >= spa->spa_root_vdev->vdev_children)
 		return (B_FALSE);
 
 	vdev_t *vd = spa->spa_root_vdev->vdev_child[vdevid];
 	if (vd == NULL)
 		return (B_FALSE);
 
 	if (vd->vdev_ops == &vdev_hole_ops)
 		return (B_FALSE);
 
 	if (vd->vdev_ops == &vdev_missing_ops) {
 		return (B_FALSE);
 	}
 
 	uint64_t offset = DVA_GET_OFFSET(dva);
 	uint64_t asize = DVA_GET_ASIZE(dva);
 
 	if (DVA_GET_GANG(dva))
 		asize = vdev_gang_header_asize(vd);
 	if (offset + asize > vd->vdev_asize)
 		return (B_FALSE);
 
 	return (B_TRUE);
 }
 
 zio_t *
 zio_read(zio_t *pio, spa_t *spa, const blkptr_t *bp,
     abd_t *data, uint64_t size, zio_done_func_t *done, void *private,
     zio_priority_t priority, zio_flag_t flags, const zbookmark_phys_t *zb)
 {
 	zio_t *zio;
 
 	zio = zio_create(pio, spa, BP_GET_BIRTH(bp), bp,
 	    data, size, size, done, private,
 	    ZIO_TYPE_READ, priority, flags, NULL, 0, zb,
 	    ZIO_STAGE_OPEN, (flags & ZIO_FLAG_DDT_CHILD) ?
 	    ZIO_DDT_CHILD_READ_PIPELINE : ZIO_READ_PIPELINE);
 
 	return (zio);
 }
 
 zio_t *
 zio_write(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp,
     abd_t *data, uint64_t lsize, uint64_t psize, const zio_prop_t *zp,
     zio_done_func_t *ready, zio_done_func_t *children_ready,
     zio_done_func_t *done, void *private, zio_priority_t priority,
     zio_flag_t flags, const zbookmark_phys_t *zb)
 {
 	zio_t *zio;
 	enum zio_stage pipeline = zp->zp_direct_write == B_TRUE ?
 	    ZIO_DIRECT_WRITE_PIPELINE : (flags & ZIO_FLAG_DDT_CHILD) ?
 	    ZIO_DDT_CHILD_WRITE_PIPELINE : ZIO_WRITE_PIPELINE;
 
 
 	zio = zio_create(pio, spa, txg, bp, data, lsize, psize, done, private,
 	    ZIO_TYPE_WRITE, priority, flags, NULL, 0, zb,
 	    ZIO_STAGE_OPEN, pipeline);
 
 	zio->io_ready = ready;
 	zio->io_children_ready = children_ready;
 	zio->io_prop = *zp;
 
 	/*
 	 * Data can be NULL if we are going to call zio_write_override() to
 	 * provide the already-allocated BP.  But we may need the data to
 	 * verify a dedup hit (if requested).  In this case, don't try to
 	 * dedup (just take the already-allocated BP verbatim). Encrypted
 	 * dedup blocks need data as well so we also disable dedup in this
 	 * case.
 	 */
 	if (data == NULL &&
 	    (zio->io_prop.zp_dedup_verify || zio->io_prop.zp_encrypt)) {
 		zio->io_prop.zp_dedup = zio->io_prop.zp_dedup_verify = B_FALSE;
 	}
 
 	return (zio);
 }
 
 zio_t *
 zio_rewrite(zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp, abd_t *data,
     uint64_t size, zio_done_func_t *done, void *private,
     zio_priority_t priority, zio_flag_t flags, zbookmark_phys_t *zb)
 {
 	zio_t *zio;
 
 	zio = zio_create(pio, spa, txg, bp, data, size, size, done, private,
 	    ZIO_TYPE_WRITE, priority, flags | ZIO_FLAG_IO_REWRITE, NULL, 0, zb,
 	    ZIO_STAGE_OPEN, ZIO_REWRITE_PIPELINE);
 
 	return (zio);
 }
 
 void
 zio_write_override(zio_t *zio, blkptr_t *bp, int copies, boolean_t nopwrite,
     boolean_t brtwrite)
 {
 	ASSERT(zio->io_type == ZIO_TYPE_WRITE);
 	ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
 	ASSERT(zio->io_stage == ZIO_STAGE_OPEN);
 	ASSERT(zio->io_txg == spa_syncing_txg(zio->io_spa));
 	ASSERT(!brtwrite || !nopwrite);
 
 	/*
 	 * We must reset the io_prop to match the values that existed
 	 * when the bp was first written by dmu_sync() keeping in mind
 	 * that nopwrite and dedup are mutually exclusive.
 	 */
 	zio->io_prop.zp_dedup = nopwrite ? B_FALSE : zio->io_prop.zp_dedup;
 	zio->io_prop.zp_nopwrite = nopwrite;
 	zio->io_prop.zp_brtwrite = brtwrite;
 	zio->io_prop.zp_copies = copies;
 	zio->io_bp_override = bp;
 }
 
 void
 zio_free(spa_t *spa, uint64_t txg, const blkptr_t *bp)
 {
 
 	(void) zfs_blkptr_verify(spa, bp, BLK_CONFIG_NEEDED, BLK_VERIFY_HALT);
 
 	/*
 	 * The check for EMBEDDED is a performance optimization.  We
 	 * process the free here (by ignoring it) rather than
 	 * putting it on the list and then processing it in zio_free_sync().
 	 */
 	if (BP_IS_EMBEDDED(bp))
 		return;
 
 	/*
 	 * Frees that are for the currently-syncing txg, are not going to be
 	 * deferred, and which will not need to do a read (i.e. not GANG or
 	 * DEDUP), can be processed immediately.  Otherwise, put them on the
 	 * in-memory list for later processing.
 	 *
 	 * Note that we only defer frees after zfs_sync_pass_deferred_free
 	 * when the log space map feature is disabled. [see relevant comment
 	 * in spa_sync_iterate_to_convergence()]
 	 */
 	if (BP_IS_GANG(bp) ||
 	    BP_GET_DEDUP(bp) ||
 	    txg != spa->spa_syncing_txg ||
 	    (spa_sync_pass(spa) >= zfs_sync_pass_deferred_free &&
 	    !spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP)) ||
 	    brt_maybe_exists(spa, bp)) {
 		metaslab_check_free(spa, bp);
 		bplist_append(&spa->spa_free_bplist[txg & TXG_MASK], bp);
 	} else {
 		VERIFY3P(zio_free_sync(NULL, spa, txg, bp, 0), ==, NULL);
 	}
 }
 
 /*
  * To improve performance, this function may return NULL if we were able
  * to do the free immediately.  This avoids the cost of creating a zio
  * (and linking it to the parent, etc).
  */
 zio_t *
 zio_free_sync(zio_t *pio, spa_t *spa, uint64_t txg, const blkptr_t *bp,
     zio_flag_t flags)
 {
 	ASSERT(!BP_IS_HOLE(bp));
 	ASSERT(spa_syncing_txg(spa) == txg);
 
 	if (BP_IS_EMBEDDED(bp))
 		return (NULL);
 
 	metaslab_check_free(spa, bp);
 	arc_freed(spa, bp);
 	dsl_scan_freed(spa, bp);
 
 	if (BP_IS_GANG(bp) ||
 	    BP_GET_DEDUP(bp) ||
 	    brt_maybe_exists(spa, bp)) {
 		/*
 		 * GANG, DEDUP and BRT blocks can induce a read (for the gang
 		 * block header, the DDT or the BRT), so issue them
 		 * asynchronously so that this thread is not tied up.
 		 */
 		enum zio_stage stage =
 		    ZIO_FREE_PIPELINE | ZIO_STAGE_ISSUE_ASYNC;
 
 		return (zio_create(pio, spa, txg, bp, NULL, BP_GET_PSIZE(bp),
 		    BP_GET_PSIZE(bp), NULL, NULL,
 		    ZIO_TYPE_FREE, ZIO_PRIORITY_NOW,
 		    flags, NULL, 0, NULL, ZIO_STAGE_OPEN, stage));
 	} else {
 		metaslab_free(spa, bp, txg, B_FALSE);
 		return (NULL);
 	}
 }
 
 zio_t *
 zio_claim(zio_t *pio, spa_t *spa, uint64_t txg, const blkptr_t *bp,
     zio_done_func_t *done, void *private, zio_flag_t flags)
 {
 	zio_t *zio;
 
 	(void) zfs_blkptr_verify(spa, bp, (flags & ZIO_FLAG_CONFIG_WRITER) ?
 	    BLK_CONFIG_HELD : BLK_CONFIG_NEEDED, BLK_VERIFY_HALT);
 
 	if (BP_IS_EMBEDDED(bp))
 		return (zio_null(pio, spa, NULL, NULL, NULL, 0));
 
 	/*
 	 * A claim is an allocation of a specific block.  Claims are needed
 	 * to support immediate writes in the intent log.  The issue is that
 	 * immediate writes contain committed data, but in a txg that was
 	 * *not* committed.  Upon opening the pool after an unclean shutdown,
 	 * the intent log claims all blocks that contain immediate write data
 	 * so that the SPA knows they're in use.
 	 *
 	 * All claims *must* be resolved in the first txg -- before the SPA
 	 * starts allocating blocks -- so that nothing is allocated twice.
 	 * If txg == 0 we just verify that the block is claimable.
 	 */
 	ASSERT3U(BP_GET_LOGICAL_BIRTH(&spa->spa_uberblock.ub_rootbp), <,
 	    spa_min_claim_txg(spa));
 	ASSERT(txg == spa_min_claim_txg(spa) || txg == 0);
 	ASSERT(!BP_GET_DEDUP(bp) || !spa_writeable(spa));	/* zdb(8) */
 
 	zio = zio_create(pio, spa, txg, bp, NULL, BP_GET_PSIZE(bp),
 	    BP_GET_PSIZE(bp), done, private, ZIO_TYPE_CLAIM, ZIO_PRIORITY_NOW,
 	    flags, NULL, 0, NULL, ZIO_STAGE_OPEN, ZIO_CLAIM_PIPELINE);
 	ASSERT0(zio->io_queued_timestamp);
 
 	return (zio);
 }
 
 zio_t *
 zio_trim(zio_t *pio, vdev_t *vd, uint64_t offset, uint64_t size,
     zio_done_func_t *done, void *private, zio_priority_t priority,
     zio_flag_t flags, enum trim_flag trim_flags)
 {
 	zio_t *zio;
 
 	ASSERT0(vd->vdev_children);
 	ASSERT0(P2PHASE(offset, 1ULL << vd->vdev_ashift));
 	ASSERT0(P2PHASE(size, 1ULL << vd->vdev_ashift));
 	ASSERT3U(size, !=, 0);
 
 	zio = zio_create(pio, vd->vdev_spa, 0, NULL, NULL, size, size, done,
 	    private, ZIO_TYPE_TRIM, priority, flags | ZIO_FLAG_PHYSICAL,
 	    vd, offset, NULL, ZIO_STAGE_OPEN, ZIO_TRIM_PIPELINE);
 	zio->io_trim_flags = trim_flags;
 
 	return (zio);
 }
 
 zio_t *
 zio_read_phys(zio_t *pio, vdev_t *vd, uint64_t offset, uint64_t size,
     abd_t *data, int checksum, zio_done_func_t *done, void *private,
     zio_priority_t priority, zio_flag_t flags, boolean_t labels)
 {
 	zio_t *zio;
 
 	ASSERT(vd->vdev_children == 0);
 	ASSERT(!labels || offset + size <= VDEV_LABEL_START_SIZE ||
 	    offset >= vd->vdev_psize - VDEV_LABEL_END_SIZE);
 	ASSERT3U(offset + size, <=, vd->vdev_psize);
 
 	zio = zio_create(pio, vd->vdev_spa, 0, NULL, data, size, size, done,
 	    private, ZIO_TYPE_READ, priority, flags | ZIO_FLAG_PHYSICAL, vd,
 	    offset, NULL, ZIO_STAGE_OPEN, ZIO_READ_PHYS_PIPELINE);
 
 	zio->io_prop.zp_checksum = checksum;
 
 	return (zio);
 }
 
 zio_t *
 zio_write_phys(zio_t *pio, vdev_t *vd, uint64_t offset, uint64_t size,
     abd_t *data, int checksum, zio_done_func_t *done, void *private,
     zio_priority_t priority, zio_flag_t flags, boolean_t labels)
 {
 	zio_t *zio;
 
 	ASSERT(vd->vdev_children == 0);
 	ASSERT(!labels || offset + size <= VDEV_LABEL_START_SIZE ||
 	    offset >= vd->vdev_psize - VDEV_LABEL_END_SIZE);
 	ASSERT3U(offset + size, <=, vd->vdev_psize);
 
 	zio = zio_create(pio, vd->vdev_spa, 0, NULL, data, size, size, done,
 	    private, ZIO_TYPE_WRITE, priority, flags | ZIO_FLAG_PHYSICAL, vd,
 	    offset, NULL, ZIO_STAGE_OPEN, ZIO_WRITE_PHYS_PIPELINE);
 
 	zio->io_prop.zp_checksum = checksum;
 
 	if (zio_checksum_table[checksum].ci_flags & ZCHECKSUM_FLAG_EMBEDDED) {
 		/*
 		 * zec checksums are necessarily destructive -- they modify
 		 * the end of the write buffer to hold the verifier/checksum.
 		 * Therefore, we must make a local copy in case the data is
 		 * being written to multiple places in parallel.
 		 */
 		abd_t *wbuf = abd_alloc_sametype(data, size);
 		abd_copy(wbuf, data, size);
 
 		zio_push_transform(zio, wbuf, size, size, NULL);
 	}
 
 	return (zio);
 }
 
 /*
  * Create a child I/O to do some work for us.
  */
 zio_t *
 zio_vdev_child_io(zio_t *pio, blkptr_t *bp, vdev_t *vd, uint64_t offset,
     abd_t *data, uint64_t size, int type, zio_priority_t priority,
     zio_flag_t flags, zio_done_func_t *done, void *private)
 {
 	enum zio_stage pipeline = ZIO_VDEV_CHILD_PIPELINE;
 	zio_t *zio;
 
 	/*
 	 * vdev child I/Os do not propagate their error to the parent.
 	 * Therefore, for correct operation the caller *must* check for
 	 * and handle the error in the child i/o's done callback.
 	 * The only exceptions are i/os that we don't care about
 	 * (OPTIONAL or REPAIR).
 	 */
 	ASSERT((flags & ZIO_FLAG_OPTIONAL) || (flags & ZIO_FLAG_IO_REPAIR) ||
 	    done != NULL);
 
 	if (type == ZIO_TYPE_READ && bp != NULL) {
 		/*
 		 * If we have the bp, then the child should perform the
 		 * checksum and the parent need not.  This pushes error
 		 * detection as close to the leaves as possible and
 		 * eliminates redundant checksums in the interior nodes.
 		 */
 		pipeline |= ZIO_STAGE_CHECKSUM_VERIFY;
 		pio->io_pipeline &= ~ZIO_STAGE_CHECKSUM_VERIFY;
+		/*
+		 * We never allow the mirror VDEV to attempt reading from any
+		 * additional data copies after the first Direct I/O checksum
+		 * verify failure. This is to avoid bad data being written out
+		 * through the mirror during self healing. See comment in
+		 * vdev_mirror_io_done() for more details.
+		 */
+		ASSERT0(pio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR);
 	} else if (type == ZIO_TYPE_WRITE &&
 	    pio->io_prop.zp_direct_write == B_TRUE) {
 		/*
 		 * By default we only will verify checksums for Direct I/O
 		 * writes for Linux. FreeBSD is able to place user pages under
 		 * write protection before issuing them to the ZIO pipeline.
 		 *
 		 * Checksum validation errors will only be reported through
 		 * the top-level VDEV, which is set by this child ZIO.
 		 */
 		ASSERT3P(bp, !=, NULL);
 		ASSERT3U(pio->io_child_type, ==, ZIO_CHILD_LOGICAL);
 		pipeline |= ZIO_STAGE_DIO_CHECKSUM_VERIFY;
 	}
 
 	if (vd->vdev_ops->vdev_op_leaf) {
 		ASSERT0(vd->vdev_children);
 		offset += VDEV_LABEL_START_SIZE;
 	}
 
 	flags |= ZIO_VDEV_CHILD_FLAGS(pio);
 
 	/*
 	 * If we've decided to do a repair, the write is not speculative --
 	 * even if the original read was.
 	 */
 	if (flags & ZIO_FLAG_IO_REPAIR)
 		flags &= ~ZIO_FLAG_SPECULATIVE;
 
 	/*
 	 * If we're creating a child I/O that is not associated with a
 	 * top-level vdev, then the child zio is not an allocating I/O.
 	 * If this is a retried I/O then we ignore it since we will
 	 * have already processed the original allocating I/O.
 	 */
 	if (flags & ZIO_FLAG_IO_ALLOCATING &&
 	    (vd != vd->vdev_top || (flags & ZIO_FLAG_IO_RETRY))) {
 		ASSERT(pio->io_metaslab_class != NULL);
 		ASSERT(pio->io_metaslab_class->mc_alloc_throttle_enabled);
 		ASSERT(type == ZIO_TYPE_WRITE);
 		ASSERT(priority == ZIO_PRIORITY_ASYNC_WRITE);
 		ASSERT(!(flags & ZIO_FLAG_IO_REPAIR));
 		ASSERT(!(pio->io_flags & ZIO_FLAG_IO_REWRITE) ||
 		    pio->io_child_type == ZIO_CHILD_GANG);
 
 		flags &= ~ZIO_FLAG_IO_ALLOCATING;
 	}
 
 	zio = zio_create(pio, pio->io_spa, pio->io_txg, bp, data, size, size,
 	    done, private, type, priority, flags, vd, offset, &pio->io_bookmark,
 	    ZIO_STAGE_VDEV_IO_START >> 1, pipeline);
 	ASSERT3U(zio->io_child_type, ==, ZIO_CHILD_VDEV);
 
 	return (zio);
 }
 
 zio_t *
 zio_vdev_delegated_io(vdev_t *vd, uint64_t offset, abd_t *data, uint64_t size,
     zio_type_t type, zio_priority_t priority, zio_flag_t flags,
     zio_done_func_t *done, void *private)
 {
 	zio_t *zio;
 
 	ASSERT(vd->vdev_ops->vdev_op_leaf);
 
 	zio = zio_create(NULL, vd->vdev_spa, 0, NULL,
 	    data, size, size, done, private, type, priority,
 	    flags | ZIO_FLAG_CANFAIL | ZIO_FLAG_DONT_RETRY | ZIO_FLAG_DELEGATED,
 	    vd, offset, NULL,
 	    ZIO_STAGE_VDEV_IO_START >> 1, ZIO_VDEV_CHILD_PIPELINE);
 
 	return (zio);
 }
 
 
 /*
  * Send a flush command to the given vdev. Unlike most zio creation functions,
  * the flush zios are issued immediately. You can wait on pio to pause until
  * the flushes complete.
  */
 void
 zio_flush(zio_t *pio, vdev_t *vd)
 {
 	const zio_flag_t flags = ZIO_FLAG_CANFAIL | ZIO_FLAG_DONT_PROPAGATE |
 	    ZIO_FLAG_DONT_RETRY;
 
 	if (vd->vdev_nowritecache)
 		return;
 
 	if (vd->vdev_children == 0) {
 		zio_nowait(zio_create(pio, vd->vdev_spa, 0, NULL, NULL, 0, 0,
 		    NULL, NULL, ZIO_TYPE_FLUSH, ZIO_PRIORITY_NOW, flags, vd, 0,
 		    NULL, ZIO_STAGE_OPEN, ZIO_FLUSH_PIPELINE));
 	} else {
 		for (uint64_t c = 0; c < vd->vdev_children; c++)
 			zio_flush(pio, vd->vdev_child[c]);
 	}
 }
 
 void
 zio_shrink(zio_t *zio, uint64_t size)
 {
 	ASSERT3P(zio->io_executor, ==, NULL);
 	ASSERT3U(zio->io_orig_size, ==, zio->io_size);
 	ASSERT3U(size, <=, zio->io_size);
 
 	/*
 	 * We don't shrink for raidz because of problems with the
 	 * reconstruction when reading back less than the block size.
 	 * Note, BP_IS_RAIDZ() assumes no compression.
 	 */
 	ASSERT(BP_GET_COMPRESS(zio->io_bp) == ZIO_COMPRESS_OFF);
 	if (!BP_IS_RAIDZ(zio->io_bp)) {
 		/* we are not doing a raw write */
 		ASSERT3U(zio->io_size, ==, zio->io_lsize);
 		zio->io_orig_size = zio->io_size = zio->io_lsize = size;
 	}
 }
 
 /*
  * Round provided allocation size up to a value that can be allocated
  * by at least some vdev(s) in the pool with minimum or no additional
  * padding and without extra space usage on others
  */
 static uint64_t
 zio_roundup_alloc_size(spa_t *spa, uint64_t size)
 {
 	if (size > spa->spa_min_alloc)
 		return (roundup(size, spa->spa_gcd_alloc));
 	return (spa->spa_min_alloc);
 }
 
 size_t
 zio_get_compression_max_size(enum zio_compress compress, uint64_t gcd_alloc,
     uint64_t min_alloc, size_t s_len)
 {
 	size_t d_len;
 
 	/* minimum 12.5% must be saved (legacy value, may be changed later) */
 	d_len = s_len - (s_len >> 3);
 
 	/* ZLE can't use exactly d_len bytes, it needs more, so ignore it */
 	if (compress == ZIO_COMPRESS_ZLE)
 		return (d_len);
 
 	d_len = d_len - d_len % gcd_alloc;
 
 	if (d_len < min_alloc)
 		return (BPE_PAYLOAD_SIZE);
 	return (d_len);
 }
 
 /*
  * ==========================================================================
  * Prepare to read and write logical blocks
  * ==========================================================================
  */
 
 static zio_t *
 zio_read_bp_init(zio_t *zio)
 {
 	blkptr_t *bp = zio->io_bp;
 	uint64_t psize =
 	    BP_IS_EMBEDDED(bp) ? BPE_GET_PSIZE(bp) : BP_GET_PSIZE(bp);
 
 	ASSERT3P(zio->io_bp, ==, &zio->io_bp_copy);
 
 	if (BP_GET_COMPRESS(bp) != ZIO_COMPRESS_OFF &&
 	    zio->io_child_type == ZIO_CHILD_LOGICAL &&
 	    !(zio->io_flags & ZIO_FLAG_RAW_COMPRESS)) {
 		zio_push_transform(zio, abd_alloc_sametype(zio->io_abd, psize),
 		    psize, psize, zio_decompress);
 	}
 
 	if (((BP_IS_PROTECTED(bp) && !(zio->io_flags & ZIO_FLAG_RAW_ENCRYPT)) ||
 	    BP_HAS_INDIRECT_MAC_CKSUM(bp)) &&
 	    zio->io_child_type == ZIO_CHILD_LOGICAL) {
 		zio_push_transform(zio, abd_alloc_sametype(zio->io_abd, psize),
 		    psize, psize, zio_decrypt);
 	}
 
 	if (BP_IS_EMBEDDED(bp) && BPE_GET_ETYPE(bp) == BP_EMBEDDED_TYPE_DATA) {
 		int psize = BPE_GET_PSIZE(bp);
 		void *data = abd_borrow_buf(zio->io_abd, psize);
 
 		zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
 		decode_embedded_bp_compressed(bp, data);
 		abd_return_buf_copy(zio->io_abd, data, psize);
 	} else {
 		ASSERT(!BP_IS_EMBEDDED(bp));
 	}
 
 	if (BP_GET_DEDUP(bp) && zio->io_child_type == ZIO_CHILD_LOGICAL)
 		zio->io_pipeline = ZIO_DDT_READ_PIPELINE;
 
 	return (zio);
 }
 
 static zio_t *
 zio_write_bp_init(zio_t *zio)
 {
 	if (!IO_IS_ALLOCATING(zio))
 		return (zio);
 
 	ASSERT(zio->io_child_type != ZIO_CHILD_DDT);
 
 	if (zio->io_bp_override) {
 		blkptr_t *bp = zio->io_bp;
 		zio_prop_t *zp = &zio->io_prop;
 
 		ASSERT(BP_GET_LOGICAL_BIRTH(bp) != zio->io_txg);
 
 		*bp = *zio->io_bp_override;
 		zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
 
 		if (zp->zp_brtwrite)
 			return (zio);
 
 		ASSERT(!BP_GET_DEDUP(zio->io_bp_override));
 
 		if (BP_IS_EMBEDDED(bp))
 			return (zio);
 
 		/*
 		 * If we've been overridden and nopwrite is set then
 		 * set the flag accordingly to indicate that a nopwrite
 		 * has already occurred.
 		 */
 		if (!BP_IS_HOLE(bp) && zp->zp_nopwrite) {
 			ASSERT(!zp->zp_dedup);
 			ASSERT3U(BP_GET_CHECKSUM(bp), ==, zp->zp_checksum);
 			zio->io_flags |= ZIO_FLAG_NOPWRITE;
 			return (zio);
 		}
 
 		ASSERT(!zp->zp_nopwrite);
 
 		if (BP_IS_HOLE(bp) || !zp->zp_dedup)
 			return (zio);
 
 		ASSERT((zio_checksum_table[zp->zp_checksum].ci_flags &
 		    ZCHECKSUM_FLAG_DEDUP) || zp->zp_dedup_verify);
 
 		if (BP_GET_CHECKSUM(bp) == zp->zp_checksum &&
 		    !zp->zp_encrypt) {
 			BP_SET_DEDUP(bp, 1);
 			zio->io_pipeline |= ZIO_STAGE_DDT_WRITE;
 			return (zio);
 		}
 
 		/*
 		 * We were unable to handle this as an override bp, treat
 		 * it as a regular write I/O.
 		 */
 		zio->io_bp_override = NULL;
 		*bp = zio->io_bp_orig;
 		zio->io_pipeline = zio->io_orig_pipeline;
 	}
 
 	return (zio);
 }
 
 static zio_t *
 zio_write_compress(zio_t *zio)
 {
 	spa_t *spa = zio->io_spa;
 	zio_prop_t *zp = &zio->io_prop;
 	enum zio_compress compress = zp->zp_compress;
 	blkptr_t *bp = zio->io_bp;
 	uint64_t lsize = zio->io_lsize;
 	uint64_t psize = zio->io_size;
 	uint32_t pass = 1;
 
 	/*
 	 * If our children haven't all reached the ready stage,
 	 * wait for them and then repeat this pipeline stage.
 	 */
 	if (zio_wait_for_children(zio, ZIO_CHILD_LOGICAL_BIT |
 	    ZIO_CHILD_GANG_BIT, ZIO_WAIT_READY)) {
 		return (NULL);
 	}
 
 	if (!IO_IS_ALLOCATING(zio))
 		return (zio);
 
 	if (zio->io_children_ready != NULL) {
 		/*
 		 * Now that all our children are ready, run the callback
 		 * associated with this zio in case it wants to modify the
 		 * data to be written.
 		 */
 		ASSERT3U(zp->zp_level, >, 0);
 		zio->io_children_ready(zio);
 	}
 
 	ASSERT(zio->io_child_type != ZIO_CHILD_DDT);
 	ASSERT(zio->io_bp_override == NULL);
 
 	if (!BP_IS_HOLE(bp) && BP_GET_LOGICAL_BIRTH(bp) == zio->io_txg) {
 		/*
 		 * We're rewriting an existing block, which means we're
 		 * working on behalf of spa_sync().  For spa_sync() to
 		 * converge, it must eventually be the case that we don't
 		 * have to allocate new blocks.  But compression changes
 		 * the blocksize, which forces a reallocate, and makes
 		 * convergence take longer.  Therefore, after the first
 		 * few passes, stop compressing to ensure convergence.
 		 */
 		pass = spa_sync_pass(spa);
 
 		ASSERT(zio->io_txg == spa_syncing_txg(spa));
 		ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
 		ASSERT(!BP_GET_DEDUP(bp));
 
 		if (pass >= zfs_sync_pass_dont_compress)
 			compress = ZIO_COMPRESS_OFF;
 
 		/* Make sure someone doesn't change their mind on overwrites */
 		ASSERT(BP_IS_EMBEDDED(bp) || BP_IS_GANG(bp) ||
 		    MIN(zp->zp_copies, spa_max_replication(spa))
 		    == BP_GET_NDVAS(bp));
 	}
 
 	/* If it's a compressed write that is not raw, compress the buffer. */
 	if (compress != ZIO_COMPRESS_OFF &&
 	    !(zio->io_flags & ZIO_FLAG_RAW_COMPRESS)) {
 		abd_t *cabd = NULL;
 		if (abd_cmp_zero(zio->io_abd, lsize) == 0)
 			psize = 0;
 		else if (compress == ZIO_COMPRESS_EMPTY)
 			psize = lsize;
 		else
 			psize = zio_compress_data(compress, zio->io_abd, &cabd,
 			    lsize,
 			    zio_get_compression_max_size(compress,
 			    spa->spa_gcd_alloc, spa->spa_min_alloc, lsize),
 			    zp->zp_complevel);
 		if (psize == 0) {
 			compress = ZIO_COMPRESS_OFF;
 		} else if (psize >= lsize) {
 			compress = ZIO_COMPRESS_OFF;
 			if (cabd != NULL)
 				abd_free(cabd);
 		} else if (!zp->zp_dedup && !zp->zp_encrypt &&
 		    psize <= BPE_PAYLOAD_SIZE &&
 		    zp->zp_level == 0 && !DMU_OT_HAS_FILL(zp->zp_type) &&
 		    spa_feature_is_enabled(spa, SPA_FEATURE_EMBEDDED_DATA)) {
 			void *cbuf = abd_borrow_buf_copy(cabd, lsize);
 			encode_embedded_bp_compressed(bp,
 			    cbuf, compress, lsize, psize);
 			BPE_SET_ETYPE(bp, BP_EMBEDDED_TYPE_DATA);
 			BP_SET_TYPE(bp, zio->io_prop.zp_type);
 			BP_SET_LEVEL(bp, zio->io_prop.zp_level);
 			abd_return_buf(cabd, cbuf, lsize);
 			abd_free(cabd);
 			BP_SET_LOGICAL_BIRTH(bp, zio->io_txg);
 			zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
 			ASSERT(spa_feature_is_active(spa,
 			    SPA_FEATURE_EMBEDDED_DATA));
 			return (zio);
 		} else {
 			/*
 			 * Round compressed size up to the minimum allocation
 			 * size of the smallest-ashift device, and zero the
 			 * tail. This ensures that the compressed size of the
 			 * BP (and thus compressratio property) are correct,
 			 * in that we charge for the padding used to fill out
 			 * the last sector.
 			 */
 			size_t rounded = (size_t)zio_roundup_alloc_size(spa,
 			    psize);
 			if (rounded >= lsize) {
 				compress = ZIO_COMPRESS_OFF;
 				abd_free(cabd);
 				psize = lsize;
 			} else {
 				abd_zero_off(cabd, psize, rounded - psize);
 				psize = rounded;
 				zio_push_transform(zio, cabd,
 				    psize, lsize, NULL);
 			}
 		}
 
 		/*
 		 * We were unable to handle this as an override bp, treat
 		 * it as a regular write I/O.
 		 */
 		zio->io_bp_override = NULL;
 		*bp = zio->io_bp_orig;
 		zio->io_pipeline = zio->io_orig_pipeline;
 
 	} else if ((zio->io_flags & ZIO_FLAG_RAW_ENCRYPT) != 0 &&
 	    zp->zp_type == DMU_OT_DNODE) {
 		/*
 		 * The DMU actually relies on the zio layer's compression
 		 * to free metadnode blocks that have had all contained
 		 * dnodes freed. As a result, even when doing a raw
 		 * receive, we must check whether the block can be compressed
 		 * to a hole.
 		 */
 		if (abd_cmp_zero(zio->io_abd, lsize) == 0) {
 			psize = 0;
 			compress = ZIO_COMPRESS_OFF;
 		} else {
 			psize = lsize;
 		}
 	} else if (zio->io_flags & ZIO_FLAG_RAW_COMPRESS &&
 	    !(zio->io_flags & ZIO_FLAG_RAW_ENCRYPT)) {
 		/*
 		 * If we are raw receiving an encrypted dataset we should not
 		 * take this codepath because it will change the on-disk block
 		 * and decryption will fail.
 		 */
 		size_t rounded = MIN((size_t)zio_roundup_alloc_size(spa, psize),
 		    lsize);
 
 		if (rounded != psize) {
 			abd_t *cdata = abd_alloc_linear(rounded, B_TRUE);
 			abd_zero_off(cdata, psize, rounded - psize);
 			abd_copy_off(cdata, zio->io_abd, 0, 0, psize);
 			psize = rounded;
 			zio_push_transform(zio, cdata,
 			    psize, rounded, NULL);
 		}
 	} else {
 		ASSERT3U(psize, !=, 0);
 	}
 
 	/*
 	 * The final pass of spa_sync() must be all rewrites, but the first
 	 * few passes offer a trade-off: allocating blocks defers convergence,
 	 * but newly allocated blocks are sequential, so they can be written
 	 * to disk faster.  Therefore, we allow the first few passes of
 	 * spa_sync() to allocate new blocks, but force rewrites after that.
 	 * There should only be a handful of blocks after pass 1 in any case.
 	 */
 	if (!BP_IS_HOLE(bp) && BP_GET_LOGICAL_BIRTH(bp) == zio->io_txg &&
 	    BP_GET_PSIZE(bp) == psize &&
 	    pass >= zfs_sync_pass_rewrite) {
 		VERIFY3U(psize, !=, 0);
 		enum zio_stage gang_stages = zio->io_pipeline & ZIO_GANG_STAGES;
 
 		zio->io_pipeline = ZIO_REWRITE_PIPELINE | gang_stages;
 		zio->io_flags |= ZIO_FLAG_IO_REWRITE;
 	} else {
 		BP_ZERO(bp);
 		zio->io_pipeline = ZIO_WRITE_PIPELINE;
 	}
 
 	if (psize == 0) {
 		if (BP_GET_LOGICAL_BIRTH(&zio->io_bp_orig) != 0 &&
 		    spa_feature_is_active(spa, SPA_FEATURE_HOLE_BIRTH)) {
 			BP_SET_LSIZE(bp, lsize);
 			BP_SET_TYPE(bp, zp->zp_type);
 			BP_SET_LEVEL(bp, zp->zp_level);
 			BP_SET_BIRTH(bp, zio->io_txg, 0);
 		}
 		zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
 	} else {
 		ASSERT(zp->zp_checksum != ZIO_CHECKSUM_GANG_HEADER);
 		BP_SET_LSIZE(bp, lsize);
 		BP_SET_TYPE(bp, zp->zp_type);
 		BP_SET_LEVEL(bp, zp->zp_level);
 		BP_SET_PSIZE(bp, psize);
 		BP_SET_COMPRESS(bp, compress);
 		BP_SET_CHECKSUM(bp, zp->zp_checksum);
 		BP_SET_DEDUP(bp, zp->zp_dedup);
 		BP_SET_BYTEORDER(bp, ZFS_HOST_BYTEORDER);
 		if (zp->zp_dedup) {
 			ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
 			ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REWRITE));
 			ASSERT(!zp->zp_encrypt ||
 			    DMU_OT_IS_ENCRYPTED(zp->zp_type));
 			zio->io_pipeline = ZIO_DDT_WRITE_PIPELINE;
 		}
 		if (zp->zp_nopwrite) {
 			ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
 			ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REWRITE));
 			zio->io_pipeline |= ZIO_STAGE_NOP_WRITE;
 		}
 	}
 	return (zio);
 }
 
 static zio_t *
 zio_free_bp_init(zio_t *zio)
 {
 	blkptr_t *bp = zio->io_bp;
 
 	if (zio->io_child_type == ZIO_CHILD_LOGICAL) {
 		if (BP_GET_DEDUP(bp))
 			zio->io_pipeline = ZIO_DDT_FREE_PIPELINE;
 	}
 
 	ASSERT3P(zio->io_bp, ==, &zio->io_bp_copy);
 
 	return (zio);
 }
 
 /*
  * ==========================================================================
  * Execute the I/O pipeline
  * ==========================================================================
  */
 
 static void
 zio_taskq_dispatch(zio_t *zio, zio_taskq_type_t q, boolean_t cutinline)
 {
 	spa_t *spa = zio->io_spa;
 	zio_type_t t = zio->io_type;
 
 	/*
 	 * If we're a config writer or a probe, the normal issue and
 	 * interrupt threads may all be blocked waiting for the config lock.
 	 * In this case, select the otherwise-unused taskq for ZIO_TYPE_NULL.
 	 */
 	if (zio->io_flags & (ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_PROBE))
 		t = ZIO_TYPE_NULL;
 
 	/*
 	 * A similar issue exists for the L2ARC write thread until L2ARC 2.0.
 	 */
 	if (t == ZIO_TYPE_WRITE && zio->io_vd && zio->io_vd->vdev_aux)
 		t = ZIO_TYPE_NULL;
 
 	/*
 	 * If this is a high priority I/O, then use the high priority taskq if
 	 * available or cut the line otherwise.
 	 */
 	if (zio->io_priority == ZIO_PRIORITY_SYNC_WRITE) {
 		if (spa->spa_zio_taskq[t][q + 1].stqs_count != 0)
 			q++;
 		else
 			cutinline = B_TRUE;
 	}
 
 	ASSERT3U(q, <, ZIO_TASKQ_TYPES);
 
 	spa_taskq_dispatch(spa, t, q, zio_execute, zio, cutinline);
 }
 
 static boolean_t
 zio_taskq_member(zio_t *zio, zio_taskq_type_t q)
 {
 	spa_t *spa = zio->io_spa;
 
 	taskq_t *tq = taskq_of_curthread();
 
 	for (zio_type_t t = 0; t < ZIO_TYPES; t++) {
 		spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q];
 		uint_t i;
 		for (i = 0; i < tqs->stqs_count; i++) {
 			if (tqs->stqs_taskq[i] == tq)
 				return (B_TRUE);
 		}
 	}
 
 	return (B_FALSE);
 }
 
 static zio_t *
 zio_issue_async(zio_t *zio)
 {
 	ASSERT((zio->io_type != ZIO_TYPE_WRITE) || ZIO_HAS_ALLOCATOR(zio));
 	zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_FALSE);
 	return (NULL);
 }
 
 void
 zio_interrupt(void *zio)
 {
 	zio_taskq_dispatch(zio, ZIO_TASKQ_INTERRUPT, B_FALSE);
 }
 
 void
 zio_delay_interrupt(zio_t *zio)
 {
 	/*
 	 * The timeout_generic() function isn't defined in userspace, so
 	 * rather than trying to implement the function, the zio delay
 	 * functionality has been disabled for userspace builds.
 	 */
 
 #ifdef _KERNEL
 	/*
 	 * If io_target_timestamp is zero, then no delay has been registered
 	 * for this IO, thus jump to the end of this function and "skip" the
 	 * delay; issuing it directly to the zio layer.
 	 */
 	if (zio->io_target_timestamp != 0) {
 		hrtime_t now = gethrtime();
 
 		if (now >= zio->io_target_timestamp) {
 			/*
 			 * This IO has already taken longer than the target
 			 * delay to complete, so we don't want to delay it
 			 * any longer; we "miss" the delay and issue it
 			 * directly to the zio layer. This is likely due to
 			 * the target latency being set to a value less than
 			 * the underlying hardware can satisfy (e.g. delay
 			 * set to 1ms, but the disks take 10ms to complete an
 			 * IO request).
 			 */
 
 			DTRACE_PROBE2(zio__delay__miss, zio_t *, zio,
 			    hrtime_t, now);
 
 			zio_interrupt(zio);
 		} else {
 			taskqid_t tid;
 			hrtime_t diff = zio->io_target_timestamp - now;
 			clock_t expire_at_tick = ddi_get_lbolt() +
 			    NSEC_TO_TICK(diff);
 
 			DTRACE_PROBE3(zio__delay__hit, zio_t *, zio,
 			    hrtime_t, now, hrtime_t, diff);
 
 			if (NSEC_TO_TICK(diff) == 0) {
 				/* Our delay is less than a jiffy - just spin */
 				zfs_sleep_until(zio->io_target_timestamp);
 				zio_interrupt(zio);
 			} else {
 				/*
 				 * Use taskq_dispatch_delay() in the place of
 				 * OpenZFS's timeout_generic().
 				 */
 				tid = taskq_dispatch_delay(system_taskq,
 				    zio_interrupt, zio, TQ_NOSLEEP,
 				    expire_at_tick);
 				if (tid == TASKQID_INVALID) {
 					/*
 					 * Couldn't allocate a task.  Just
 					 * finish the zio without a delay.
 					 */
 					zio_interrupt(zio);
 				}
 			}
 		}
 		return;
 	}
 #endif
 	DTRACE_PROBE1(zio__delay__skip, zio_t *, zio);
 	zio_interrupt(zio);
 }
 
 static void
 zio_deadman_impl(zio_t *pio, int ziodepth)
 {
 	zio_t *cio, *cio_next;
 	zio_link_t *zl = NULL;
 	vdev_t *vd = pio->io_vd;
 
 	if (zio_deadman_log_all || (vd != NULL && vd->vdev_ops->vdev_op_leaf)) {
 		vdev_queue_t *vq = vd ? &vd->vdev_queue : NULL;
 		zbookmark_phys_t *zb = &pio->io_bookmark;
 		uint64_t delta = gethrtime() - pio->io_timestamp;
 		uint64_t failmode = spa_get_deadman_failmode(pio->io_spa);
 
 		zfs_dbgmsg("slow zio[%d]: zio=%px timestamp=%llu "
 		    "delta=%llu queued=%llu io=%llu "
 		    "path=%s "
 		    "last=%llu type=%d "
 		    "priority=%d flags=0x%llx stage=0x%x "
 		    "pipeline=0x%x pipeline-trace=0x%x "
 		    "objset=%llu object=%llu "
 		    "level=%llu blkid=%llu "
 		    "offset=%llu size=%llu "
 		    "error=%d",
 		    ziodepth, pio, pio->io_timestamp,
 		    (u_longlong_t)delta, pio->io_delta, pio->io_delay,
 		    vd ? vd->vdev_path : "NULL",
 		    vq ? vq->vq_io_complete_ts : 0, pio->io_type,
 		    pio->io_priority, (u_longlong_t)pio->io_flags,
 		    pio->io_stage, pio->io_pipeline, pio->io_pipeline_trace,
 		    (u_longlong_t)zb->zb_objset, (u_longlong_t)zb->zb_object,
 		    (u_longlong_t)zb->zb_level, (u_longlong_t)zb->zb_blkid,
 		    (u_longlong_t)pio->io_offset, (u_longlong_t)pio->io_size,
 		    pio->io_error);
 		(void) zfs_ereport_post(FM_EREPORT_ZFS_DEADMAN,
 		    pio->io_spa, vd, zb, pio, 0);
 
 		if (failmode == ZIO_FAILURE_MODE_CONTINUE &&
 		    taskq_empty_ent(&pio->io_tqent)) {
 			zio_interrupt(pio);
 		}
 	}
 
 	mutex_enter(&pio->io_lock);
 	for (cio = zio_walk_children(pio, &zl); cio != NULL; cio = cio_next) {
 		cio_next = zio_walk_children(pio, &zl);
 		zio_deadman_impl(cio, ziodepth + 1);
 	}
 	mutex_exit(&pio->io_lock);
 }
 
 /*
  * Log the critical information describing this zio and all of its children
  * using the zfs_dbgmsg() interface then post deadman event for the ZED.
  */
 void
 zio_deadman(zio_t *pio, const char *tag)
 {
 	spa_t *spa = pio->io_spa;
 	char *name = spa_name(spa);
 
 	if (!zfs_deadman_enabled || spa_suspended(spa))
 		return;
 
 	zio_deadman_impl(pio, 0);
 
 	switch (spa_get_deadman_failmode(spa)) {
 	case ZIO_FAILURE_MODE_WAIT:
 		zfs_dbgmsg("%s waiting for hung I/O to pool '%s'", tag, name);
 		break;
 
 	case ZIO_FAILURE_MODE_CONTINUE:
 		zfs_dbgmsg("%s restarting hung I/O for pool '%s'", tag, name);
 		break;
 
 	case ZIO_FAILURE_MODE_PANIC:
 		fm_panic("%s determined I/O to pool '%s' is hung.", tag, name);
 		break;
 	}
 }
 
 /*
  * Execute the I/O pipeline until one of the following occurs:
  * (1) the I/O completes; (2) the pipeline stalls waiting for
  * dependent child I/Os; (3) the I/O issues, so we're waiting
  * for an I/O completion interrupt; (4) the I/O is delegated by
  * vdev-level caching or aggregation; (5) the I/O is deferred
  * due to vdev-level queueing; (6) the I/O is handed off to
  * another thread.  In all cases, the pipeline stops whenever
  * there's no CPU work; it never burns a thread in cv_wait_io().
  *
  * There's no locking on io_stage because there's no legitimate way
  * for multiple threads to be attempting to process the same I/O.
  */
 static zio_pipe_stage_t *zio_pipeline[];
 
 /*
  * zio_execute() is a wrapper around the static function
  * __zio_execute() so that we can force  __zio_execute() to be
  * inlined.  This reduces stack overhead which is important
  * because __zio_execute() is called recursively in several zio
  * code paths.  zio_execute() itself cannot be inlined because
  * it is externally visible.
  */
 void
 zio_execute(void *zio)
 {
 	fstrans_cookie_t cookie;
 
 	cookie = spl_fstrans_mark();
 	__zio_execute(zio);
 	spl_fstrans_unmark(cookie);
 }
 
 /*
  * Used to determine if in the current context the stack is sized large
  * enough to allow zio_execute() to be called recursively.  A minimum
  * stack size of 16K is required to avoid needing to re-dispatch the zio.
  */
 static boolean_t
 zio_execute_stack_check(zio_t *zio)
 {
 #if !defined(HAVE_LARGE_STACKS)
 	dsl_pool_t *dp = spa_get_dsl(zio->io_spa);
 
 	/* Executing in txg_sync_thread() context. */
 	if (dp && curthread == dp->dp_tx.tx_sync_thread)
 		return (B_TRUE);
 
 	/* Pool initialization outside of zio_taskq context. */
 	if (dp && spa_is_initializing(dp->dp_spa) &&
 	    !zio_taskq_member(zio, ZIO_TASKQ_ISSUE) &&
 	    !zio_taskq_member(zio, ZIO_TASKQ_ISSUE_HIGH))
 		return (B_TRUE);
 #else
 	(void) zio;
 #endif /* HAVE_LARGE_STACKS */
 
 	return (B_FALSE);
 }
 
 __attribute__((always_inline))
 static inline void
 __zio_execute(zio_t *zio)
 {
 	ASSERT3U(zio->io_queued_timestamp, >, 0);
 
 	while (zio->io_stage < ZIO_STAGE_DONE) {
 		enum zio_stage pipeline = zio->io_pipeline;
 		enum zio_stage stage = zio->io_stage;
 
 		zio->io_executor = curthread;
 
 		ASSERT(!MUTEX_HELD(&zio->io_lock));
 		ASSERT(ISP2(stage));
 		ASSERT(zio->io_stall == NULL);
 
 		do {
 			stage <<= 1;
 		} while ((stage & pipeline) == 0);
 
 		ASSERT(stage <= ZIO_STAGE_DONE);
 
 		/*
 		 * If we are in interrupt context and this pipeline stage
 		 * will grab a config lock that is held across I/O,
 		 * or may wait for an I/O that needs an interrupt thread
 		 * to complete, issue async to avoid deadlock.
 		 *
 		 * For VDEV_IO_START, we cut in line so that the io will
 		 * be sent to disk promptly.
 		 */
 		if ((stage & ZIO_BLOCKING_STAGES) && zio->io_vd == NULL &&
 		    zio_taskq_member(zio, ZIO_TASKQ_INTERRUPT)) {
 			boolean_t cut = (stage == ZIO_STAGE_VDEV_IO_START) ?
 			    zio_requeue_io_start_cut_in_line : B_FALSE;
 			zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, cut);
 			return;
 		}
 
 		/*
 		 * If the current context doesn't have large enough stacks
 		 * the zio must be issued asynchronously to prevent overflow.
 		 */
 		if (zio_execute_stack_check(zio)) {
 			boolean_t cut = (stage == ZIO_STAGE_VDEV_IO_START) ?
 			    zio_requeue_io_start_cut_in_line : B_FALSE;
 			zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, cut);
 			return;
 		}
 
 		zio->io_stage = stage;
 		zio->io_pipeline_trace |= zio->io_stage;
 
 		/*
 		 * The zio pipeline stage returns the next zio to execute
 		 * (typically the same as this one), or NULL if we should
 		 * stop.
 		 */
 		zio = zio_pipeline[highbit64(stage) - 1](zio);
 
 		if (zio == NULL)
 			return;
 	}
 }
 
 
 /*
  * ==========================================================================
  * Initiate I/O, either sync or async
  * ==========================================================================
  */
 int
 zio_wait(zio_t *zio)
 {
 	/*
 	 * Some routines, like zio_free_sync(), may return a NULL zio
 	 * to avoid the performance overhead of creating and then destroying
 	 * an unneeded zio.  For the callers' simplicity, we accept a NULL
 	 * zio and ignore it.
 	 */
 	if (zio == NULL)
 		return (0);
 
 	long timeout = MSEC_TO_TICK(zfs_deadman_ziotime_ms);
 	int error;
 
 	ASSERT3S(zio->io_stage, ==, ZIO_STAGE_OPEN);
 	ASSERT3P(zio->io_executor, ==, NULL);
 
 	zio->io_waiter = curthread;
 	ASSERT0(zio->io_queued_timestamp);
 	zio->io_queued_timestamp = gethrtime();
 
 	if (zio->io_type == ZIO_TYPE_WRITE) {
 		spa_select_allocator(zio);
 	}
 	__zio_execute(zio);
 
 	mutex_enter(&zio->io_lock);
 	while (zio->io_executor != NULL) {
 		error = cv_timedwait_io(&zio->io_cv, &zio->io_lock,
 		    ddi_get_lbolt() + timeout);
 
 		if (zfs_deadman_enabled && error == -1 &&
 		    gethrtime() - zio->io_queued_timestamp >
 		    spa_deadman_ziotime(zio->io_spa)) {
 			mutex_exit(&zio->io_lock);
 			timeout = MSEC_TO_TICK(zfs_deadman_checktime_ms);
 			zio_deadman(zio, FTAG);
 			mutex_enter(&zio->io_lock);
 		}
 	}
 	mutex_exit(&zio->io_lock);
 
 	error = zio->io_error;
 	zio_destroy(zio);
 
 	return (error);
 }
 
 void
 zio_nowait(zio_t *zio)
 {
 	/*
 	 * See comment in zio_wait().
 	 */
 	if (zio == NULL)
 		return;
 
 	ASSERT3P(zio->io_executor, ==, NULL);
 
 	if (zio->io_child_type == ZIO_CHILD_LOGICAL &&
 	    list_is_empty(&zio->io_parent_list)) {
 		zio_t *pio;
 
 		/*
 		 * This is a logical async I/O with no parent to wait for it.
 		 * We add it to the spa_async_root_zio "Godfather" I/O which
 		 * will ensure they complete prior to unloading the pool.
 		 */
 		spa_t *spa = zio->io_spa;
 		pio = spa->spa_async_zio_root[CPU_SEQID_UNSTABLE];
 
 		zio_add_child(pio, zio);
 	}
 
 	ASSERT0(zio->io_queued_timestamp);
 	zio->io_queued_timestamp = gethrtime();
 	if (zio->io_type == ZIO_TYPE_WRITE) {
 		spa_select_allocator(zio);
 	}
 	__zio_execute(zio);
 }
 
 /*
  * ==========================================================================
  * Reexecute, cancel, or suspend/resume failed I/O
  * ==========================================================================
  */
 
 static void
 zio_reexecute(void *arg)
 {
 	zio_t *pio = arg;
 	zio_t *cio, *cio_next, *gio;
 
 	ASSERT(pio->io_child_type == ZIO_CHILD_LOGICAL);
 	ASSERT(pio->io_orig_stage == ZIO_STAGE_OPEN);
 	ASSERT(pio->io_gang_leader == NULL);
 	ASSERT(pio->io_gang_tree == NULL);
 
 	mutex_enter(&pio->io_lock);
 	pio->io_flags = pio->io_orig_flags;
 	pio->io_stage = pio->io_orig_stage;
 	pio->io_pipeline = pio->io_orig_pipeline;
 	pio->io_reexecute = 0;
 	pio->io_flags |= ZIO_FLAG_REEXECUTED;
 	pio->io_pipeline_trace = 0;
 	pio->io_error = 0;
 	pio->io_state[ZIO_WAIT_READY] = (pio->io_stage >= ZIO_STAGE_READY) ||
 	    (pio->io_pipeline & ZIO_STAGE_READY) == 0;
 	pio->io_state[ZIO_WAIT_DONE] = (pio->io_stage >= ZIO_STAGE_DONE);
 	zio_link_t *zl = NULL;
 	while ((gio = zio_walk_parents(pio, &zl)) != NULL) {
 		for (int w = 0; w < ZIO_WAIT_TYPES; w++) {
 			gio->io_children[pio->io_child_type][w] +=
 			    !pio->io_state[w];
 		}
 	}
 	for (int c = 0; c < ZIO_CHILD_TYPES; c++)
 		pio->io_child_error[c] = 0;
 
 	if (IO_IS_ALLOCATING(pio))
 		BP_ZERO(pio->io_bp);
 
 	/*
 	 * As we reexecute pio's children, new children could be created.
 	 * New children go to the head of pio's io_child_list, however,
 	 * so we will (correctly) not reexecute them.  The key is that
 	 * the remainder of pio's io_child_list, from 'cio_next' onward,
 	 * cannot be affected by any side effects of reexecuting 'cio'.
 	 */
 	zl = NULL;
 	for (cio = zio_walk_children(pio, &zl); cio != NULL; cio = cio_next) {
 		cio_next = zio_walk_children(pio, &zl);
 		mutex_exit(&pio->io_lock);
 		zio_reexecute(cio);
 		mutex_enter(&pio->io_lock);
 	}
 	mutex_exit(&pio->io_lock);
 
 	/*
 	 * Now that all children have been reexecuted, execute the parent.
 	 * We don't reexecute "The Godfather" I/O here as it's the
 	 * responsibility of the caller to wait on it.
 	 */
 	if (!(pio->io_flags & ZIO_FLAG_GODFATHER)) {
 		pio->io_queued_timestamp = gethrtime();
 		__zio_execute(pio);
 	}
 }
 
 void
 zio_suspend(spa_t *spa, zio_t *zio, zio_suspend_reason_t reason)
 {
 	if (spa_get_failmode(spa) == ZIO_FAILURE_MODE_PANIC)
 		fm_panic("Pool '%s' has encountered an uncorrectable I/O "
 		    "failure and the failure mode property for this pool "
 		    "is set to panic.", spa_name(spa));
 
 	if (reason != ZIO_SUSPEND_MMP) {
 		cmn_err(CE_WARN, "Pool '%s' has encountered an uncorrectable "
 		    "I/O failure and has been suspended.", spa_name(spa));
 	}
 
 	(void) zfs_ereport_post(FM_EREPORT_ZFS_IO_FAILURE, spa, NULL,
 	    NULL, NULL, 0);
 
 	mutex_enter(&spa->spa_suspend_lock);
 
 	if (spa->spa_suspend_zio_root == NULL)
 		spa->spa_suspend_zio_root = zio_root(spa, NULL, NULL,
 		    ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE |
 		    ZIO_FLAG_GODFATHER);
 
 	spa->spa_suspended = reason;
 
 	if (zio != NULL) {
 		ASSERT(!(zio->io_flags & ZIO_FLAG_GODFATHER));
 		ASSERT(zio != spa->spa_suspend_zio_root);
 		ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
 		ASSERT(zio_unique_parent(zio) == NULL);
 		ASSERT(zio->io_stage == ZIO_STAGE_DONE);
 		zio_add_child(spa->spa_suspend_zio_root, zio);
 	}
 
 	mutex_exit(&spa->spa_suspend_lock);
 }
 
 int
 zio_resume(spa_t *spa)
 {
 	zio_t *pio;
 
 	/*
 	 * Reexecute all previously suspended i/o.
 	 */
 	mutex_enter(&spa->spa_suspend_lock);
 	if (spa->spa_suspended != ZIO_SUSPEND_NONE)
 		cmn_err(CE_WARN, "Pool '%s' was suspended and is being "
 		    "resumed. Failed I/O will be retried.",
 		    spa_name(spa));
 	spa->spa_suspended = ZIO_SUSPEND_NONE;
 	cv_broadcast(&spa->spa_suspend_cv);
 	pio = spa->spa_suspend_zio_root;
 	spa->spa_suspend_zio_root = NULL;
 	mutex_exit(&spa->spa_suspend_lock);
 
 	if (pio == NULL)
 		return (0);
 
 	zio_reexecute(pio);
 	return (zio_wait(pio));
 }
 
 void
 zio_resume_wait(spa_t *spa)
 {
 	mutex_enter(&spa->spa_suspend_lock);
 	while (spa_suspended(spa))
 		cv_wait(&spa->spa_suspend_cv, &spa->spa_suspend_lock);
 	mutex_exit(&spa->spa_suspend_lock);
 }
 
 /*
  * ==========================================================================
  * Gang blocks.
  *
  * A gang block is a collection of small blocks that looks to the DMU
  * like one large block.  When zio_dva_allocate() cannot find a block
  * of the requested size, due to either severe fragmentation or the pool
  * being nearly full, it calls zio_write_gang_block() to construct the
  * block from smaller fragments.
  *
  * A gang block consists of a gang header (zio_gbh_phys_t) and up to
  * three (SPA_GBH_NBLKPTRS) gang members.  The gang header is just like
  * an indirect block: it's an array of block pointers.  It consumes
  * only one sector and hence is allocatable regardless of fragmentation.
  * The gang header's bps point to its gang members, which hold the data.
  *
  * Gang blocks are self-checksumming, using the bp's <vdev, offset, txg>
  * as the verifier to ensure uniqueness of the SHA256 checksum.
  * Critically, the gang block bp's blk_cksum is the checksum of the data,
  * not the gang header.  This ensures that data block signatures (needed for
  * deduplication) are independent of how the block is physically stored.
  *
  * Gang blocks can be nested: a gang member may itself be a gang block.
  * Thus every gang block is a tree in which root and all interior nodes are
  * gang headers, and the leaves are normal blocks that contain user data.
  * The root of the gang tree is called the gang leader.
  *
  * To perform any operation (read, rewrite, free, claim) on a gang block,
  * zio_gang_assemble() first assembles the gang tree (minus data leaves)
  * in the io_gang_tree field of the original logical i/o by recursively
  * reading the gang leader and all gang headers below it.  This yields
  * an in-core tree containing the contents of every gang header and the
  * bps for every constituent of the gang block.
  *
  * With the gang tree now assembled, zio_gang_issue() just walks the gang tree
  * and invokes a callback on each bp.  To free a gang block, zio_gang_issue()
  * calls zio_free_gang() -- a trivial wrapper around zio_free() -- for each bp.
  * zio_claim_gang() provides a similarly trivial wrapper for zio_claim().
  * zio_read_gang() is a wrapper around zio_read() that omits reading gang
  * headers, since we already have those in io_gang_tree.  zio_rewrite_gang()
  * performs a zio_rewrite() of the data or, for gang headers, a zio_rewrite()
  * of the gang header plus zio_checksum_compute() of the data to update the
  * gang header's blk_cksum as described above.
  *
  * The two-phase assemble/issue model solves the problem of partial failure --
  * what if you'd freed part of a gang block but then couldn't read the
  * gang header for another part?  Assembling the entire gang tree first
  * ensures that all the necessary gang header I/O has succeeded before
  * starting the actual work of free, claim, or write.  Once the gang tree
  * is assembled, free and claim are in-memory operations that cannot fail.
  *
  * In the event that a gang write fails, zio_dva_unallocate() walks the
  * gang tree to immediately free (i.e. insert back into the space map)
  * everything we've allocated.  This ensures that we don't get ENOSPC
  * errors during repeated suspend/resume cycles due to a flaky device.
  *
  * Gang rewrites only happen during sync-to-convergence.  If we can't assemble
  * the gang tree, we won't modify the block, so we can safely defer the free
  * (knowing that the block is still intact).  If we *can* assemble the gang
  * tree, then even if some of the rewrites fail, zio_dva_unallocate() will free
  * each constituent bp and we can allocate a new block on the next sync pass.
  *
  * In all cases, the gang tree allows complete recovery from partial failure.
  * ==========================================================================
  */
 
 static void
 zio_gang_issue_func_done(zio_t *zio)
 {
 	abd_free(zio->io_abd);
 }
 
 static zio_t *
 zio_read_gang(zio_t *pio, blkptr_t *bp, zio_gang_node_t *gn, abd_t *data,
     uint64_t offset)
 {
 	if (gn != NULL)
 		return (pio);
 
 	return (zio_read(pio, pio->io_spa, bp, abd_get_offset(data, offset),
 	    BP_GET_PSIZE(bp), zio_gang_issue_func_done,
 	    NULL, pio->io_priority, ZIO_GANG_CHILD_FLAGS(pio),
 	    &pio->io_bookmark));
 }
 
 static zio_t *
 zio_rewrite_gang(zio_t *pio, blkptr_t *bp, zio_gang_node_t *gn, abd_t *data,
     uint64_t offset)
 {
 	zio_t *zio;
 
 	if (gn != NULL) {
 		abd_t *gbh_abd =
 		    abd_get_from_buf(gn->gn_gbh, SPA_GANGBLOCKSIZE);
 		zio = zio_rewrite(pio, pio->io_spa, pio->io_txg, bp,
 		    gbh_abd, SPA_GANGBLOCKSIZE, zio_gang_issue_func_done, NULL,
 		    pio->io_priority, ZIO_GANG_CHILD_FLAGS(pio),
 		    &pio->io_bookmark);
 		/*
 		 * As we rewrite each gang header, the pipeline will compute
 		 * a new gang block header checksum for it; but no one will
 		 * compute a new data checksum, so we do that here.  The one
 		 * exception is the gang leader: the pipeline already computed
 		 * its data checksum because that stage precedes gang assembly.
 		 * (Presently, nothing actually uses interior data checksums;
 		 * this is just good hygiene.)
 		 */
 		if (gn != pio->io_gang_leader->io_gang_tree) {
 			abd_t *buf = abd_get_offset(data, offset);
 
 			zio_checksum_compute(zio, BP_GET_CHECKSUM(bp),
 			    buf, BP_GET_PSIZE(bp));
 
 			abd_free(buf);
 		}
 		/*
 		 * If we are here to damage data for testing purposes,
 		 * leave the GBH alone so that we can detect the damage.
 		 */
 		if (pio->io_gang_leader->io_flags & ZIO_FLAG_INDUCE_DAMAGE)
 			zio->io_pipeline &= ~ZIO_VDEV_IO_STAGES;
 	} else {
 		zio = zio_rewrite(pio, pio->io_spa, pio->io_txg, bp,
 		    abd_get_offset(data, offset), BP_GET_PSIZE(bp),
 		    zio_gang_issue_func_done, NULL, pio->io_priority,
 		    ZIO_GANG_CHILD_FLAGS(pio), &pio->io_bookmark);
 	}
 
 	return (zio);
 }
 
 static zio_t *
 zio_free_gang(zio_t *pio, blkptr_t *bp, zio_gang_node_t *gn, abd_t *data,
     uint64_t offset)
 {
 	(void) gn, (void) data, (void) offset;
 
 	zio_t *zio = zio_free_sync(pio, pio->io_spa, pio->io_txg, bp,
 	    ZIO_GANG_CHILD_FLAGS(pio));
 	if (zio == NULL) {
 		zio = zio_null(pio, pio->io_spa,
 		    NULL, NULL, NULL, ZIO_GANG_CHILD_FLAGS(pio));
 	}
 	return (zio);
 }
 
 static zio_t *
 zio_claim_gang(zio_t *pio, blkptr_t *bp, zio_gang_node_t *gn, abd_t *data,
     uint64_t offset)
 {
 	(void) gn, (void) data, (void) offset;
 	return (zio_claim(pio, pio->io_spa, pio->io_txg, bp,
 	    NULL, NULL, ZIO_GANG_CHILD_FLAGS(pio)));
 }
 
 static zio_gang_issue_func_t *zio_gang_issue_func[ZIO_TYPES] = {
 	NULL,
 	zio_read_gang,
 	zio_rewrite_gang,
 	zio_free_gang,
 	zio_claim_gang,
 	NULL
 };
 
 static void zio_gang_tree_assemble_done(zio_t *zio);
 
 static zio_gang_node_t *
 zio_gang_node_alloc(zio_gang_node_t **gnpp)
 {
 	zio_gang_node_t *gn;
 
 	ASSERT(*gnpp == NULL);
 
 	gn = kmem_zalloc(sizeof (*gn), KM_SLEEP);
 	gn->gn_gbh = zio_buf_alloc(SPA_GANGBLOCKSIZE);
 	*gnpp = gn;
 
 	return (gn);
 }
 
 static void
 zio_gang_node_free(zio_gang_node_t **gnpp)
 {
 	zio_gang_node_t *gn = *gnpp;
 
 	for (int g = 0; g < SPA_GBH_NBLKPTRS; g++)
 		ASSERT(gn->gn_child[g] == NULL);
 
 	zio_buf_free(gn->gn_gbh, SPA_GANGBLOCKSIZE);
 	kmem_free(gn, sizeof (*gn));
 	*gnpp = NULL;
 }
 
 static void
 zio_gang_tree_free(zio_gang_node_t **gnpp)
 {
 	zio_gang_node_t *gn = *gnpp;
 
 	if (gn == NULL)
 		return;
 
 	for (int g = 0; g < SPA_GBH_NBLKPTRS; g++)
 		zio_gang_tree_free(&gn->gn_child[g]);
 
 	zio_gang_node_free(gnpp);
 }
 
 static void
 zio_gang_tree_assemble(zio_t *gio, blkptr_t *bp, zio_gang_node_t **gnpp)
 {
 	zio_gang_node_t *gn = zio_gang_node_alloc(gnpp);
 	abd_t *gbh_abd = abd_get_from_buf(gn->gn_gbh, SPA_GANGBLOCKSIZE);
 
 	ASSERT(gio->io_gang_leader == gio);
 	ASSERT(BP_IS_GANG(bp));
 
 	zio_nowait(zio_read(gio, gio->io_spa, bp, gbh_abd, SPA_GANGBLOCKSIZE,
 	    zio_gang_tree_assemble_done, gn, gio->io_priority,
 	    ZIO_GANG_CHILD_FLAGS(gio), &gio->io_bookmark));
 }
 
 static void
 zio_gang_tree_assemble_done(zio_t *zio)
 {
 	zio_t *gio = zio->io_gang_leader;
 	zio_gang_node_t *gn = zio->io_private;
 	blkptr_t *bp = zio->io_bp;
 
 	ASSERT(gio == zio_unique_parent(zio));
 	ASSERT(list_is_empty(&zio->io_child_list));
 
 	if (zio->io_error)
 		return;
 
 	/* this ABD was created from a linear buf in zio_gang_tree_assemble */
 	if (BP_SHOULD_BYTESWAP(bp))
 		byteswap_uint64_array(abd_to_buf(zio->io_abd), zio->io_size);
 
 	ASSERT3P(abd_to_buf(zio->io_abd), ==, gn->gn_gbh);
 	ASSERT(zio->io_size == SPA_GANGBLOCKSIZE);
 	ASSERT(gn->gn_gbh->zg_tail.zec_magic == ZEC_MAGIC);
 
 	abd_free(zio->io_abd);
 
 	for (int g = 0; g < SPA_GBH_NBLKPTRS; g++) {
 		blkptr_t *gbp = &gn->gn_gbh->zg_blkptr[g];
 		if (!BP_IS_GANG(gbp))
 			continue;
 		zio_gang_tree_assemble(gio, gbp, &gn->gn_child[g]);
 	}
 }
 
 static void
 zio_gang_tree_issue(zio_t *pio, zio_gang_node_t *gn, blkptr_t *bp, abd_t *data,
     uint64_t offset)
 {
 	zio_t *gio = pio->io_gang_leader;
 	zio_t *zio;
 
 	ASSERT(BP_IS_GANG(bp) == !!gn);
 	ASSERT(BP_GET_CHECKSUM(bp) == BP_GET_CHECKSUM(gio->io_bp));
 	ASSERT(BP_GET_LSIZE(bp) == BP_GET_PSIZE(bp) || gn == gio->io_gang_tree);
 
 	/*
 	 * If you're a gang header, your data is in gn->gn_gbh.
 	 * If you're a gang member, your data is in 'data' and gn == NULL.
 	 */
 	zio = zio_gang_issue_func[gio->io_type](pio, bp, gn, data, offset);
 
 	if (gn != NULL) {
 		ASSERT(gn->gn_gbh->zg_tail.zec_magic == ZEC_MAGIC);
 
 		for (int g = 0; g < SPA_GBH_NBLKPTRS; g++) {
 			blkptr_t *gbp = &gn->gn_gbh->zg_blkptr[g];
 			if (BP_IS_HOLE(gbp))
 				continue;
 			zio_gang_tree_issue(zio, gn->gn_child[g], gbp, data,
 			    offset);
 			offset += BP_GET_PSIZE(gbp);
 		}
 	}
 
 	if (gn == gio->io_gang_tree)
 		ASSERT3U(gio->io_size, ==, offset);
 
 	if (zio != pio)
 		zio_nowait(zio);
 }
 
 static zio_t *
 zio_gang_assemble(zio_t *zio)
 {
 	blkptr_t *bp = zio->io_bp;
 
 	ASSERT(BP_IS_GANG(bp) && zio->io_gang_leader == NULL);
 	ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
 
 	zio->io_gang_leader = zio;
 
 	zio_gang_tree_assemble(zio, bp, &zio->io_gang_tree);
 
 	return (zio);
 }
 
 static zio_t *
 zio_gang_issue(zio_t *zio)
 {
 	blkptr_t *bp = zio->io_bp;
 
 	if (zio_wait_for_children(zio, ZIO_CHILD_GANG_BIT, ZIO_WAIT_DONE)) {
 		return (NULL);
 	}
 
 	ASSERT(BP_IS_GANG(bp) && zio->io_gang_leader == zio);
 	ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
 
 	if (zio->io_child_error[ZIO_CHILD_GANG] == 0)
 		zio_gang_tree_issue(zio, zio->io_gang_tree, bp, zio->io_abd,
 		    0);
 	else
 		zio_gang_tree_free(&zio->io_gang_tree);
 
 	zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
 
 	return (zio);
 }
 
 static void
 zio_gang_inherit_allocator(zio_t *pio, zio_t *cio)
 {
 	cio->io_allocator = pio->io_allocator;
 }
 
 static void
 zio_write_gang_member_ready(zio_t *zio)
 {
 	zio_t *pio = zio_unique_parent(zio);
 	dva_t *cdva = zio->io_bp->blk_dva;
 	dva_t *pdva = pio->io_bp->blk_dva;
 	uint64_t asize;
 	zio_t *gio __maybe_unused = zio->io_gang_leader;
 
 	if (BP_IS_HOLE(zio->io_bp))
 		return;
 
 	ASSERT(BP_IS_HOLE(&zio->io_bp_orig));
 
 	ASSERT(zio->io_child_type == ZIO_CHILD_GANG);
 	ASSERT3U(zio->io_prop.zp_copies, ==, gio->io_prop.zp_copies);
 	ASSERT3U(zio->io_prop.zp_copies, <=, BP_GET_NDVAS(zio->io_bp));
 	ASSERT3U(pio->io_prop.zp_copies, <=, BP_GET_NDVAS(pio->io_bp));
 	VERIFY3U(BP_GET_NDVAS(zio->io_bp), <=, BP_GET_NDVAS(pio->io_bp));
 
 	mutex_enter(&pio->io_lock);
 	for (int d = 0; d < BP_GET_NDVAS(zio->io_bp); d++) {
 		ASSERT(DVA_GET_GANG(&pdva[d]));
 		asize = DVA_GET_ASIZE(&pdva[d]);
 		asize += DVA_GET_ASIZE(&cdva[d]);
 		DVA_SET_ASIZE(&pdva[d], asize);
 	}
 	mutex_exit(&pio->io_lock);
 }
 
 static void
 zio_write_gang_done(zio_t *zio)
 {
 	/*
 	 * The io_abd field will be NULL for a zio with no data.  The io_flags
 	 * will initially have the ZIO_FLAG_NODATA bit flag set, but we can't
 	 * check for it here as it is cleared in zio_ready.
 	 */
 	if (zio->io_abd != NULL)
 		abd_free(zio->io_abd);
 }
 
 static zio_t *
 zio_write_gang_block(zio_t *pio, metaslab_class_t *mc)
 {
 	spa_t *spa = pio->io_spa;
 	blkptr_t *bp = pio->io_bp;
 	zio_t *gio = pio->io_gang_leader;
 	zio_t *zio;
 	zio_gang_node_t *gn, **gnpp;
 	zio_gbh_phys_t *gbh;
 	abd_t *gbh_abd;
 	uint64_t txg = pio->io_txg;
 	uint64_t resid = pio->io_size;
 	uint64_t lsize;
 	int copies = gio->io_prop.zp_copies;
 	zio_prop_t zp;
 	int error;
 	boolean_t has_data = !(pio->io_flags & ZIO_FLAG_NODATA);
 
 	/*
 	 * If one copy was requested, store 2 copies of the GBH, so that we
 	 * can still traverse all the data (e.g. to free or scrub) even if a
 	 * block is damaged.  Note that we can't store 3 copies of the GBH in
 	 * all cases, e.g. with encryption, which uses DVA[2] for the IV+salt.
 	 */
 	int gbh_copies = copies;
 	if (gbh_copies == 1) {
 		gbh_copies = MIN(2, spa_max_replication(spa));
 	}
 
 	ASSERT(ZIO_HAS_ALLOCATOR(pio));
 	int flags = METASLAB_HINTBP_FAVOR | METASLAB_GANG_HEADER;
 	if (pio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
 		ASSERT(pio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
 		ASSERT(has_data);
 
 		flags |= METASLAB_ASYNC_ALLOC;
 		VERIFY(zfs_refcount_held(&mc->mc_allocator[pio->io_allocator].
 		    mca_alloc_slots, pio));
 
 		/*
 		 * The logical zio has already placed a reservation for
 		 * 'copies' allocation slots but gang blocks may require
 		 * additional copies. These additional copies
 		 * (i.e. gbh_copies - copies) are guaranteed to succeed
 		 * since metaslab_class_throttle_reserve() always allows
 		 * additional reservations for gang blocks.
 		 */
 		VERIFY(metaslab_class_throttle_reserve(mc, gbh_copies - copies,
 		    pio->io_allocator, pio, flags));
 	}
 
 	error = metaslab_alloc(spa, mc, SPA_GANGBLOCKSIZE,
 	    bp, gbh_copies, txg, pio == gio ? NULL : gio->io_bp, flags,
 	    &pio->io_alloc_list, pio, pio->io_allocator);
 	if (error) {
 		if (pio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
 			ASSERT(pio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
 			ASSERT(has_data);
 
 			/*
 			 * If we failed to allocate the gang block header then
 			 * we remove any additional allocation reservations that
 			 * we placed here. The original reservation will
 			 * be removed when the logical I/O goes to the ready
 			 * stage.
 			 */
 			metaslab_class_throttle_unreserve(mc,
 			    gbh_copies - copies, pio->io_allocator, pio);
 		}
 
 		pio->io_error = error;
 		return (pio);
 	}
 
 	if (pio == gio) {
 		gnpp = &gio->io_gang_tree;
 	} else {
 		gnpp = pio->io_private;
 		ASSERT(pio->io_ready == zio_write_gang_member_ready);
 	}
 
 	gn = zio_gang_node_alloc(gnpp);
 	gbh = gn->gn_gbh;
 	memset(gbh, 0, SPA_GANGBLOCKSIZE);
 	gbh_abd = abd_get_from_buf(gbh, SPA_GANGBLOCKSIZE);
 
 	/*
 	 * Create the gang header.
 	 */
 	zio = zio_rewrite(pio, spa, txg, bp, gbh_abd, SPA_GANGBLOCKSIZE,
 	    zio_write_gang_done, NULL, pio->io_priority,
 	    ZIO_GANG_CHILD_FLAGS(pio), &pio->io_bookmark);
 
 	zio_gang_inherit_allocator(pio, zio);
 
 	/*
 	 * Create and nowait the gang children.
 	 */
 	for (int g = 0; resid != 0; resid -= lsize, g++) {
 		lsize = P2ROUNDUP(resid / (SPA_GBH_NBLKPTRS - g),
 		    SPA_MINBLOCKSIZE);
 		ASSERT(lsize >= SPA_MINBLOCKSIZE && lsize <= resid);
 
 		zp.zp_checksum = gio->io_prop.zp_checksum;
 		zp.zp_compress = ZIO_COMPRESS_OFF;
 		zp.zp_complevel = gio->io_prop.zp_complevel;
 		zp.zp_type = zp.zp_storage_type = DMU_OT_NONE;
 		zp.zp_level = 0;
 		zp.zp_copies = gio->io_prop.zp_copies;
 		zp.zp_dedup = B_FALSE;
 		zp.zp_dedup_verify = B_FALSE;
 		zp.zp_nopwrite = B_FALSE;
 		zp.zp_encrypt = gio->io_prop.zp_encrypt;
 		zp.zp_byteorder = gio->io_prop.zp_byteorder;
 		zp.zp_direct_write = B_FALSE;
 		memset(zp.zp_salt, 0, ZIO_DATA_SALT_LEN);
 		memset(zp.zp_iv, 0, ZIO_DATA_IV_LEN);
 		memset(zp.zp_mac, 0, ZIO_DATA_MAC_LEN);
 
 		zio_t *cio = zio_write(zio, spa, txg, &gbh->zg_blkptr[g],
 		    has_data ? abd_get_offset(pio->io_abd, pio->io_size -
 		    resid) : NULL, lsize, lsize, &zp,
 		    zio_write_gang_member_ready, NULL,
 		    zio_write_gang_done, &gn->gn_child[g], pio->io_priority,
 		    ZIO_GANG_CHILD_FLAGS(pio), &pio->io_bookmark);
 
 		zio_gang_inherit_allocator(zio, cio);
 
 		if (pio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
 			ASSERT(pio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
 			ASSERT(has_data);
 
 			/*
 			 * Gang children won't throttle but we should
 			 * account for their work, so reserve an allocation
 			 * slot for them here.
 			 */
 			VERIFY(metaslab_class_throttle_reserve(mc,
 			    zp.zp_copies, cio->io_allocator, cio, flags));
 		}
 		zio_nowait(cio);
 	}
 
 	/*
 	 * Set pio's pipeline to just wait for zio to finish.
 	 */
 	pio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
 
 	zio_nowait(zio);
 
 	return (pio);
 }
 
 /*
  * The zio_nop_write stage in the pipeline determines if allocating a
  * new bp is necessary.  The nopwrite feature can handle writes in
  * either syncing or open context (i.e. zil writes) and as a result is
  * mutually exclusive with dedup.
  *
  * By leveraging a cryptographically secure checksum, such as SHA256, we
  * can compare the checksums of the new data and the old to determine if
  * allocating a new block is required.  Note that our requirements for
  * cryptographic strength are fairly weak: there can't be any accidental
  * hash collisions, but we don't need to be secure against intentional
  * (malicious) collisions.  To trigger a nopwrite, you have to be able
  * to write the file to begin with, and triggering an incorrect (hash
  * collision) nopwrite is no worse than simply writing to the file.
  * That said, there are no known attacks against the checksum algorithms
  * used for nopwrite, assuming that the salt and the checksums
  * themselves remain secret.
  */
 static zio_t *
 zio_nop_write(zio_t *zio)
 {
 	blkptr_t *bp = zio->io_bp;
 	blkptr_t *bp_orig = &zio->io_bp_orig;
 	zio_prop_t *zp = &zio->io_prop;
 
 	ASSERT(BP_IS_HOLE(bp));
 	ASSERT(BP_GET_LEVEL(bp) == 0);
 	ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REWRITE));
 	ASSERT(zp->zp_nopwrite);
 	ASSERT(!zp->zp_dedup);
 	ASSERT(zio->io_bp_override == NULL);
 	ASSERT(IO_IS_ALLOCATING(zio));
 
 	/*
 	 * Check to see if the original bp and the new bp have matching
 	 * characteristics (i.e. same checksum, compression algorithms, etc).
 	 * If they don't then just continue with the pipeline which will
 	 * allocate a new bp.
 	 */
 	if (BP_IS_HOLE(bp_orig) ||
 	    !(zio_checksum_table[BP_GET_CHECKSUM(bp)].ci_flags &
 	    ZCHECKSUM_FLAG_NOPWRITE) ||
 	    BP_IS_ENCRYPTED(bp) || BP_IS_ENCRYPTED(bp_orig) ||
 	    BP_GET_CHECKSUM(bp) != BP_GET_CHECKSUM(bp_orig) ||
 	    BP_GET_COMPRESS(bp) != BP_GET_COMPRESS(bp_orig) ||
 	    BP_GET_DEDUP(bp) != BP_GET_DEDUP(bp_orig) ||
 	    zp->zp_copies != BP_GET_NDVAS(bp_orig))
 		return (zio);
 
 	/*
 	 * If the checksums match then reset the pipeline so that we
 	 * avoid allocating a new bp and issuing any I/O.
 	 */
 	if (ZIO_CHECKSUM_EQUAL(bp->blk_cksum, bp_orig->blk_cksum)) {
 		ASSERT(zio_checksum_table[zp->zp_checksum].ci_flags &
 		    ZCHECKSUM_FLAG_NOPWRITE);
 		ASSERT3U(BP_GET_PSIZE(bp), ==, BP_GET_PSIZE(bp_orig));
 		ASSERT3U(BP_GET_LSIZE(bp), ==, BP_GET_LSIZE(bp_orig));
 		ASSERT(zp->zp_compress != ZIO_COMPRESS_OFF);
 		ASSERT3U(bp->blk_prop, ==, bp_orig->blk_prop);
 
 		/*
 		 * If we're overwriting a block that is currently on an
 		 * indirect vdev, then ignore the nopwrite request and
 		 * allow a new block to be allocated on a concrete vdev.
 		 */
 		spa_config_enter(zio->io_spa, SCL_VDEV, FTAG, RW_READER);
 		for (int d = 0; d < BP_GET_NDVAS(bp_orig); d++) {
 			vdev_t *tvd = vdev_lookup_top(zio->io_spa,
 			    DVA_GET_VDEV(&bp_orig->blk_dva[d]));
 			if (tvd->vdev_ops == &vdev_indirect_ops) {
 				spa_config_exit(zio->io_spa, SCL_VDEV, FTAG);
 				return (zio);
 			}
 		}
 		spa_config_exit(zio->io_spa, SCL_VDEV, FTAG);
 
 		*bp = *bp_orig;
 		zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
 		zio->io_flags |= ZIO_FLAG_NOPWRITE;
 	}
 
 	return (zio);
 }
 
 /*
  * ==========================================================================
  * Block Reference Table
  * ==========================================================================
  */
 static zio_t *
 zio_brt_free(zio_t *zio)
 {
 	blkptr_t *bp;
 
 	bp = zio->io_bp;
 
 	if (BP_GET_LEVEL(bp) > 0 ||
 	    BP_IS_METADATA(bp) ||
 	    !brt_maybe_exists(zio->io_spa, bp)) {
 		return (zio);
 	}
 
 	if (!brt_entry_decref(zio->io_spa, bp)) {
 		/*
 		 * This isn't the last reference, so we cannot free
 		 * the data yet.
 		 */
 		zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
 	}
 
 	return (zio);
 }
 
 /*
  * ==========================================================================
  * Dedup
  * ==========================================================================
  */
 static void
 zio_ddt_child_read_done(zio_t *zio)
 {
 	blkptr_t *bp = zio->io_bp;
 	ddt_t *ddt;
 	ddt_entry_t *dde = zio->io_private;
 	zio_t *pio = zio_unique_parent(zio);
 
 	mutex_enter(&pio->io_lock);
 	ddt = ddt_select(zio->io_spa, bp);
 
 	if (zio->io_error == 0) {
 		ddt_phys_variant_t v = ddt_phys_select(ddt, dde, bp);
 		/* this phys variant doesn't need repair */
 		ddt_phys_clear(dde->dde_phys, v);
 	}
 
 	if (zio->io_error == 0 && dde->dde_io->dde_repair_abd == NULL)
 		dde->dde_io->dde_repair_abd = zio->io_abd;
 	else
 		abd_free(zio->io_abd);
 	mutex_exit(&pio->io_lock);
 }
 
 static zio_t *
 zio_ddt_read_start(zio_t *zio)
 {
 	blkptr_t *bp = zio->io_bp;
 
 	ASSERT(BP_GET_DEDUP(bp));
 	ASSERT(BP_GET_PSIZE(bp) == zio->io_size);
 	ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
 
 	if (zio->io_child_error[ZIO_CHILD_DDT]) {
 		ddt_t *ddt = ddt_select(zio->io_spa, bp);
 		ddt_entry_t *dde = ddt_repair_start(ddt, bp);
 		ddt_phys_variant_t v_self = ddt_phys_select(ddt, dde, bp);
 		ddt_univ_phys_t *ddp = dde->dde_phys;
 		blkptr_t blk;
 
 		ASSERT(zio->io_vsd == NULL);
 		zio->io_vsd = dde;
 
 		if (v_self == DDT_PHYS_NONE)
 			return (zio);
 
 		/* issue I/O for the other copies */
 		for (int p = 0; p < DDT_NPHYS(ddt); p++) {
 			ddt_phys_variant_t v = DDT_PHYS_VARIANT(ddt, p);
 
 			if (ddt_phys_birth(ddp, v) == 0 || v == v_self)
 				continue;
 
 			ddt_bp_create(ddt->ddt_checksum, &dde->dde_key,
 			    ddp, v, &blk);
 			zio_nowait(zio_read(zio, zio->io_spa, &blk,
 			    abd_alloc_for_io(zio->io_size, B_TRUE),
 			    zio->io_size, zio_ddt_child_read_done, dde,
 			    zio->io_priority, ZIO_DDT_CHILD_FLAGS(zio) |
 			    ZIO_FLAG_DONT_PROPAGATE, &zio->io_bookmark));
 		}
 		return (zio);
 	}
 
 	zio_nowait(zio_read(zio, zio->io_spa, bp,
 	    zio->io_abd, zio->io_size, NULL, NULL, zio->io_priority,
 	    ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark));
 
 	return (zio);
 }
 
 static zio_t *
 zio_ddt_read_done(zio_t *zio)
 {
 	blkptr_t *bp = zio->io_bp;
 
 	if (zio_wait_for_children(zio, ZIO_CHILD_DDT_BIT, ZIO_WAIT_DONE)) {
 		return (NULL);
 	}
 
 	ASSERT(BP_GET_DEDUP(bp));
 	ASSERT(BP_GET_PSIZE(bp) == zio->io_size);
 	ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
 
 	if (zio->io_child_error[ZIO_CHILD_DDT]) {
 		ddt_t *ddt = ddt_select(zio->io_spa, bp);
 		ddt_entry_t *dde = zio->io_vsd;
 		if (ddt == NULL) {
 			ASSERT(spa_load_state(zio->io_spa) != SPA_LOAD_NONE);
 			return (zio);
 		}
 		if (dde == NULL) {
 			zio->io_stage = ZIO_STAGE_DDT_READ_START >> 1;
 			zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_FALSE);
 			return (NULL);
 		}
 		if (dde->dde_io->dde_repair_abd != NULL) {
 			abd_copy(zio->io_abd, dde->dde_io->dde_repair_abd,
 			    zio->io_size);
 			zio->io_child_error[ZIO_CHILD_DDT] = 0;
 		}
 		ddt_repair_done(ddt, dde);
 		zio->io_vsd = NULL;
 	}
 
 	ASSERT(zio->io_vsd == NULL);
 
 	return (zio);
 }
 
 static boolean_t
 zio_ddt_collision(zio_t *zio, ddt_t *ddt, ddt_entry_t *dde)
 {
 	spa_t *spa = zio->io_spa;
 	boolean_t do_raw = !!(zio->io_flags & ZIO_FLAG_RAW);
 
 	ASSERT(!(zio->io_bp_override && do_raw));
 
 	/*
 	 * Note: we compare the original data, not the transformed data,
 	 * because when zio->io_bp is an override bp, we will not have
 	 * pushed the I/O transforms.  That's an important optimization
 	 * because otherwise we'd compress/encrypt all dmu_sync() data twice.
 	 * However, we should never get a raw, override zio so in these
 	 * cases we can compare the io_abd directly. This is useful because
 	 * it allows us to do dedup verification even if we don't have access
 	 * to the original data (for instance, if the encryption keys aren't
 	 * loaded).
 	 */
 
 	for (int p = 0; p < DDT_NPHYS(ddt); p++) {
 		if (DDT_PHYS_IS_DITTO(ddt, p))
 			continue;
 
 		if (dde->dde_io == NULL)
 			continue;
 
 		zio_t *lio = dde->dde_io->dde_lead_zio[p];
 		if (lio == NULL)
 			continue;
 
 		if (do_raw)
 			return (lio->io_size != zio->io_size ||
 			    abd_cmp(zio->io_abd, lio->io_abd) != 0);
 
 		return (lio->io_orig_size != zio->io_orig_size ||
 		    abd_cmp(zio->io_orig_abd, lio->io_orig_abd) != 0);
 	}
 
 	for (int p = 0; p < DDT_NPHYS(ddt); p++) {
 		ddt_phys_variant_t v = DDT_PHYS_VARIANT(ddt, p);
 		uint64_t phys_birth = ddt_phys_birth(dde->dde_phys, v);
 
 		if (phys_birth != 0 && do_raw) {
 			blkptr_t blk = *zio->io_bp;
 			uint64_t psize;
 			abd_t *tmpabd;
 			int error;
 
 			ddt_bp_fill(dde->dde_phys, v, &blk, phys_birth);
 			psize = BP_GET_PSIZE(&blk);
 
 			if (psize != zio->io_size)
 				return (B_TRUE);
 
 			ddt_exit(ddt);
 
 			tmpabd = abd_alloc_for_io(psize, B_TRUE);
 
 			error = zio_wait(zio_read(NULL, spa, &blk, tmpabd,
 			    psize, NULL, NULL, ZIO_PRIORITY_SYNC_READ,
 			    ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE |
 			    ZIO_FLAG_RAW, &zio->io_bookmark));
 
 			if (error == 0) {
 				if (abd_cmp(tmpabd, zio->io_abd) != 0)
 					error = SET_ERROR(ENOENT);
 			}
 
 			abd_free(tmpabd);
 			ddt_enter(ddt);
 			return (error != 0);
 		} else if (phys_birth != 0) {
 			arc_buf_t *abuf = NULL;
 			arc_flags_t aflags = ARC_FLAG_WAIT;
 			blkptr_t blk = *zio->io_bp;
 			int error;
 
 			ddt_bp_fill(dde->dde_phys, v, &blk, phys_birth);
 
 			if (BP_GET_LSIZE(&blk) != zio->io_orig_size)
 				return (B_TRUE);
 
 			ddt_exit(ddt);
 
 			error = arc_read(NULL, spa, &blk,
 			    arc_getbuf_func, &abuf, ZIO_PRIORITY_SYNC_READ,
 			    ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE,
 			    &aflags, &zio->io_bookmark);
 
 			if (error == 0) {
 				if (abd_cmp_buf(zio->io_orig_abd, abuf->b_data,
 				    zio->io_orig_size) != 0)
 					error = SET_ERROR(ENOENT);
 				arc_buf_destroy(abuf, &abuf);
 			}
 
 			ddt_enter(ddt);
 			return (error != 0);
 		}
 	}
 
 	return (B_FALSE);
 }
 
 static void
 zio_ddt_child_write_done(zio_t *zio)
 {
 	ddt_t *ddt = ddt_select(zio->io_spa, zio->io_bp);
 	ddt_entry_t *dde = zio->io_private;
 
 	zio_link_t *zl = NULL;
 	ASSERT3P(zio_walk_parents(zio, &zl), !=, NULL);
 
 	int p = DDT_PHYS_FOR_COPIES(ddt, zio->io_prop.zp_copies);
 	ddt_phys_variant_t v = DDT_PHYS_VARIANT(ddt, p);
 	ddt_univ_phys_t *ddp = dde->dde_phys;
 
 	ddt_enter(ddt);
 
 	/* we're the lead, so once we're done there's no one else outstanding */
 	if (dde->dde_io->dde_lead_zio[p] == zio)
 		dde->dde_io->dde_lead_zio[p] = NULL;
 
 	ddt_univ_phys_t *orig = &dde->dde_io->dde_orig_phys;
 
 	if (zio->io_error != 0) {
 		/*
 		 * The write failed, so we're about to abort the entire IO
 		 * chain. We need to revert the entry back to what it was at
 		 * the last time it was successfully extended.
 		 */
 		ddt_phys_copy(ddp, orig, v);
 		ddt_phys_clear(orig, v);
 
 		ddt_exit(ddt);
 		return;
 	}
 
 	/*
 	 * We've successfully added new DVAs to the entry. Clear the saved
 	 * state or, if there's still outstanding IO, remember it so we can
 	 * revert to a known good state if that IO fails.
 	 */
 	if (dde->dde_io->dde_lead_zio[p] == NULL)
 		ddt_phys_clear(orig, v);
 	else
 		ddt_phys_copy(orig, ddp, v);
 
 	/*
 	 * Add references for all dedup writes that were waiting on the
 	 * physical one, skipping any other physical writes that are waiting.
 	 */
 	zio_t *pio;
 	zl = NULL;
 	while ((pio = zio_walk_parents(zio, &zl)) != NULL) {
 		if (!(pio->io_flags & ZIO_FLAG_DDT_CHILD))
 			ddt_phys_addref(ddp, v);
 	}
 
 	ddt_exit(ddt);
 }
 
 static void
 zio_ddt_child_write_ready(zio_t *zio)
 {
 	ddt_t *ddt = ddt_select(zio->io_spa, zio->io_bp);
 	ddt_entry_t *dde = zio->io_private;
 
 	zio_link_t *zl = NULL;
 	ASSERT3P(zio_walk_parents(zio, &zl), !=, NULL);
 
 	int p = DDT_PHYS_FOR_COPIES(ddt, zio->io_prop.zp_copies);
 	ddt_phys_variant_t v = DDT_PHYS_VARIANT(ddt, p);
 
 	if (zio->io_error != 0)
 		return;
 
 	ddt_enter(ddt);
 
 	ddt_phys_extend(dde->dde_phys, v, zio->io_bp);
 
 	zio_t *pio;
 	zl = NULL;
 	while ((pio = zio_walk_parents(zio, &zl)) != NULL) {
 		if (!(pio->io_flags & ZIO_FLAG_DDT_CHILD))
 			ddt_bp_fill(dde->dde_phys, v, pio->io_bp, zio->io_txg);
 	}
 
 	ddt_exit(ddt);
 }
 
 static zio_t *
 zio_ddt_write(zio_t *zio)
 {
 	spa_t *spa = zio->io_spa;
 	blkptr_t *bp = zio->io_bp;
 	uint64_t txg = zio->io_txg;
 	zio_prop_t *zp = &zio->io_prop;
 	ddt_t *ddt = ddt_select(spa, bp);
 	ddt_entry_t *dde;
 
 	ASSERT(BP_GET_DEDUP(bp));
 	ASSERT(BP_GET_CHECKSUM(bp) == zp->zp_checksum);
 	ASSERT(BP_IS_HOLE(bp) || zio->io_bp_override);
 	ASSERT(!(zio->io_bp_override && (zio->io_flags & ZIO_FLAG_RAW)));
 	/*
 	 * Deduplication will not take place for Direct I/O writes. The
 	 * ddt_tree will be emptied in syncing context. Direct I/O writes take
 	 * place in the open-context. Direct I/O write can not attempt to
 	 * modify the ddt_tree while issuing out a write.
 	 */
 	ASSERT3B(zio->io_prop.zp_direct_write, ==, B_FALSE);
 
 	ddt_enter(ddt);
 	dde = ddt_lookup(ddt, bp);
 	if (dde == NULL) {
 		/* DDT size is over its quota so no new entries */
 		zp->zp_dedup = B_FALSE;
 		BP_SET_DEDUP(bp, B_FALSE);
 		if (zio->io_bp_override == NULL)
 			zio->io_pipeline = ZIO_WRITE_PIPELINE;
 		ddt_exit(ddt);
 		return (zio);
 	}
 
 	if (zp->zp_dedup_verify && zio_ddt_collision(zio, ddt, dde)) {
 		/*
 		 * If we're using a weak checksum, upgrade to a strong checksum
 		 * and try again.  If we're already using a strong checksum,
 		 * we can't resolve it, so just convert to an ordinary write.
 		 * (And automatically e-mail a paper to Nature?)
 		 */
 		if (!(zio_checksum_table[zp->zp_checksum].ci_flags &
 		    ZCHECKSUM_FLAG_DEDUP)) {
 			zp->zp_checksum = spa_dedup_checksum(spa);
 			zio_pop_transforms(zio);
 			zio->io_stage = ZIO_STAGE_OPEN;
 			BP_ZERO(bp);
 		} else {
 			zp->zp_dedup = B_FALSE;
 			BP_SET_DEDUP(bp, B_FALSE);
 		}
 		ASSERT(!BP_GET_DEDUP(bp));
 		zio->io_pipeline = ZIO_WRITE_PIPELINE;
 		ddt_exit(ddt);
 		return (zio);
 	}
 
 	int p = DDT_PHYS_FOR_COPIES(ddt, zp->zp_copies);
 	ddt_phys_variant_t v = DDT_PHYS_VARIANT(ddt, p);
 	ddt_univ_phys_t *ddp = dde->dde_phys;
 
 	/*
 	 * In the common cases, at this point we have a regular BP with no
 	 * allocated DVAs, and the corresponding DDT entry for its checksum.
 	 * Our goal is to fill the BP with enough DVAs to satisfy its copies=
 	 * requirement.
 	 *
 	 * One of three things needs to happen to fulfill this:
 	 *
 	 * - if the DDT entry has enough DVAs to satisfy the BP, we just copy
 	 *   them out of the entry and return;
 	 *
 	 * - if the DDT entry has no DVAs (ie its brand new), then we have to
 	 *   issue the write as normal so that DVAs can be allocated and the
 	 *   data land on disk. We then copy the DVAs into the DDT entry on
 	 *   return.
 	 *
 	 * - if the DDT entry has some DVAs, but too few, we have to issue the
 	 *   write, adjusted to have allocate fewer copies. When it returns, we
 	 *   add the new DVAs to the DDT entry, and update the BP to have the
 	 *   full amount it originally requested.
 	 *
 	 * In all cases, if there's already a writing IO in flight, we need to
 	 * defer the action until after the write is done. If our action is to
 	 * write, we need to adjust our request for additional DVAs to match
 	 * what will be in the DDT entry after it completes. In this way every
 	 * IO can be guaranteed to recieve enough DVAs simply by joining the
 	 * end of the chain and letting the sequence play out.
 	 */
 
 	/*
 	 * Number of DVAs in the DDT entry. If the BP is encrypted we ignore
 	 * the third one as normal.
 	 */
 	int have_dvas = ddt_phys_dva_count(ddp, v, BP_IS_ENCRYPTED(bp));
 	IMPLY(have_dvas == 0, ddt_phys_birth(ddp, v) == 0);
 
 	/* Number of DVAs requested bya the IO. */
 	uint8_t need_dvas = zp->zp_copies;
 
 	/*
 	 * What we do next depends on whether or not there's IO outstanding that
 	 * will update this entry.
 	 */
 	if (dde->dde_io == NULL || dde->dde_io->dde_lead_zio[p] == NULL) {
 		/*
 		 * No IO outstanding, so we only need to worry about ourselves.
 		 */
 
 		/*
 		 * Override BPs bring their own DVAs and their own problems.
 		 */
 		if (zio->io_bp_override) {
 			/*
 			 * For a brand-new entry, all the work has been done
 			 * for us, and we can just fill it out from the provided
 			 * block and leave.
 			 */
 			if (have_dvas == 0) {
 				ASSERT(BP_GET_LOGICAL_BIRTH(bp) == txg);
 				ASSERT(BP_EQUAL(bp, zio->io_bp_override));
 				ddt_phys_extend(ddp, v, bp);
 				ddt_phys_addref(ddp, v);
 				ddt_exit(ddt);
 				return (zio);
 			}
 
 			/*
 			 * If we already have this entry, then we want to treat
 			 * it like a regular write. To do this we just wipe
 			 * them out and proceed like a regular write.
 			 *
 			 * Even if there are some DVAs in the entry, we still
 			 * have to clear them out. We can't use them to fill
 			 * out the dedup entry, as they are all referenced
 			 * together by a bp already on disk, and will be freed
 			 * as a group.
 			 */
 			BP_ZERO_DVAS(bp);
 			BP_SET_BIRTH(bp, 0, 0);
 		}
 
 		/*
 		 * If there are enough DVAs in the entry to service our request,
 		 * then we can just use them as-is.
 		 */
 		if (have_dvas >= need_dvas) {
 			ddt_bp_fill(ddp, v, bp, txg);
 			ddt_phys_addref(ddp, v);
 			ddt_exit(ddt);
 			return (zio);
 		}
 
 		/*
 		 * Otherwise, we have to issue IO to fill the entry up to the
 		 * amount we need.
 		 */
 		need_dvas -= have_dvas;
 	} else {
 		/*
 		 * There's a write in-flight. If there's already enough DVAs on
 		 * the entry, then either there were already enough to start
 		 * with, or the in-flight IO is between READY and DONE, and so
 		 * has extended the entry with new DVAs. Either way, we don't
 		 * need to do anything, we can just slot in behind it.
 		 */
 
 		if (zio->io_bp_override) {
 			/*
 			 * If there's a write out, then we're soon going to
 			 * have our own copies of this block, so clear out the
 			 * override block and treat it as a regular dedup
 			 * write. See comment above.
 			 */
 			BP_ZERO_DVAS(bp);
 			BP_SET_BIRTH(bp, 0, 0);
 		}
 
 		if (have_dvas >= need_dvas) {
 			/*
 			 * A minor point: there might already be enough
 			 * committed DVAs in the entry to service our request,
 			 * but we don't know which are completed and which are
 			 * allocated but not yet written. In this case, should
 			 * the IO for the new DVAs fail, we will be on the end
 			 * of the IO chain and will also recieve an error, even
 			 * though our request could have been serviced.
 			 *
 			 * This is an extremely rare case, as it requires the
 			 * original block to be copied with a request for a
 			 * larger number of DVAs, then copied again requesting
 			 * the same (or already fulfilled) number of DVAs while
 			 * the first request is active, and then that first
 			 * request errors. In return, the logic required to
 			 * catch and handle it is complex. For now, I'm just
 			 * not going to bother with it.
 			 */
 
 			/*
 			 * We always fill the bp here as we may have arrived
 			 * after the in-flight write has passed READY, and so
 			 * missed out.
 			 */
 			ddt_bp_fill(ddp, v, bp, txg);
 			zio_add_child(zio, dde->dde_io->dde_lead_zio[p]);
 			ddt_exit(ddt);
 			return (zio);
 		}
 
 		/*
 		 * There's not enough in the entry yet, so we need to look at
 		 * the write in-flight and see how many DVAs it will have once
 		 * it completes.
 		 *
 		 * The in-flight write has potentially had its copies request
 		 * reduced (if we're filling out an existing entry), so we need
 		 * to reach in and get the original write to find out what it is
 		 * expecting.
 		 *
 		 * Note that the parent of the lead zio will always have the
 		 * highest zp_copies of any zio in the chain, because ones that
 		 * can be serviced without additional IO are always added to
 		 * the back of the chain.
 		 */
 		zio_link_t *zl = NULL;
 		zio_t *pio =
 		    zio_walk_parents(dde->dde_io->dde_lead_zio[p], &zl);
 		ASSERT(pio);
 		uint8_t parent_dvas = pio->io_prop.zp_copies;
 
 		if (parent_dvas >= need_dvas) {
 			zio_add_child(zio, dde->dde_io->dde_lead_zio[p]);
 			ddt_exit(ddt);
 			return (zio);
 		}
 
 		/*
 		 * Still not enough, so we will need to issue to get the
 		 * shortfall.
 		 */
 		need_dvas -= parent_dvas;
 	}
 
 	/*
 	 * We need to write. We will create a new write with the copies
 	 * property adjusted to match the number of DVAs we need to need to
 	 * grow the DDT entry by to satisfy the request.
 	 */
 	zio_prop_t czp = *zp;
 	czp.zp_copies = need_dvas;
 	zio_t *cio = zio_write(zio, spa, txg, bp, zio->io_orig_abd,
 	    zio->io_orig_size, zio->io_orig_size, &czp,
 	    zio_ddt_child_write_ready, NULL,
 	    zio_ddt_child_write_done, dde, zio->io_priority,
 	    ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark);
 
 	zio_push_transform(cio, zio->io_abd, zio->io_size, 0, NULL);
 
 	/*
 	 * We are the new lead zio, because our parent has the highest
 	 * zp_copies that has been requested for this entry so far.
 	 */
 	ddt_alloc_entry_io(dde);
 	if (dde->dde_io->dde_lead_zio[p] == NULL) {
 		/*
 		 * First time out, take a copy of the stable entry to revert
 		 * to if there's an error (see zio_ddt_child_write_done())
 		 */
 		ddt_phys_copy(&dde->dde_io->dde_orig_phys, dde->dde_phys, v);
 	} else {
 		/*
 		 * Make the existing chain our child, because it cannot
 		 * complete until we have.
 		 */
 		zio_add_child(cio, dde->dde_io->dde_lead_zio[p]);
 	}
 	dde->dde_io->dde_lead_zio[p] = cio;
 
 	ddt_exit(ddt);
 
 	zio_nowait(cio);
 
 	return (zio);
 }
 
 static ddt_entry_t *freedde; /* for debugging */
 
 static zio_t *
 zio_ddt_free(zio_t *zio)
 {
 	spa_t *spa = zio->io_spa;
 	blkptr_t *bp = zio->io_bp;
 	ddt_t *ddt = ddt_select(spa, bp);
 	ddt_entry_t *dde = NULL;
 
 	ASSERT(BP_GET_DEDUP(bp));
 	ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
 
 	ddt_enter(ddt);
 	freedde = dde = ddt_lookup(ddt, bp);
 	if (dde) {
 		ddt_phys_variant_t v = ddt_phys_select(ddt, dde, bp);
 		if (v != DDT_PHYS_NONE)
 			ddt_phys_decref(dde->dde_phys, v);
 	}
 	ddt_exit(ddt);
 
 	/*
 	 * When no entry was found, it must have been pruned,
 	 * so we can free it now instead of decrementing the
 	 * refcount in the DDT.
 	 */
 	if (!dde) {
 		BP_SET_DEDUP(bp, 0);
 		zio->io_pipeline |= ZIO_STAGE_DVA_FREE;
 	}
 
 	return (zio);
 }
 
 /*
  * ==========================================================================
  * Allocate and free blocks
  * ==========================================================================
  */
 
 static zio_t *
 zio_io_to_allocate(spa_t *spa, int allocator)
 {
 	zio_t *zio;
 
 	ASSERT(MUTEX_HELD(&spa->spa_allocs[allocator].spaa_lock));
 
 	zio = avl_first(&spa->spa_allocs[allocator].spaa_tree);
 	if (zio == NULL)
 		return (NULL);
 
 	ASSERT(IO_IS_ALLOCATING(zio));
 	ASSERT(ZIO_HAS_ALLOCATOR(zio));
 
 	/*
 	 * Try to place a reservation for this zio. If we're unable to
 	 * reserve then we throttle.
 	 */
 	ASSERT3U(zio->io_allocator, ==, allocator);
 	if (!metaslab_class_throttle_reserve(zio->io_metaslab_class,
 	    zio->io_prop.zp_copies, allocator, zio, 0)) {
 		return (NULL);
 	}
 
 	avl_remove(&spa->spa_allocs[allocator].spaa_tree, zio);
 	ASSERT3U(zio->io_stage, <, ZIO_STAGE_DVA_ALLOCATE);
 
 	return (zio);
 }
 
 static zio_t *
 zio_dva_throttle(zio_t *zio)
 {
 	spa_t *spa = zio->io_spa;
 	zio_t *nio;
 	metaslab_class_t *mc;
 
 	/* locate an appropriate allocation class */
 	mc = spa_preferred_class(spa, zio);
 
 	if (zio->io_priority == ZIO_PRIORITY_SYNC_WRITE ||
 	    !mc->mc_alloc_throttle_enabled ||
 	    zio->io_child_type == ZIO_CHILD_GANG ||
 	    zio->io_flags & ZIO_FLAG_NODATA) {
 		return (zio);
 	}
 
 	ASSERT(zio->io_type == ZIO_TYPE_WRITE);
 	ASSERT(ZIO_HAS_ALLOCATOR(zio));
 	ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
 	ASSERT3U(zio->io_queued_timestamp, >, 0);
 	ASSERT(zio->io_stage == ZIO_STAGE_DVA_THROTTLE);
 
 	int allocator = zio->io_allocator;
 	zio->io_metaslab_class = mc;
 	mutex_enter(&spa->spa_allocs[allocator].spaa_lock);
 	avl_add(&spa->spa_allocs[allocator].spaa_tree, zio);
 	nio = zio_io_to_allocate(spa, allocator);
 	mutex_exit(&spa->spa_allocs[allocator].spaa_lock);
 	return (nio);
 }
 
 static void
 zio_allocate_dispatch(spa_t *spa, int allocator)
 {
 	zio_t *zio;
 
 	mutex_enter(&spa->spa_allocs[allocator].spaa_lock);
 	zio = zio_io_to_allocate(spa, allocator);
 	mutex_exit(&spa->spa_allocs[allocator].spaa_lock);
 	if (zio == NULL)
 		return;
 
 	ASSERT3U(zio->io_stage, ==, ZIO_STAGE_DVA_THROTTLE);
 	ASSERT0(zio->io_error);
 	zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_TRUE);
 }
 
 static zio_t *
 zio_dva_allocate(zio_t *zio)
 {
 	spa_t *spa = zio->io_spa;
 	metaslab_class_t *mc;
 	blkptr_t *bp = zio->io_bp;
 	int error;
 	int flags = 0;
 
 	if (zio->io_gang_leader == NULL) {
 		ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
 		zio->io_gang_leader = zio;
 	}
 
 	ASSERT(BP_IS_HOLE(bp));
 	ASSERT0(BP_GET_NDVAS(bp));
 	ASSERT3U(zio->io_prop.zp_copies, >, 0);
 	ASSERT3U(zio->io_prop.zp_copies, <=, spa_max_replication(spa));
 	ASSERT3U(zio->io_size, ==, BP_GET_PSIZE(bp));
 
 	if (zio->io_flags & ZIO_FLAG_NODATA)
 		flags |= METASLAB_DONT_THROTTLE;
 	if (zio->io_flags & ZIO_FLAG_GANG_CHILD)
 		flags |= METASLAB_GANG_CHILD;
 	if (zio->io_priority == ZIO_PRIORITY_ASYNC_WRITE)
 		flags |= METASLAB_ASYNC_ALLOC;
 
 	/*
 	 * if not already chosen, locate an appropriate allocation class
 	 */
 	mc = zio->io_metaslab_class;
 	if (mc == NULL) {
 		mc = spa_preferred_class(spa, zio);
 		zio->io_metaslab_class = mc;
 	}
 
 	/*
 	 * Try allocating the block in the usual metaslab class.
 	 * If that's full, allocate it in the normal class.
 	 * If that's full, allocate as a gang block,
 	 * and if all are full, the allocation fails (which shouldn't happen).
 	 *
 	 * Note that we do not fall back on embedded slog (ZIL) space, to
 	 * preserve unfragmented slog space, which is critical for decent
 	 * sync write performance.  If a log allocation fails, we will fall
 	 * back to spa_sync() which is abysmal for performance.
 	 */
 	ASSERT(ZIO_HAS_ALLOCATOR(zio));
 	error = metaslab_alloc(spa, mc, zio->io_size, bp,
 	    zio->io_prop.zp_copies, zio->io_txg, NULL, flags,
 	    &zio->io_alloc_list, zio, zio->io_allocator);
 
 	/*
 	 * Fallback to normal class when an alloc class is full
 	 */
 	if (error == ENOSPC && mc != spa_normal_class(spa)) {
 		/*
 		 * When the dedup or special class is spilling into the  normal
 		 * class, there can still be significant space available due
 		 * to deferred frees that are in-flight.  We track the txg when
 		 * this occurred and back off adding new DDT entries for a few
 		 * txgs to allow the free blocks to be processed.
 		 */
 		if ((mc == spa_dedup_class(spa) || (spa_special_has_ddt(spa) &&
 		    mc == spa_special_class(spa))) &&
 		    spa->spa_dedup_class_full_txg != zio->io_txg) {
 			spa->spa_dedup_class_full_txg = zio->io_txg;
 			zfs_dbgmsg("%s[%d]: %s class spilling, req size %d, "
 			    "%llu allocated of %llu",
 			    spa_name(spa), (int)zio->io_txg,
 			    mc == spa_dedup_class(spa) ? "dedup" : "special",
 			    (int)zio->io_size,
 			    (u_longlong_t)metaslab_class_get_alloc(mc),
 			    (u_longlong_t)metaslab_class_get_space(mc));
 		}
 
 		/*
 		 * If throttling, transfer reservation over to normal class.
 		 * The io_allocator slot can remain the same even though we
 		 * are switching classes.
 		 */
 		if (mc->mc_alloc_throttle_enabled &&
 		    (zio->io_flags & ZIO_FLAG_IO_ALLOCATING)) {
 			metaslab_class_throttle_unreserve(mc,
 			    zio->io_prop.zp_copies, zio->io_allocator, zio);
 			zio->io_flags &= ~ZIO_FLAG_IO_ALLOCATING;
 
 			VERIFY(metaslab_class_throttle_reserve(
 			    spa_normal_class(spa),
 			    zio->io_prop.zp_copies, zio->io_allocator, zio,
 			    flags | METASLAB_MUST_RESERVE));
 		}
 		zio->io_metaslab_class = mc = spa_normal_class(spa);
 		if (zfs_flags & ZFS_DEBUG_METASLAB_ALLOC) {
 			zfs_dbgmsg("%s: metaslab allocation failure, "
 			    "trying normal class: zio %px, size %llu, error %d",
 			    spa_name(spa), zio, (u_longlong_t)zio->io_size,
 			    error);
 		}
 
 		error = metaslab_alloc(spa, mc, zio->io_size, bp,
 		    zio->io_prop.zp_copies, zio->io_txg, NULL, flags,
 		    &zio->io_alloc_list, zio, zio->io_allocator);
 	}
 
 	if (error == ENOSPC && zio->io_size > SPA_MINBLOCKSIZE) {
 		if (zfs_flags & ZFS_DEBUG_METASLAB_ALLOC) {
 			zfs_dbgmsg("%s: metaslab allocation failure, "
 			    "trying ganging: zio %px, size %llu, error %d",
 			    spa_name(spa), zio, (u_longlong_t)zio->io_size,
 			    error);
 		}
 		return (zio_write_gang_block(zio, mc));
 	}
 	if (error != 0) {
 		if (error != ENOSPC ||
 		    (zfs_flags & ZFS_DEBUG_METASLAB_ALLOC)) {
 			zfs_dbgmsg("%s: metaslab allocation failure: zio %px, "
 			    "size %llu, error %d",
 			    spa_name(spa), zio, (u_longlong_t)zio->io_size,
 			    error);
 		}
 		zio->io_error = error;
 	}
 
 	return (zio);
 }
 
 static zio_t *
 zio_dva_free(zio_t *zio)
 {
 	metaslab_free(zio->io_spa, zio->io_bp, zio->io_txg, B_FALSE);
 
 	return (zio);
 }
 
 static zio_t *
 zio_dva_claim(zio_t *zio)
 {
 	int error;
 
 	error = metaslab_claim(zio->io_spa, zio->io_bp, zio->io_txg);
 	if (error)
 		zio->io_error = error;
 
 	return (zio);
 }
 
 /*
  * Undo an allocation.  This is used by zio_done() when an I/O fails
  * and we want to give back the block we just allocated.
  * This handles both normal blocks and gang blocks.
  */
 static void
 zio_dva_unallocate(zio_t *zio, zio_gang_node_t *gn, blkptr_t *bp)
 {
 	ASSERT(BP_GET_LOGICAL_BIRTH(bp) == zio->io_txg || BP_IS_HOLE(bp));
 	ASSERT(zio->io_bp_override == NULL);
 
 	if (!BP_IS_HOLE(bp)) {
 		metaslab_free(zio->io_spa, bp, BP_GET_LOGICAL_BIRTH(bp),
 		    B_TRUE);
 	}
 
 	if (gn != NULL) {
 		for (int g = 0; g < SPA_GBH_NBLKPTRS; g++) {
 			zio_dva_unallocate(zio, gn->gn_child[g],
 			    &gn->gn_gbh->zg_blkptr[g]);
 		}
 	}
 }
 
 /*
  * Try to allocate an intent log block.  Return 0 on success, errno on failure.
  */
 int
 zio_alloc_zil(spa_t *spa, objset_t *os, uint64_t txg, blkptr_t *new_bp,
     uint64_t size, boolean_t *slog)
 {
 	int error = 1;
 	zio_alloc_list_t io_alloc_list;
 
 	ASSERT(txg > spa_syncing_txg(spa));
 
 	metaslab_trace_init(&io_alloc_list);
 
 	/*
 	 * Block pointer fields are useful to metaslabs for stats and debugging.
 	 * Fill in the obvious ones before calling into metaslab_alloc().
 	 */
 	BP_SET_TYPE(new_bp, DMU_OT_INTENT_LOG);
 	BP_SET_PSIZE(new_bp, size);
 	BP_SET_LEVEL(new_bp, 0);
 
 	/*
 	 * When allocating a zil block, we don't have information about
 	 * the final destination of the block except the objset it's part
 	 * of, so we just hash the objset ID to pick the allocator to get
 	 * some parallelism.
 	 */
 	int flags = METASLAB_ZIL;
 	int allocator = (uint_t)cityhash1(os->os_dsl_dataset->ds_object)
 	    % spa->spa_alloc_count;
 	error = metaslab_alloc(spa, spa_log_class(spa), size, new_bp, 1,
 	    txg, NULL, flags, &io_alloc_list, NULL, allocator);
 	*slog = (error == 0);
 	if (error != 0) {
 		error = metaslab_alloc(spa, spa_embedded_log_class(spa), size,
 		    new_bp, 1, txg, NULL, flags,
 		    &io_alloc_list, NULL, allocator);
 	}
 	if (error != 0) {
 		error = metaslab_alloc(spa, spa_normal_class(spa), size,
 		    new_bp, 1, txg, NULL, flags,
 		    &io_alloc_list, NULL, allocator);
 	}
 	metaslab_trace_fini(&io_alloc_list);
 
 	if (error == 0) {
 		BP_SET_LSIZE(new_bp, size);
 		BP_SET_PSIZE(new_bp, size);
 		BP_SET_COMPRESS(new_bp, ZIO_COMPRESS_OFF);
 		BP_SET_CHECKSUM(new_bp,
 		    spa_version(spa) >= SPA_VERSION_SLIM_ZIL
 		    ? ZIO_CHECKSUM_ZILOG2 : ZIO_CHECKSUM_ZILOG);
 		BP_SET_TYPE(new_bp, DMU_OT_INTENT_LOG);
 		BP_SET_LEVEL(new_bp, 0);
 		BP_SET_DEDUP(new_bp, 0);
 		BP_SET_BYTEORDER(new_bp, ZFS_HOST_BYTEORDER);
 
 		/*
 		 * encrypted blocks will require an IV and salt. We generate
 		 * these now since we will not be rewriting the bp at
 		 * rewrite time.
 		 */
 		if (os->os_encrypted) {
 			uint8_t iv[ZIO_DATA_IV_LEN];
 			uint8_t salt[ZIO_DATA_SALT_LEN];
 
 			BP_SET_CRYPT(new_bp, B_TRUE);
 			VERIFY0(spa_crypt_get_salt(spa,
 			    dmu_objset_id(os), salt));
 			VERIFY0(zio_crypt_generate_iv(iv));
 
 			zio_crypt_encode_params_bp(new_bp, salt, iv);
 		}
 	} else {
 		zfs_dbgmsg("%s: zil block allocation failure: "
 		    "size %llu, error %d", spa_name(spa), (u_longlong_t)size,
 		    error);
 	}
 
 	return (error);
 }
 
 /*
  * ==========================================================================
  * Read and write to physical devices
  * ==========================================================================
  */
 
 /*
  * Issue an I/O to the underlying vdev. Typically the issue pipeline
  * stops after this stage and will resume upon I/O completion.
  * However, there are instances where the vdev layer may need to
  * continue the pipeline when an I/O was not issued. Since the I/O
  * that was sent to the vdev layer might be different than the one
  * currently active in the pipeline (see vdev_queue_io()), we explicitly
  * force the underlying vdev layers to call either zio_execute() or
  * zio_interrupt() to ensure that the pipeline continues with the correct I/O.
  */
 static zio_t *
 zio_vdev_io_start(zio_t *zio)
 {
 	vdev_t *vd = zio->io_vd;
 	uint64_t align;
 	spa_t *spa = zio->io_spa;
 
 	zio->io_delay = 0;
 
 	ASSERT(zio->io_error == 0);
 	ASSERT(zio->io_child_error[ZIO_CHILD_VDEV] == 0);
 
 	if (vd == NULL) {
 		if (!(zio->io_flags & ZIO_FLAG_CONFIG_WRITER))
 			spa_config_enter(spa, SCL_ZIO, zio, RW_READER);
 
 		/*
 		 * The mirror_ops handle multiple DVAs in a single BP.
 		 */
 		vdev_mirror_ops.vdev_op_io_start(zio);
 		return (NULL);
 	}
 
 	ASSERT3P(zio->io_logical, !=, zio);
 	if (zio->io_type == ZIO_TYPE_WRITE) {
 		ASSERT(spa->spa_trust_config);
 
 		/*
 		 * Note: the code can handle other kinds of writes,
 		 * but we don't expect them.
 		 */
 		if (zio->io_vd->vdev_noalloc) {
 			ASSERT(zio->io_flags &
 			    (ZIO_FLAG_PHYSICAL | ZIO_FLAG_SELF_HEAL |
 			    ZIO_FLAG_RESILVER | ZIO_FLAG_INDUCE_DAMAGE));
 		}
 	}
 
 	align = 1ULL << vd->vdev_top->vdev_ashift;
 
 	if (!(zio->io_flags & ZIO_FLAG_PHYSICAL) &&
 	    P2PHASE(zio->io_size, align) != 0) {
 		/* Transform logical writes to be a full physical block size. */
 		uint64_t asize = P2ROUNDUP(zio->io_size, align);
 		abd_t *abuf = abd_alloc_sametype(zio->io_abd, asize);
 		ASSERT(vd == vd->vdev_top);
 		if (zio->io_type == ZIO_TYPE_WRITE) {
 			abd_copy(abuf, zio->io_abd, zio->io_size);
 			abd_zero_off(abuf, zio->io_size, asize - zio->io_size);
 		}
 		zio_push_transform(zio, abuf, asize, asize, zio_subblock);
 	}
 
 	/*
 	 * If this is not a physical io, make sure that it is properly aligned
 	 * before proceeding.
 	 */
 	if (!(zio->io_flags & ZIO_FLAG_PHYSICAL)) {
 		ASSERT0(P2PHASE(zio->io_offset, align));
 		ASSERT0(P2PHASE(zio->io_size, align));
 	} else {
 		/*
 		 * For physical writes, we allow 512b aligned writes and assume
 		 * the device will perform a read-modify-write as necessary.
 		 */
 		ASSERT0(P2PHASE(zio->io_offset, SPA_MINBLOCKSIZE));
 		ASSERT0(P2PHASE(zio->io_size, SPA_MINBLOCKSIZE));
 	}
 
 	VERIFY(zio->io_type != ZIO_TYPE_WRITE || spa_writeable(spa));
 
 	/*
 	 * If this is a repair I/O, and there's no self-healing involved --
 	 * that is, we're just resilvering what we expect to resilver --
 	 * then don't do the I/O unless zio's txg is actually in vd's DTL.
 	 * This prevents spurious resilvering.
 	 *
 	 * There are a few ways that we can end up creating these spurious
 	 * resilver i/os:
 	 *
 	 * 1. A resilver i/o will be issued if any DVA in the BP has a
 	 * dirty DTL.  The mirror code will issue resilver writes to
 	 * each DVA, including the one(s) that are not on vdevs with dirty
 	 * DTLs.
 	 *
 	 * 2. With nested replication, which happens when we have a
 	 * "replacing" or "spare" vdev that's a child of a mirror or raidz.
 	 * For example, given mirror(replacing(A+B), C), it's likely that
 	 * only A is out of date (it's the new device). In this case, we'll
 	 * read from C, then use the data to resilver A+B -- but we don't
 	 * actually want to resilver B, just A. The top-level mirror has no
 	 * way to know this, so instead we just discard unnecessary repairs
 	 * as we work our way down the vdev tree.
 	 *
 	 * 3. ZTEST also creates mirrors of mirrors, mirrors of raidz, etc.
 	 * The same logic applies to any form of nested replication: ditto
 	 * + mirror, RAID-Z + replacing, etc.
 	 *
 	 * However, indirect vdevs point off to other vdevs which may have
 	 * DTL's, so we never bypass them.  The child i/os on concrete vdevs
 	 * will be properly bypassed instead.
 	 *
 	 * Leaf DTL_PARTIAL can be empty when a legitimate write comes from
 	 * a dRAID spare vdev. For example, when a dRAID spare is first
 	 * used, its spare blocks need to be written to but the leaf vdev's
 	 * of such blocks can have empty DTL_PARTIAL.
 	 *
 	 * There seemed no clean way to allow such writes while bypassing
 	 * spurious ones. At this point, just avoid all bypassing for dRAID
 	 * for correctness.
 	 */
 	if ((zio->io_flags & ZIO_FLAG_IO_REPAIR) &&
 	    !(zio->io_flags & ZIO_FLAG_SELF_HEAL) &&
 	    zio->io_txg != 0 &&	/* not a delegated i/o */
 	    vd->vdev_ops != &vdev_indirect_ops &&
 	    vd->vdev_top->vdev_ops != &vdev_draid_ops &&
 	    !vdev_dtl_contains(vd, DTL_PARTIAL, zio->io_txg, 1)) {
 		ASSERT(zio->io_type == ZIO_TYPE_WRITE);
 		zio_vdev_io_bypass(zio);
 		return (zio);
 	}
 
 	/*
 	 * Select the next best leaf I/O to process.  Distributed spares are
 	 * excluded since they dispatch the I/O directly to a leaf vdev after
 	 * applying the dRAID mapping.
 	 */
 	if (vd->vdev_ops->vdev_op_leaf &&
 	    vd->vdev_ops != &vdev_draid_spare_ops &&
 	    (zio->io_type == ZIO_TYPE_READ ||
 	    zio->io_type == ZIO_TYPE_WRITE ||
 	    zio->io_type == ZIO_TYPE_TRIM)) {
 
 		if (zio_handle_device_injection(vd, zio, ENOSYS) != 0) {
 			/*
 			 * "no-op" injections return success, but do no actual
 			 * work. Just skip the remaining vdev stages.
 			 */
 			zio_vdev_io_bypass(zio);
 			zio_interrupt(zio);
 			return (NULL);
 		}
 
 		if ((zio = vdev_queue_io(zio)) == NULL)
 			return (NULL);
 
 		if (!vdev_accessible(vd, zio)) {
 			zio->io_error = SET_ERROR(ENXIO);
 			zio_interrupt(zio);
 			return (NULL);
 		}
 		zio->io_delay = gethrtime();
 	}
 
 	vd->vdev_ops->vdev_op_io_start(zio);
 	return (NULL);
 }
 
 static zio_t *
 zio_vdev_io_done(zio_t *zio)
 {
 	vdev_t *vd = zio->io_vd;
 	vdev_ops_t *ops = vd ? vd->vdev_ops : &vdev_mirror_ops;
 	boolean_t unexpected_error = B_FALSE;
 
 	if (zio_wait_for_children(zio, ZIO_CHILD_VDEV_BIT, ZIO_WAIT_DONE)) {
 		return (NULL);
 	}
 
 	ASSERT(zio->io_type == ZIO_TYPE_READ ||
 	    zio->io_type == ZIO_TYPE_WRITE ||
 	    zio->io_type == ZIO_TYPE_FLUSH ||
 	    zio->io_type == ZIO_TYPE_TRIM);
 
 	if (zio->io_delay)
 		zio->io_delay = gethrtime() - zio->io_delay;
 
 	if (vd != NULL && vd->vdev_ops->vdev_op_leaf &&
 	    vd->vdev_ops != &vdev_draid_spare_ops) {
 		if (zio->io_type != ZIO_TYPE_FLUSH)
 			vdev_queue_io_done(zio);
 
 		if (zio_injection_enabled && zio->io_error == 0)
 			zio->io_error = zio_handle_device_injections(vd, zio,
 			    EIO, EILSEQ);
 
 		if (zio_injection_enabled && zio->io_error == 0)
 			zio->io_error = zio_handle_label_injection(zio, EIO);
 
 		if (zio->io_error && zio->io_type != ZIO_TYPE_FLUSH &&
 		    zio->io_type != ZIO_TYPE_TRIM) {
 			if (!vdev_accessible(vd, zio)) {
 				zio->io_error = SET_ERROR(ENXIO);
 			} else {
 				unexpected_error = B_TRUE;
 			}
 		}
 	}
 
 	ops->vdev_op_io_done(zio);
 
 	if (unexpected_error && vd->vdev_remove_wanted == B_FALSE)
 		VERIFY(vdev_probe(vd, zio) == NULL);
 
 	return (zio);
 }
 
 /*
  * This function is used to change the priority of an existing zio that is
  * currently in-flight. This is used by the arc to upgrade priority in the
  * event that a demand read is made for a block that is currently queued
  * as a scrub or async read IO. Otherwise, the high priority read request
  * would end up having to wait for the lower priority IO.
  */
 void
 zio_change_priority(zio_t *pio, zio_priority_t priority)
 {
 	zio_t *cio, *cio_next;
 	zio_link_t *zl = NULL;
 
 	ASSERT3U(priority, <, ZIO_PRIORITY_NUM_QUEUEABLE);
 
 	if (pio->io_vd != NULL && pio->io_vd->vdev_ops->vdev_op_leaf) {
 		vdev_queue_change_io_priority(pio, priority);
 	} else {
 		pio->io_priority = priority;
 	}
 
 	mutex_enter(&pio->io_lock);
 	for (cio = zio_walk_children(pio, &zl); cio != NULL; cio = cio_next) {
 		cio_next = zio_walk_children(pio, &zl);
 		zio_change_priority(cio, priority);
 	}
 	mutex_exit(&pio->io_lock);
 }
 
 /*
  * For non-raidz ZIOs, we can just copy aside the bad data read from the
  * disk, and use that to finish the checksum ereport later.
  */
 static void
 zio_vsd_default_cksum_finish(zio_cksum_report_t *zcr,
     const abd_t *good_buf)
 {
 	/* no processing needed */
 	zfs_ereport_finish_checksum(zcr, good_buf, zcr->zcr_cbdata, B_FALSE);
 }
 
 void
 zio_vsd_default_cksum_report(zio_t *zio, zio_cksum_report_t *zcr)
 {
 	void *abd = abd_alloc_sametype(zio->io_abd, zio->io_size);
 
 	abd_copy(abd, zio->io_abd, zio->io_size);
 
 	zcr->zcr_cbinfo = zio->io_size;
 	zcr->zcr_cbdata = abd;
 	zcr->zcr_finish = zio_vsd_default_cksum_finish;
 	zcr->zcr_free = zio_abd_free;
 }
 
 static zio_t *
 zio_vdev_io_assess(zio_t *zio)
 {
 	vdev_t *vd = zio->io_vd;
 
 	if (zio_wait_for_children(zio, ZIO_CHILD_VDEV_BIT, ZIO_WAIT_DONE)) {
 		return (NULL);
 	}
 
 	if (vd == NULL && !(zio->io_flags & ZIO_FLAG_CONFIG_WRITER))
 		spa_config_exit(zio->io_spa, SCL_ZIO, zio);
 
 	if (zio->io_vsd != NULL) {
 		zio->io_vsd_ops->vsd_free(zio);
 		zio->io_vsd = NULL;
 	}
 
 	/*
-	 * If a Direct I/O write checksum verify error has occurred then this
-	 * I/O should not attempt to be issued again. Instead the EIO will
-	 * be returned.
+	 * If a Direct I/O operation has a checksum verify error then this I/O
+	 * should not attempt to be issued again.
 	 */
 	if (zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR) {
-		ASSERT3U(zio->io_child_type, ==, ZIO_CHILD_LOGICAL);
-		ASSERT3U(zio->io_error, ==, EIO);
+		if (zio->io_type == ZIO_TYPE_WRITE) {
+			ASSERT3U(zio->io_child_type, ==, ZIO_CHILD_LOGICAL);
+			ASSERT3U(zio->io_error, ==, EIO);
+		}
 		zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
 		return (zio);
 	}
 
-
 	if (zio_injection_enabled && zio->io_error == 0)
 		zio->io_error = zio_handle_fault_injection(zio, EIO);
 
 	/*
 	 * If the I/O failed, determine whether we should attempt to retry it.
 	 *
 	 * On retry, we cut in line in the issue queue, since we don't want
 	 * compression/checksumming/etc. work to prevent our (cheap) IO reissue.
 	 */
 	if (zio->io_error && vd == NULL &&
 	    !(zio->io_flags & (ZIO_FLAG_DONT_RETRY | ZIO_FLAG_IO_RETRY))) {
 		ASSERT(!(zio->io_flags & ZIO_FLAG_DONT_QUEUE));	/* not a leaf */
 		ASSERT(!(zio->io_flags & ZIO_FLAG_IO_BYPASS));	/* not a leaf */
 		zio->io_error = 0;
 		zio->io_flags |= ZIO_FLAG_IO_RETRY | ZIO_FLAG_DONT_AGGREGATE;
 		zio->io_stage = ZIO_STAGE_VDEV_IO_START >> 1;
 		zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE,
 		    zio_requeue_io_start_cut_in_line);
 		return (NULL);
 	}
 
 	/*
 	 * If we got an error on a leaf device, convert it to ENXIO
 	 * if the device is not accessible at all.
 	 */
 	if (zio->io_error && vd != NULL && vd->vdev_ops->vdev_op_leaf &&
 	    !vdev_accessible(vd, zio))
 		zio->io_error = SET_ERROR(ENXIO);
 
 	/*
 	 * If we can't write to an interior vdev (mirror or RAID-Z),
 	 * set vdev_cant_write so that we stop trying to allocate from it.
 	 */
 	if (zio->io_error == ENXIO && zio->io_type == ZIO_TYPE_WRITE &&
 	    vd != NULL && !vd->vdev_ops->vdev_op_leaf) {
 		vdev_dbgmsg(vd, "zio_vdev_io_assess(zio=%px) setting "
 		    "cant_write=TRUE due to write failure with ENXIO",
 		    zio);
 		vd->vdev_cant_write = B_TRUE;
 	}
 
 	/*
 	 * If a cache flush returns ENOTSUP or ENOTTY, we know that no future
 	 * attempts will ever succeed. In this case we set a persistent
 	 * boolean flag so that we don't bother with it in the future.
 	 */
 	if ((zio->io_error == ENOTSUP || zio->io_error == ENOTTY) &&
 	    zio->io_type == ZIO_TYPE_FLUSH && vd != NULL)
 		vd->vdev_nowritecache = B_TRUE;
 
 	if (zio->io_error)
 		zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
 
 	return (zio);
 }
 
 void
 zio_vdev_io_reissue(zio_t *zio)
 {
 	ASSERT(zio->io_stage == ZIO_STAGE_VDEV_IO_START);
 	ASSERT(zio->io_error == 0);
 
 	zio->io_stage >>= 1;
 }
 
 void
 zio_vdev_io_redone(zio_t *zio)
 {
 	ASSERT(zio->io_stage == ZIO_STAGE_VDEV_IO_DONE);
 
 	zio->io_stage >>= 1;
 }
 
 void
 zio_vdev_io_bypass(zio_t *zio)
 {
 	ASSERT(zio->io_stage == ZIO_STAGE_VDEV_IO_START);
 	ASSERT(zio->io_error == 0);
 
 	zio->io_flags |= ZIO_FLAG_IO_BYPASS;
 	zio->io_stage = ZIO_STAGE_VDEV_IO_ASSESS >> 1;
 }
 
 /*
  * ==========================================================================
  * Encrypt and store encryption parameters
  * ==========================================================================
  */
 
 
 /*
  * This function is used for ZIO_STAGE_ENCRYPT. It is responsible for
  * managing the storage of encryption parameters and passing them to the
  * lower-level encryption functions.
  */
 static zio_t *
 zio_encrypt(zio_t *zio)
 {
 	zio_prop_t *zp = &zio->io_prop;
 	spa_t *spa = zio->io_spa;
 	blkptr_t *bp = zio->io_bp;
 	uint64_t psize = BP_GET_PSIZE(bp);
 	uint64_t dsobj = zio->io_bookmark.zb_objset;
 	dmu_object_type_t ot = BP_GET_TYPE(bp);
 	void *enc_buf = NULL;
 	abd_t *eabd = NULL;
 	uint8_t salt[ZIO_DATA_SALT_LEN];
 	uint8_t iv[ZIO_DATA_IV_LEN];
 	uint8_t mac[ZIO_DATA_MAC_LEN];
 	boolean_t no_crypt = B_FALSE;
 
 	/* the root zio already encrypted the data */
 	if (zio->io_child_type == ZIO_CHILD_GANG)
 		return (zio);
 
 	/* only ZIL blocks are re-encrypted on rewrite */
 	if (!IO_IS_ALLOCATING(zio) && ot != DMU_OT_INTENT_LOG)
 		return (zio);
 
 	if (!(zp->zp_encrypt || BP_IS_ENCRYPTED(bp))) {
 		BP_SET_CRYPT(bp, B_FALSE);
 		return (zio);
 	}
 
 	/* if we are doing raw encryption set the provided encryption params */
 	if (zio->io_flags & ZIO_FLAG_RAW_ENCRYPT) {
 		ASSERT0(BP_GET_LEVEL(bp));
 		BP_SET_CRYPT(bp, B_TRUE);
 		BP_SET_BYTEORDER(bp, zp->zp_byteorder);
 		if (ot != DMU_OT_OBJSET)
 			zio_crypt_encode_mac_bp(bp, zp->zp_mac);
 
 		/* dnode blocks must be written out in the provided byteorder */
 		if (zp->zp_byteorder != ZFS_HOST_BYTEORDER &&
 		    ot == DMU_OT_DNODE) {
 			void *bswap_buf = zio_buf_alloc(psize);
 			abd_t *babd = abd_get_from_buf(bswap_buf, psize);
 
 			ASSERT3U(BP_GET_COMPRESS(bp), ==, ZIO_COMPRESS_OFF);
 			abd_copy_to_buf(bswap_buf, zio->io_abd, psize);
 			dmu_ot_byteswap[DMU_OT_BYTESWAP(ot)].ob_func(bswap_buf,
 			    psize);
 
 			abd_take_ownership_of_buf(babd, B_TRUE);
 			zio_push_transform(zio, babd, psize, psize, NULL);
 		}
 
 		if (DMU_OT_IS_ENCRYPTED(ot))
 			zio_crypt_encode_params_bp(bp, zp->zp_salt, zp->zp_iv);
 		return (zio);
 	}
 
 	/* indirect blocks only maintain a cksum of the lower level MACs */
 	if (BP_GET_LEVEL(bp) > 0) {
 		BP_SET_CRYPT(bp, B_TRUE);
 		VERIFY0(zio_crypt_do_indirect_mac_checksum_abd(B_TRUE,
 		    zio->io_orig_abd, BP_GET_LSIZE(bp), BP_SHOULD_BYTESWAP(bp),
 		    mac));
 		zio_crypt_encode_mac_bp(bp, mac);
 		return (zio);
 	}
 
 	/*
 	 * Objset blocks are a special case since they have 2 256-bit MACs
 	 * embedded within them.
 	 */
 	if (ot == DMU_OT_OBJSET) {
 		ASSERT0(DMU_OT_IS_ENCRYPTED(ot));
 		ASSERT3U(BP_GET_COMPRESS(bp), ==, ZIO_COMPRESS_OFF);
 		BP_SET_CRYPT(bp, B_TRUE);
 		VERIFY0(spa_do_crypt_objset_mac_abd(B_TRUE, spa, dsobj,
 		    zio->io_abd, psize, BP_SHOULD_BYTESWAP(bp)));
 		return (zio);
 	}
 
 	/* unencrypted object types are only authenticated with a MAC */
 	if (!DMU_OT_IS_ENCRYPTED(ot)) {
 		BP_SET_CRYPT(bp, B_TRUE);
 		VERIFY0(spa_do_crypt_mac_abd(B_TRUE, spa, dsobj,
 		    zio->io_abd, psize, mac));
 		zio_crypt_encode_mac_bp(bp, mac);
 		return (zio);
 	}
 
 	/*
 	 * Later passes of sync-to-convergence may decide to rewrite data
 	 * in place to avoid more disk reallocations. This presents a problem
 	 * for encryption because this constitutes rewriting the new data with
 	 * the same encryption key and IV. However, this only applies to blocks
 	 * in the MOS (particularly the spacemaps) and we do not encrypt the
 	 * MOS. We assert that the zio is allocating or an intent log write
 	 * to enforce this.
 	 */
 	ASSERT(IO_IS_ALLOCATING(zio) || ot == DMU_OT_INTENT_LOG);
 	ASSERT(BP_GET_LEVEL(bp) == 0 || ot == DMU_OT_INTENT_LOG);
 	ASSERT(spa_feature_is_active(spa, SPA_FEATURE_ENCRYPTION));
 	ASSERT3U(psize, !=, 0);
 
 	enc_buf = zio_buf_alloc(psize);
 	eabd = abd_get_from_buf(enc_buf, psize);
 	abd_take_ownership_of_buf(eabd, B_TRUE);
 
 	/*
 	 * For an explanation of what encryption parameters are stored
 	 * where, see the block comment in zio_crypt.c.
 	 */
 	if (ot == DMU_OT_INTENT_LOG) {
 		zio_crypt_decode_params_bp(bp, salt, iv);
 	} else {
 		BP_SET_CRYPT(bp, B_TRUE);
 	}
 
 	/* Perform the encryption. This should not fail */
 	VERIFY0(spa_do_crypt_abd(B_TRUE, spa, &zio->io_bookmark,
 	    BP_GET_TYPE(bp), BP_GET_DEDUP(bp), BP_SHOULD_BYTESWAP(bp),
 	    salt, iv, mac, psize, zio->io_abd, eabd, &no_crypt));
 
 	/* encode encryption metadata into the bp */
 	if (ot == DMU_OT_INTENT_LOG) {
 		/*
 		 * ZIL blocks store the MAC in the embedded checksum, so the
 		 * transform must always be applied.
 		 */
 		zio_crypt_encode_mac_zil(enc_buf, mac);
 		zio_push_transform(zio, eabd, psize, psize, NULL);
 	} else {
 		BP_SET_CRYPT(bp, B_TRUE);
 		zio_crypt_encode_params_bp(bp, salt, iv);
 		zio_crypt_encode_mac_bp(bp, mac);
 
 		if (no_crypt) {
 			ASSERT3U(ot, ==, DMU_OT_DNODE);
 			abd_free(eabd);
 		} else {
 			zio_push_transform(zio, eabd, psize, psize, NULL);
 		}
 	}
 
 	return (zio);
 }
 
 /*
  * ==========================================================================
  * Generate and verify checksums
  * ==========================================================================
  */
 static zio_t *
 zio_checksum_generate(zio_t *zio)
 {
 	blkptr_t *bp = zio->io_bp;
 	enum zio_checksum checksum;
 
 	if (bp == NULL) {
 		/*
 		 * This is zio_write_phys().
 		 * We're either generating a label checksum, or none at all.
 		 */
 		checksum = zio->io_prop.zp_checksum;
 
 		if (checksum == ZIO_CHECKSUM_OFF)
 			return (zio);
 
 		ASSERT(checksum == ZIO_CHECKSUM_LABEL);
 	} else {
 		if (BP_IS_GANG(bp) && zio->io_child_type == ZIO_CHILD_GANG) {
 			ASSERT(!IO_IS_ALLOCATING(zio));
 			checksum = ZIO_CHECKSUM_GANG_HEADER;
 		} else {
 			checksum = BP_GET_CHECKSUM(bp);
 		}
 	}
 
 	zio_checksum_compute(zio, checksum, zio->io_abd, zio->io_size);
 
 	return (zio);
 }
 
 static zio_t *
 zio_checksum_verify(zio_t *zio)
 {
 	zio_bad_cksum_t info;
 	blkptr_t *bp = zio->io_bp;
 	int error;
 
 	ASSERT(zio->io_vd != NULL);
 
 	if (bp == NULL) {
 		/*
 		 * This is zio_read_phys().
 		 * We're either verifying a label checksum, or nothing at all.
 		 */
 		if (zio->io_prop.zp_checksum == ZIO_CHECKSUM_OFF)
 			return (zio);
 
 		ASSERT3U(zio->io_prop.zp_checksum, ==, ZIO_CHECKSUM_LABEL);
 	}
 
+	ASSERT0(zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR);
+	IMPLY(zio->io_flags & ZIO_FLAG_DIO_READ,
+	    !(zio->io_flags & ZIO_FLAG_SPECULATIVE));
+
 	if ((error = zio_checksum_error(zio, &info)) != 0) {
 		zio->io_error = error;
 		if (error == ECKSUM &&
 		    !(zio->io_flags & ZIO_FLAG_SPECULATIVE)) {
-			mutex_enter(&zio->io_vd->vdev_stat_lock);
-			zio->io_vd->vdev_stat.vs_checksum_errors++;
-			mutex_exit(&zio->io_vd->vdev_stat_lock);
-			(void) zfs_ereport_start_checksum(zio->io_spa,
-			    zio->io_vd, &zio->io_bookmark, zio,
-			    zio->io_offset, zio->io_size, &info);
+			if (zio->io_flags & ZIO_FLAG_DIO_READ) {
+				zio->io_flags |= ZIO_FLAG_DIO_CHKSUM_ERR;
+				zio_t *pio = zio_unique_parent(zio);
+				/*
+				 * Any Direct I/O read that has a checksum
+				 * error must be treated as suspicous as the
+				 * contents of the buffer could be getting
+				 * manipulated while the I/O is taking place.
+				 *
+				 * The checksum verify error will only be
+				 * reported here for disk and file VDEV's and
+				 * will be reported on those that the failure
+				 * occurred on. Other types of VDEV's report the
+				 * verify failure in their own code paths.
+				 */
+				if (pio->io_child_type == ZIO_CHILD_LOGICAL) {
+					zio_dio_chksum_verify_error_report(zio);
+				}
+			} else {
+				mutex_enter(&zio->io_vd->vdev_stat_lock);
+				zio->io_vd->vdev_stat.vs_checksum_errors++;
+				mutex_exit(&zio->io_vd->vdev_stat_lock);
+				(void) zfs_ereport_start_checksum(zio->io_spa,
+				    zio->io_vd, &zio->io_bookmark, zio,
+				    zio->io_offset, zio->io_size, &info);
+			}
 		}
 	}
 
 	return (zio);
 }
 
 static zio_t *
 zio_dio_checksum_verify(zio_t *zio)
 {
 	zio_t *pio = zio_unique_parent(zio);
 	int error;
 
 	ASSERT3P(zio->io_vd, !=, NULL);
 	ASSERT3P(zio->io_bp, !=, NULL);
 	ASSERT3U(zio->io_child_type, ==, ZIO_CHILD_VDEV);
 	ASSERT3U(zio->io_type, ==, ZIO_TYPE_WRITE);
 	ASSERT3B(pio->io_prop.zp_direct_write, ==, B_TRUE);
 	ASSERT3U(pio->io_child_type, ==, ZIO_CHILD_LOGICAL);
 
 	if (zfs_vdev_direct_write_verify == 0 || zio->io_error != 0)
 		goto out;
 
 	if ((error = zio_checksum_error(zio, NULL)) != 0) {
 		zio->io_error = error;
 		if (error == ECKSUM) {
-			mutex_enter(&zio->io_vd->vdev_stat_lock);
-			zio->io_vd->vdev_stat.vs_dio_verify_errors++;
-			mutex_exit(&zio->io_vd->vdev_stat_lock);
-			zio->io_error = SET_ERROR(EIO);
 			zio->io_flags |= ZIO_FLAG_DIO_CHKSUM_ERR;
-
-			/*
-			 * The EIO error must be propagated up to the logical
-			 * parent ZIO in zio_notify_parent() so it can be
-			 * returned to dmu_write_abd().
-			 */
-			zio->io_flags &= ~ZIO_FLAG_DONT_PROPAGATE;
-
-			(void) zfs_ereport_post(FM_EREPORT_ZFS_DIO_VERIFY,
-			    zio->io_spa, zio->io_vd, &zio->io_bookmark,
-			    zio, 0);
+			zio_dio_chksum_verify_error_report(zio);
 		}
 	}
 
 out:
 	return (zio);
 }
 
 
 /*
  * Called by RAID-Z to ensure we don't compute the checksum twice.
  */
 void
 zio_checksum_verified(zio_t *zio)
 {
 	zio->io_pipeline &= ~ZIO_STAGE_CHECKSUM_VERIFY;
 }
 
+/*
+ * Report Direct I/O checksum verify error and create ZED event.
+ */
+void
+zio_dio_chksum_verify_error_report(zio_t *zio)
+{
+	ASSERT(zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR);
+
+	if (zio->io_child_type == ZIO_CHILD_LOGICAL)
+		return;
+
+	mutex_enter(&zio->io_vd->vdev_stat_lock);
+	zio->io_vd->vdev_stat.vs_dio_verify_errors++;
+	mutex_exit(&zio->io_vd->vdev_stat_lock);
+	if (zio->io_type == ZIO_TYPE_WRITE) {
+		/*
+		 * Convert checksum error for writes into EIO.
+		 */
+		zio->io_error = SET_ERROR(EIO);
+		/*
+		 * Report dio_verify_wr ZED event.
+		 */
+		(void) zfs_ereport_post(FM_EREPORT_ZFS_DIO_VERIFY_WR,
+		    zio->io_spa,  zio->io_vd, &zio->io_bookmark, zio, 0);
+	} else {
+		/*
+		 * Report dio_verify_rd ZED event.
+		 */
+		(void) zfs_ereport_post(FM_EREPORT_ZFS_DIO_VERIFY_RD,
+		    zio->io_spa, zio->io_vd, &zio->io_bookmark, zio, 0);
+	}
+}
+
 /*
  * ==========================================================================
  * Error rank.  Error are ranked in the order 0, ENXIO, ECKSUM, EIO, other.
  * An error of 0 indicates success.  ENXIO indicates whole-device failure,
  * which may be transient (e.g. unplugged) or permanent.  ECKSUM and EIO
  * indicate errors that are specific to one I/O, and most likely permanent.
  * Any other error is presumed to be worse because we weren't expecting it.
  * ==========================================================================
  */
 int
 zio_worst_error(int e1, int e2)
 {
 	static int zio_error_rank[] = { 0, ENXIO, ECKSUM, EIO };
 	int r1, r2;
 
 	for (r1 = 0; r1 < sizeof (zio_error_rank) / sizeof (int); r1++)
 		if (e1 == zio_error_rank[r1])
 			break;
 
 	for (r2 = 0; r2 < sizeof (zio_error_rank) / sizeof (int); r2++)
 		if (e2 == zio_error_rank[r2])
 			break;
 
 	return (r1 > r2 ? e1 : e2);
 }
 
 /*
  * ==========================================================================
  * I/O completion
  * ==========================================================================
  */
 static zio_t *
 zio_ready(zio_t *zio)
 {
 	blkptr_t *bp = zio->io_bp;
 	zio_t *pio, *pio_next;
 	zio_link_t *zl = NULL;
 
 	if (zio_wait_for_children(zio, ZIO_CHILD_LOGICAL_BIT |
 	    ZIO_CHILD_GANG_BIT | ZIO_CHILD_DDT_BIT, ZIO_WAIT_READY)) {
 		return (NULL);
 	}
 
 	if (zio->io_ready) {
 		ASSERT(IO_IS_ALLOCATING(zio));
 		ASSERT(BP_GET_LOGICAL_BIRTH(bp) == zio->io_txg ||
 		    BP_IS_HOLE(bp) || (zio->io_flags & ZIO_FLAG_NOPWRITE));
 		ASSERT(zio->io_children[ZIO_CHILD_GANG][ZIO_WAIT_READY] == 0);
 
 		zio->io_ready(zio);
 	}
 
 #ifdef ZFS_DEBUG
 	if (bp != NULL && bp != &zio->io_bp_copy)
 		zio->io_bp_copy = *bp;
 #endif
 
 	if (zio->io_error != 0) {
 		zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
 
 		if (zio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
 			ASSERT(IO_IS_ALLOCATING(zio));
 			ASSERT(zio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
 			ASSERT(zio->io_metaslab_class != NULL);
 			ASSERT(ZIO_HAS_ALLOCATOR(zio));
 
 			/*
 			 * We were unable to allocate anything, unreserve and
 			 * issue the next I/O to allocate.
 			 */
 			metaslab_class_throttle_unreserve(
 			    zio->io_metaslab_class, zio->io_prop.zp_copies,
 			    zio->io_allocator, zio);
 			zio_allocate_dispatch(zio->io_spa, zio->io_allocator);
 		}
 	}
 
 	mutex_enter(&zio->io_lock);
 	zio->io_state[ZIO_WAIT_READY] = 1;
 	pio = zio_walk_parents(zio, &zl);
 	mutex_exit(&zio->io_lock);
 
 	/*
 	 * As we notify zio's parents, new parents could be added.
 	 * New parents go to the head of zio's io_parent_list, however,
 	 * so we will (correctly) not notify them.  The remainder of zio's
 	 * io_parent_list, from 'pio_next' onward, cannot change because
 	 * all parents must wait for us to be done before they can be done.
 	 */
 	for (; pio != NULL; pio = pio_next) {
 		pio_next = zio_walk_parents(zio, &zl);
 		zio_notify_parent(pio, zio, ZIO_WAIT_READY, NULL);
 	}
 
 	if (zio->io_flags & ZIO_FLAG_NODATA) {
 		if (bp != NULL && BP_IS_GANG(bp)) {
 			zio->io_flags &= ~ZIO_FLAG_NODATA;
 		} else {
 			ASSERT((uintptr_t)zio->io_abd < SPA_MAXBLOCKSIZE);
 			zio->io_pipeline &= ~ZIO_VDEV_IO_STAGES;
 		}
 	}
 
 	if (zio_injection_enabled &&
 	    zio->io_spa->spa_syncing_txg == zio->io_txg)
 		zio_handle_ignored_writes(zio);
 
 	return (zio);
 }
 
 /*
  * Update the allocation throttle accounting.
  */
 static void
 zio_dva_throttle_done(zio_t *zio)
 {
 	zio_t *lio __maybe_unused = zio->io_logical;
 	zio_t *pio = zio_unique_parent(zio);
 	vdev_t *vd = zio->io_vd;
 	int flags = METASLAB_ASYNC_ALLOC;
 
 	ASSERT3P(zio->io_bp, !=, NULL);
 	ASSERT3U(zio->io_type, ==, ZIO_TYPE_WRITE);
 	ASSERT3U(zio->io_priority, ==, ZIO_PRIORITY_ASYNC_WRITE);
 	ASSERT3U(zio->io_child_type, ==, ZIO_CHILD_VDEV);
 	ASSERT(vd != NULL);
 	ASSERT3P(vd, ==, vd->vdev_top);
 	ASSERT(zio_injection_enabled || !(zio->io_flags & ZIO_FLAG_IO_RETRY));
 	ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REPAIR));
 	ASSERT(zio->io_flags & ZIO_FLAG_IO_ALLOCATING);
 	ASSERT(!(lio->io_flags & ZIO_FLAG_IO_REWRITE));
 	ASSERT(!(lio->io_orig_flags & ZIO_FLAG_NODATA));
 
 	/*
 	 * Parents of gang children can have two flavors -- ones that
 	 * allocated the gang header (will have ZIO_FLAG_IO_REWRITE set)
 	 * and ones that allocated the constituent blocks. The allocation
 	 * throttle needs to know the allocating parent zio so we must find
 	 * it here.
 	 */
 	if (pio->io_child_type == ZIO_CHILD_GANG) {
 		/*
 		 * If our parent is a rewrite gang child then our grandparent
 		 * would have been the one that performed the allocation.
 		 */
 		if (pio->io_flags & ZIO_FLAG_IO_REWRITE)
 			pio = zio_unique_parent(pio);
 		flags |= METASLAB_GANG_CHILD;
 	}
 
 	ASSERT(IO_IS_ALLOCATING(pio));
 	ASSERT(ZIO_HAS_ALLOCATOR(pio));
 	ASSERT3P(zio, !=, zio->io_logical);
 	ASSERT(zio->io_logical != NULL);
 	ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REPAIR));
 	ASSERT0(zio->io_flags & ZIO_FLAG_NOPWRITE);
 	ASSERT(zio->io_metaslab_class != NULL);
 
 	mutex_enter(&pio->io_lock);
 	metaslab_group_alloc_decrement(zio->io_spa, vd->vdev_id, pio, flags,
 	    pio->io_allocator, B_TRUE);
 	mutex_exit(&pio->io_lock);
 
 	metaslab_class_throttle_unreserve(zio->io_metaslab_class, 1,
 	    pio->io_allocator, pio);
 
 	/*
 	 * Call into the pipeline to see if there is more work that
 	 * needs to be done. If there is work to be done it will be
 	 * dispatched to another taskq thread.
 	 */
 	zio_allocate_dispatch(zio->io_spa, pio->io_allocator);
 }
 
 static zio_t *
 zio_done(zio_t *zio)
 {
 	/*
 	 * Always attempt to keep stack usage minimal here since
 	 * we can be called recursively up to 19 levels deep.
 	 */
 	const uint64_t psize = zio->io_size;
 	zio_t *pio, *pio_next;
 	zio_link_t *zl = NULL;
 
 	/*
 	 * If our children haven't all completed,
 	 * wait for them and then repeat this pipeline stage.
 	 */
 	if (zio_wait_for_children(zio, ZIO_CHILD_ALL_BITS, ZIO_WAIT_DONE)) {
 		return (NULL);
 	}
 
 	/*
 	 * If the allocation throttle is enabled, then update the accounting.
 	 * We only track child I/Os that are part of an allocating async
 	 * write. We must do this since the allocation is performed
 	 * by the logical I/O but the actual write is done by child I/Os.
 	 */
 	if (zio->io_flags & ZIO_FLAG_IO_ALLOCATING &&
 	    zio->io_child_type == ZIO_CHILD_VDEV) {
 		ASSERT(zio->io_metaslab_class != NULL);
 		ASSERT(zio->io_metaslab_class->mc_alloc_throttle_enabled);
 		zio_dva_throttle_done(zio);
 	}
 
 	/*
 	 * If the allocation throttle is enabled, verify that
 	 * we have decremented the refcounts for every I/O that was throttled.
 	 */
 	if (zio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
 		ASSERT(zio->io_type == ZIO_TYPE_WRITE);
 		ASSERT(zio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
 		ASSERT(zio->io_bp != NULL);
 		ASSERT(ZIO_HAS_ALLOCATOR(zio));
 
 		metaslab_group_alloc_verify(zio->io_spa, zio->io_bp, zio,
 		    zio->io_allocator);
 		VERIFY(zfs_refcount_not_held(&zio->io_metaslab_class->
 		    mc_allocator[zio->io_allocator].mca_alloc_slots, zio));
 	}
 
 
 	for (int c = 0; c < ZIO_CHILD_TYPES; c++)
 		for (int w = 0; w < ZIO_WAIT_TYPES; w++)
 			ASSERT(zio->io_children[c][w] == 0);
 
 	if (zio->io_bp != NULL && !BP_IS_EMBEDDED(zio->io_bp)) {
 		ASSERT(zio->io_bp->blk_pad[0] == 0);
 		ASSERT(zio->io_bp->blk_pad[1] == 0);
 		ASSERT(memcmp(zio->io_bp, &zio->io_bp_copy,
 		    sizeof (blkptr_t)) == 0 ||
 		    (zio->io_bp == zio_unique_parent(zio)->io_bp));
 		if (zio->io_type == ZIO_TYPE_WRITE && !BP_IS_HOLE(zio->io_bp) &&
 		    zio->io_bp_override == NULL &&
 		    !(zio->io_flags & ZIO_FLAG_IO_REPAIR)) {
 			ASSERT3U(zio->io_prop.zp_copies, <=,
 			    BP_GET_NDVAS(zio->io_bp));
 			ASSERT(BP_COUNT_GANG(zio->io_bp) == 0 ||
 			    (BP_COUNT_GANG(zio->io_bp) ==
 			    BP_GET_NDVAS(zio->io_bp)));
 		}
 		if (zio->io_flags & ZIO_FLAG_NOPWRITE)
 			VERIFY(BP_EQUAL(zio->io_bp, &zio->io_bp_orig));
 	}
 
 	/*
 	 * If there were child vdev/gang/ddt errors, they apply to us now.
 	 */
 	zio_inherit_child_errors(zio, ZIO_CHILD_VDEV);
 	zio_inherit_child_errors(zio, ZIO_CHILD_GANG);
 	zio_inherit_child_errors(zio, ZIO_CHILD_DDT);
 
 	/*
 	 * If the I/O on the transformed data was successful, generate any
 	 * checksum reports now while we still have the transformed data.
 	 */
 	if (zio->io_error == 0) {
 		while (zio->io_cksum_report != NULL) {
 			zio_cksum_report_t *zcr = zio->io_cksum_report;
 			uint64_t align = zcr->zcr_align;
 			uint64_t asize = P2ROUNDUP(psize, align);
 			abd_t *adata = zio->io_abd;
 
 			if (adata != NULL && asize != psize) {
 				adata = abd_alloc(asize, B_TRUE);
 				abd_copy(adata, zio->io_abd, psize);
 				abd_zero_off(adata, psize, asize - psize);
 			}
 
 			zio->io_cksum_report = zcr->zcr_next;
 			zcr->zcr_next = NULL;
 			zcr->zcr_finish(zcr, adata);
 			zfs_ereport_free_checksum(zcr);
 
 			if (adata != NULL && asize != psize)
 				abd_free(adata);
 		}
 	}
 
 	zio_pop_transforms(zio);	/* note: may set zio->io_error */
 
 	vdev_stat_update(zio, psize);
 
 	/*
 	 * If this I/O is attached to a particular vdev is slow, exceeding
 	 * 30 seconds to complete, post an error described the I/O delay.
 	 * We ignore these errors if the device is currently unavailable.
 	 */
 	if (zio->io_delay >= MSEC2NSEC(zio_slow_io_ms)) {
 		if (zio->io_vd != NULL && !vdev_is_dead(zio->io_vd)) {
 			/*
 			 * We want to only increment our slow IO counters if
 			 * the IO is valid (i.e. not if the drive is removed).
 			 *
 			 * zfs_ereport_post() will also do these checks, but
 			 * it can also ratelimit and have other failures, so we
 			 * need to increment the slow_io counters independent
 			 * of it.
 			 */
 			if (zfs_ereport_is_valid(FM_EREPORT_ZFS_DELAY,
 			    zio->io_spa, zio->io_vd, zio)) {
 				mutex_enter(&zio->io_vd->vdev_stat_lock);
 				zio->io_vd->vdev_stat.vs_slow_ios++;
 				mutex_exit(&zio->io_vd->vdev_stat_lock);
 
 				(void) zfs_ereport_post(FM_EREPORT_ZFS_DELAY,
 				    zio->io_spa, zio->io_vd, &zio->io_bookmark,
 				    zio, 0);
 			}
 		}
 	}
 
 	if (zio->io_error) {
 		/*
 		 * If this I/O is attached to a particular vdev,
 		 * generate an error message describing the I/O failure
 		 * at the block level.  We ignore these errors if the
 		 * device is currently unavailable.
 		 */
 		if (zio->io_error != ECKSUM && zio->io_vd != NULL &&
 		    !vdev_is_dead(zio->io_vd) &&
 		    !(zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR)) {
 			int ret = zfs_ereport_post(FM_EREPORT_ZFS_IO,
 			    zio->io_spa, zio->io_vd, &zio->io_bookmark, zio, 0);
 			if (ret != EALREADY) {
 				mutex_enter(&zio->io_vd->vdev_stat_lock);
 				if (zio->io_type == ZIO_TYPE_READ)
 					zio->io_vd->vdev_stat.vs_read_errors++;
 				else if (zio->io_type == ZIO_TYPE_WRITE)
 					zio->io_vd->vdev_stat.vs_write_errors++;
 				mutex_exit(&zio->io_vd->vdev_stat_lock);
 			}
 		}
 
 		if ((zio->io_error == EIO || !(zio->io_flags &
 		    (ZIO_FLAG_SPECULATIVE | ZIO_FLAG_DONT_PROPAGATE))) &&
 		    !(zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR) &&
 		    zio == zio->io_logical) {
 			/*
 			 * For logical I/O requests, tell the SPA to log the
 			 * error and generate a logical data ereport.
 			 */
 			spa_log_error(zio->io_spa, &zio->io_bookmark,
 			    BP_GET_LOGICAL_BIRTH(zio->io_bp));
 			(void) zfs_ereport_post(FM_EREPORT_ZFS_DATA,
 			    zio->io_spa, NULL, &zio->io_bookmark, zio, 0);
 		}
 	}
 
 	if (zio->io_error && zio == zio->io_logical) {
 		/*
 		 * Determine whether zio should be reexecuted.  This will
 		 * propagate all the way to the root via zio_notify_parent().
 		 */
 		ASSERT(zio->io_vd == NULL && zio->io_bp != NULL);
 		ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
 
 		if (IO_IS_ALLOCATING(zio) &&
 		    !(zio->io_flags & ZIO_FLAG_CANFAIL) &&
 		    !(zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR)) {
 			if (zio->io_error != ENOSPC)
 				zio->io_reexecute |= ZIO_REEXECUTE_NOW;
 			else
 				zio->io_reexecute |= ZIO_REEXECUTE_SUSPEND;
 		}
 
 		if ((zio->io_type == ZIO_TYPE_READ ||
 		    zio->io_type == ZIO_TYPE_FREE) &&
 		    !(zio->io_flags & ZIO_FLAG_SCAN_THREAD) &&
 		    zio->io_error == ENXIO &&
 		    spa_load_state(zio->io_spa) == SPA_LOAD_NONE &&
 		    spa_get_failmode(zio->io_spa) != ZIO_FAILURE_MODE_CONTINUE)
 			zio->io_reexecute |= ZIO_REEXECUTE_SUSPEND;
 
 		if (!(zio->io_flags & ZIO_FLAG_CANFAIL) && !zio->io_reexecute)
 			zio->io_reexecute |= ZIO_REEXECUTE_SUSPEND;
 
 		/*
 		 * Here is a possibly good place to attempt to do
 		 * either combinatorial reconstruction or error correction
 		 * based on checksums.  It also might be a good place
 		 * to send out preliminary ereports before we suspend
 		 * processing.
 		 */
 	}
 
 	/*
 	 * If there were logical child errors, they apply to us now.
 	 * We defer this until now to avoid conflating logical child
 	 * errors with errors that happened to the zio itself when
 	 * updating vdev stats and reporting FMA events above.
 	 */
 	zio_inherit_child_errors(zio, ZIO_CHILD_LOGICAL);
 
 	if ((zio->io_error || zio->io_reexecute) &&
 	    IO_IS_ALLOCATING(zio) && zio->io_gang_leader == zio &&
 	    !(zio->io_flags & (ZIO_FLAG_IO_REWRITE | ZIO_FLAG_NOPWRITE)))
 		zio_dva_unallocate(zio, zio->io_gang_tree, zio->io_bp);
 
 	zio_gang_tree_free(&zio->io_gang_tree);
 
 	/*
 	 * Godfather I/Os should never suspend.
 	 */
 	if ((zio->io_flags & ZIO_FLAG_GODFATHER) &&
 	    (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND))
 		zio->io_reexecute &= ~ZIO_REEXECUTE_SUSPEND;
 
 	if (zio->io_reexecute) {
 		/*
-		 * A Direct I/O write that has a checksum verify error should
-		 * not attempt to reexecute. Instead, EAGAIN should just be
-		 * propagated back up so the write can be attempt to be issued
-		 * through the ARC.
+		 * A Direct I/O operation that has a checksum verify error
+		 * should not attempt to reexecute. Instead, the error should
+		 * just be propagated back.
 		 */
 		ASSERT(!(zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR));
 
 		/*
 		 * This is a logical I/O that wants to reexecute.
 		 *
 		 * Reexecute is top-down.  When an i/o fails, if it's not
 		 * the root, it simply notifies its parent and sticks around.
 		 * The parent, seeing that it still has children in zio_done(),
 		 * does the same.  This percolates all the way up to the root.
 		 * The root i/o will reexecute or suspend the entire tree.
 		 *
 		 * This approach ensures that zio_reexecute() honors
 		 * all the original i/o dependency relationships, e.g.
 		 * parents not executing until children are ready.
 		 */
 		ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
 
 		zio->io_gang_leader = NULL;
 
 		mutex_enter(&zio->io_lock);
 		zio->io_state[ZIO_WAIT_DONE] = 1;
 		mutex_exit(&zio->io_lock);
 
 		/*
 		 * "The Godfather" I/O monitors its children but is
 		 * not a true parent to them. It will track them through
 		 * the pipeline but severs its ties whenever they get into
 		 * trouble (e.g. suspended). This allows "The Godfather"
 		 * I/O to return status without blocking.
 		 */
 		zl = NULL;
 		for (pio = zio_walk_parents(zio, &zl); pio != NULL;
 		    pio = pio_next) {
 			zio_link_t *remove_zl = zl;
 			pio_next = zio_walk_parents(zio, &zl);
 
 			if ((pio->io_flags & ZIO_FLAG_GODFATHER) &&
 			    (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND)) {
 				zio_remove_child(pio, zio, remove_zl);
 				/*
 				 * This is a rare code path, so we don't
 				 * bother with "next_to_execute".
 				 */
 				zio_notify_parent(pio, zio, ZIO_WAIT_DONE,
 				    NULL);
 			}
 		}
 
 		if ((pio = zio_unique_parent(zio)) != NULL) {
 			/*
 			 * We're not a root i/o, so there's nothing to do
 			 * but notify our parent.  Don't propagate errors
 			 * upward since we haven't permanently failed yet.
 			 */
 			ASSERT(!(zio->io_flags & ZIO_FLAG_GODFATHER));
 			zio->io_flags |= ZIO_FLAG_DONT_PROPAGATE;
 			/*
 			 * This is a rare code path, so we don't bother with
 			 * "next_to_execute".
 			 */
 			zio_notify_parent(pio, zio, ZIO_WAIT_DONE, NULL);
 		} else if (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND) {
 			/*
 			 * We'd fail again if we reexecuted now, so suspend
 			 * until conditions improve (e.g. device comes online).
 			 */
 			zio_suspend(zio->io_spa, zio, ZIO_SUSPEND_IOERR);
 		} else {
 			/*
 			 * Reexecution is potentially a huge amount of work.
 			 * Hand it off to the otherwise-unused claim taskq.
 			 */
 			spa_taskq_dispatch(zio->io_spa,
 			    ZIO_TYPE_CLAIM, ZIO_TASKQ_ISSUE,
 			    zio_reexecute, zio, B_FALSE);
 		}
 		return (NULL);
 	}
 
 	ASSERT(list_is_empty(&zio->io_child_list));
 	ASSERT(zio->io_reexecute == 0);
 	ASSERT(zio->io_error == 0 || (zio->io_flags & ZIO_FLAG_CANFAIL));
 
 	/*
 	 * Report any checksum errors, since the I/O is complete.
 	 */
 	while (zio->io_cksum_report != NULL) {
 		zio_cksum_report_t *zcr = zio->io_cksum_report;
 		zio->io_cksum_report = zcr->zcr_next;
 		zcr->zcr_next = NULL;
 		zcr->zcr_finish(zcr, NULL);
 		zfs_ereport_free_checksum(zcr);
 	}
 
 	/*
 	 * It is the responsibility of the done callback to ensure that this
 	 * particular zio is no longer discoverable for adoption, and as
 	 * such, cannot acquire any new parents.
 	 */
 	if (zio->io_done)
 		zio->io_done(zio);
 
 	mutex_enter(&zio->io_lock);
 	zio->io_state[ZIO_WAIT_DONE] = 1;
 	mutex_exit(&zio->io_lock);
 
 	/*
 	 * We are done executing this zio.  We may want to execute a parent
 	 * next.  See the comment in zio_notify_parent().
 	 */
 	zio_t *next_to_execute = NULL;
 	zl = NULL;
 	for (pio = zio_walk_parents(zio, &zl); pio != NULL; pio = pio_next) {
 		zio_link_t *remove_zl = zl;
 		pio_next = zio_walk_parents(zio, &zl);
 		zio_remove_child(pio, zio, remove_zl);
 		zio_notify_parent(pio, zio, ZIO_WAIT_DONE, &next_to_execute);
 	}
 
 	if (zio->io_waiter != NULL) {
 		mutex_enter(&zio->io_lock);
 		zio->io_executor = NULL;
 		cv_broadcast(&zio->io_cv);
 		mutex_exit(&zio->io_lock);
 	} else {
 		zio_destroy(zio);
 	}
 
 	return (next_to_execute);
 }
 
 /*
  * ==========================================================================
  * I/O pipeline definition
  * ==========================================================================
  */
 static zio_pipe_stage_t *zio_pipeline[] = {
 	NULL,
 	zio_read_bp_init,
 	zio_write_bp_init,
 	zio_free_bp_init,
 	zio_issue_async,
 	zio_write_compress,
 	zio_encrypt,
 	zio_checksum_generate,
 	zio_nop_write,
 	zio_brt_free,
 	zio_ddt_read_start,
 	zio_ddt_read_done,
 	zio_ddt_write,
 	zio_ddt_free,
 	zio_gang_assemble,
 	zio_gang_issue,
 	zio_dva_throttle,
 	zio_dva_allocate,
 	zio_dva_free,
 	zio_dva_claim,
 	zio_ready,
 	zio_vdev_io_start,
 	zio_vdev_io_done,
 	zio_vdev_io_assess,
 	zio_checksum_verify,
 	zio_dio_checksum_verify,
 	zio_done
 };
 
 
 
 
 /*
  * Compare two zbookmark_phys_t's to see which we would reach first in a
  * pre-order traversal of the object tree.
  *
  * This is simple in every case aside from the meta-dnode object. For all other
  * objects, we traverse them in order (object 1 before object 2, and so on).
  * However, all of these objects are traversed while traversing object 0, since
  * the data it points to is the list of objects.  Thus, we need to convert to a
  * canonical representation so we can compare meta-dnode bookmarks to
  * non-meta-dnode bookmarks.
  *
  * We do this by calculating "equivalents" for each field of the zbookmark.
  * zbookmarks outside of the meta-dnode use their own object and level, and
  * calculate the level 0 equivalent (the first L0 blkid that is contained in the
  * blocks this bookmark refers to) by multiplying their blkid by their span
  * (the number of L0 blocks contained within one block at their level).
  * zbookmarks inside the meta-dnode calculate their object equivalent
  * (which is L0equiv * dnodes per data block), use 0 for their L0equiv, and use
  * level + 1<<31 (any value larger than a level could ever be) for their level.
  * This causes them to always compare before a bookmark in their object
  * equivalent, compare appropriately to bookmarks in other objects, and to
  * compare appropriately to other bookmarks in the meta-dnode.
  */
 int
 zbookmark_compare(uint16_t dbss1, uint8_t ibs1, uint16_t dbss2, uint8_t ibs2,
     const zbookmark_phys_t *zb1, const zbookmark_phys_t *zb2)
 {
 	/*
 	 * These variables represent the "equivalent" values for the zbookmark,
 	 * after converting zbookmarks inside the meta dnode to their
 	 * normal-object equivalents.
 	 */
 	uint64_t zb1obj, zb2obj;
 	uint64_t zb1L0, zb2L0;
 	uint64_t zb1level, zb2level;
 
 	if (zb1->zb_object == zb2->zb_object &&
 	    zb1->zb_level == zb2->zb_level &&
 	    zb1->zb_blkid == zb2->zb_blkid)
 		return (0);
 
 	IMPLY(zb1->zb_level > 0, ibs1 >= SPA_MINBLOCKSHIFT);
 	IMPLY(zb2->zb_level > 0, ibs2 >= SPA_MINBLOCKSHIFT);
 
 	/*
 	 * BP_SPANB calculates the span in blocks.
 	 */
 	zb1L0 = (zb1->zb_blkid) * BP_SPANB(ibs1, zb1->zb_level);
 	zb2L0 = (zb2->zb_blkid) * BP_SPANB(ibs2, zb2->zb_level);
 
 	if (zb1->zb_object == DMU_META_DNODE_OBJECT) {
 		zb1obj = zb1L0 * (dbss1 << (SPA_MINBLOCKSHIFT - DNODE_SHIFT));
 		zb1L0 = 0;
 		zb1level = zb1->zb_level + COMPARE_META_LEVEL;
 	} else {
 		zb1obj = zb1->zb_object;
 		zb1level = zb1->zb_level;
 	}
 
 	if (zb2->zb_object == DMU_META_DNODE_OBJECT) {
 		zb2obj = zb2L0 * (dbss2 << (SPA_MINBLOCKSHIFT - DNODE_SHIFT));
 		zb2L0 = 0;
 		zb2level = zb2->zb_level + COMPARE_META_LEVEL;
 	} else {
 		zb2obj = zb2->zb_object;
 		zb2level = zb2->zb_level;
 	}
 
 	/* Now that we have a canonical representation, do the comparison. */
 	if (zb1obj != zb2obj)
 		return (zb1obj < zb2obj ? -1 : 1);
 	else if (zb1L0 != zb2L0)
 		return (zb1L0 < zb2L0 ? -1 : 1);
 	else if (zb1level != zb2level)
 		return (zb1level > zb2level ? -1 : 1);
 	/*
 	 * This can (theoretically) happen if the bookmarks have the same object
 	 * and level, but different blkids, if the block sizes are not the same.
 	 * There is presently no way to change the indirect block sizes
 	 */
 	return (0);
 }
 
 /*
  *  This function checks the following: given that last_block is the place that
  *  our traversal stopped last time, does that guarantee that we've visited
  *  every node under subtree_root?  Therefore, we can't just use the raw output
  *  of zbookmark_compare.  We have to pass in a modified version of
  *  subtree_root; by incrementing the block id, and then checking whether
  *  last_block is before or equal to that, we can tell whether or not having
  *  visited last_block implies that all of subtree_root's children have been
  *  visited.
  */
 boolean_t
 zbookmark_subtree_completed(const dnode_phys_t *dnp,
     const zbookmark_phys_t *subtree_root, const zbookmark_phys_t *last_block)
 {
 	zbookmark_phys_t mod_zb = *subtree_root;
 	mod_zb.zb_blkid++;
 	ASSERT0(last_block->zb_level);
 
 	/* The objset_phys_t isn't before anything. */
 	if (dnp == NULL)
 		return (B_FALSE);
 
 	/*
 	 * We pass in 1ULL << (DNODE_BLOCK_SHIFT - SPA_MINBLOCKSHIFT) for the
 	 * data block size in sectors, because that variable is only used if
 	 * the bookmark refers to a block in the meta-dnode.  Since we don't
 	 * know without examining it what object it refers to, and there's no
 	 * harm in passing in this value in other cases, we always pass it in.
 	 *
 	 * We pass in 0 for the indirect block size shift because zb2 must be
 	 * level 0.  The indirect block size is only used to calculate the span
 	 * of the bookmark, but since the bookmark must be level 0, the span is
 	 * always 1, so the math works out.
 	 *
 	 * If you make changes to how the zbookmark_compare code works, be sure
 	 * to make sure that this code still works afterwards.
 	 */
 	return (zbookmark_compare(dnp->dn_datablkszsec, dnp->dn_indblkshift,
 	    1ULL << (DNODE_BLOCK_SHIFT - SPA_MINBLOCKSHIFT), 0, &mod_zb,
 	    last_block) <= 0);
 }
 
 /*
  * This function is similar to zbookmark_subtree_completed(), but returns true
  * if subtree_root is equal or ahead of last_block, i.e. still to be done.
  */
 boolean_t
 zbookmark_subtree_tbd(const dnode_phys_t *dnp,
     const zbookmark_phys_t *subtree_root, const zbookmark_phys_t *last_block)
 {
 	ASSERT0(last_block->zb_level);
 	if (dnp == NULL)
 		return (B_FALSE);
 	return (zbookmark_compare(dnp->dn_datablkszsec, dnp->dn_indblkshift,
 	    1ULL << (DNODE_BLOCK_SHIFT - SPA_MINBLOCKSHIFT), 0, subtree_root,
 	    last_block) >= 0);
 }
 
 EXPORT_SYMBOL(zio_type_name);
 EXPORT_SYMBOL(zio_buf_alloc);
 EXPORT_SYMBOL(zio_data_buf_alloc);
 EXPORT_SYMBOL(zio_buf_free);
 EXPORT_SYMBOL(zio_data_buf_free);
 
 ZFS_MODULE_PARAM(zfs_zio, zio_, slow_io_ms, INT, ZMOD_RW,
 	"Max I/O completion time (milliseconds) before marking it as slow");
 
 ZFS_MODULE_PARAM(zfs_zio, zio_, requeue_io_start_cut_in_line, INT, ZMOD_RW,
 	"Prioritize requeued I/O");
 
 ZFS_MODULE_PARAM(zfs, zfs_, sync_pass_deferred_free,  UINT, ZMOD_RW,
 	"Defer frees starting in this pass");
 
 ZFS_MODULE_PARAM(zfs, zfs_, sync_pass_dont_compress, UINT, ZMOD_RW,
 	"Don't compress starting in this pass");
 
 ZFS_MODULE_PARAM(zfs, zfs_, sync_pass_rewrite, UINT, ZMOD_RW,
 	"Rewrite new bps starting in this pass");
 
 ZFS_MODULE_PARAM(zfs_zio, zio_, dva_throttle_enabled, INT, ZMOD_RW,
 	"Throttle block allocations in the ZIO pipeline");
 
 ZFS_MODULE_PARAM(zfs_zio, zio_, deadman_log_all, INT, ZMOD_RW,
 	"Log all slow ZIOs, not just those with vdevs");
diff --git a/sys/contrib/openzfs/rpm/generic/zfs.spec.in b/sys/contrib/openzfs/rpm/generic/zfs.spec.in
index c7a00c61f6bb..d0d850af2629 100644
--- a/sys/contrib/openzfs/rpm/generic/zfs.spec.in
+++ b/sys/contrib/openzfs/rpm/generic/zfs.spec.in
@@ -1,590 +1,593 @@
 %global _sbindir    /sbin
 %global _libdir     /%{_lib}
 
 # Set the default udev directory based on distribution.
 %if %{undefined _udevdir}
 %if 0%{?rhel}%{?fedora}%{?centos}%{?suse_version}%{?openEuler}
 %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%{?rhel}%{?fedora}%{?centos}%{?suse_version}%{?openEuler}
 %global _udevruledir    %{_prefix}/lib/udev/rules.d
 %else
 %global _udevruledir    /lib/udev/rules.d
 %endif
 %endif
 
 # Set the default _bashcompletiondir directory based on distribution.
 %if %{undefined _bashcompletiondir}
 %if 0%{?rhel}%{?fedora}%{?centos}%{?suse_version}%{?openEuler}
 %global _bashcompletiondir    /etc/bash_completion.d
 %else
 %global _bashcompletiondir    /usr/share/bash-completion
 %endif
 %endif
 
 # Set the default dracut directory based on distribution.
 %if %{undefined _dracutdir}
 %if 0%{?rhel}%{?fedora}%{?centos}%{?suse_version}%{?openEuler}
 %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    ubsan
 %bcond_with    systemd
 %bcond_with    pam
 %bcond_without pyzfs
 
 # Generic enable switch for systemd
 %if %{with systemd}
 %define _systemd 1
 %endif
 
 # Distros below support systemd
 %if 0%{?rhel}%{?fedora}%{?centos}%{?suse_version}%{?openEuler}
 %define _systemd 1
 %endif
 
 # When not specified default to distribution provided version.
 %if %{undefined __use_python}
 %define __python                  /usr/bin/python3
 %define __python_pkg_version      3
 %else
 %define __python                  %{__use_python}
 %define __python_pkg_version      %{__use_python_pkg_version}
 %endif
 %define __python_sitelib          %(%{__python} -Esc "from distutils.sysconfig import get_python_lib; print(get_python_lib())" 2>/dev/null || %{__python} -Esc "import sysconfig; print(sysconfig.get_path('purelib'))")
 
 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%{?_isa} = %{version}-%{release}
+Requires:       libzpool6%{?_isa} = %{version}-%{release}
 Requires:       libnvpair3%{?_isa} = %{version}-%{release}
 Requires:       libuutil3%{?_isa} = %{version}-%{release}
-Requires:       libzfs5%{?_isa} = %{version}-%{release}
+Requires:       libzfs6%{?_isa} = %{version}-%{release}
 Requires:       %{name}-kmod = %{version}
 Provides:       %{name}-kmod-common = %{version}-%{release}
 Obsoletes:      spl <= %{version}
 
 # 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}%{?centos}%{?fedora}%{?suse_version}%{?openEuler}
 BuildRequires:  gcc, make
 BuildRequires:  zlib-devel
 BuildRequires:  libuuid-devel
 BuildRequires:  libblkid-devel
 BuildRequires:  libudev-devel
 BuildRequires:  libattr-devel
 BuildRequires:  openssl-devel
 %if 0%{?fedora}%{?suse_version}%{?openEuler} || 0%{?rhel} >= 8 || 0%{?centos} >= 8
 BuildRequires:  libtirpc-devel
 %endif
 
 %if (0%{?fedora}%{?suse_version}%{?openEuler}) || (0%{?rhel} && 0%{?rhel} < 9)
 # 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
 
 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
+%package -n libzpool6
 Summary:        Native ZFS pool library for Linux
 Group:          System Environment/Kernel
 Obsoletes:      libzpool2 <= %{version}
 Obsoletes:      libzpool4 <= %{version}
+Obsoletes:      libzpool5 <= %{version}
 
-%description -n libzpool5
+%description -n libzpool6
 This package contains the zpool library, which provides support
 for managing zpools
 
 %if %{defined ldconfig_scriptlets}
-%ldconfig_scriptlets -n libzpool5
+%ldconfig_scriptlets -n libzpool6
 %else
-%post -n libzpool5 -p /sbin/ldconfig
-%postun -n libzpool5 -p /sbin/ldconfig
+%post -n libzpool6 -p /sbin/ldconfig
+%postun -n libzpool6 -p /sbin/ldconfig
 %endif
 
 %package -n libnvpair3
 Summary:        Solaris name-value library for Linux
 Group:          System Environment/Kernel
 Obsoletes:      libnvpair1 <= %{version}
 
 %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 <= %{version}
 
 %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
+%package -n libzfs6
 Summary:        Native ZFS filesystem library for Linux
 Group:          System Environment/Kernel
 Obsoletes:      libzfs2 <= %{version}
 Obsoletes:      libzfs4 <= %{version}
+Obsoletes:      libzfs5 <= %{version}
 
-%description -n libzfs5
+%description -n libzfs6
 This package provides support for managing ZFS filesystems
 
 %if %{defined ldconfig_scriptlets}
-%ldconfig_scriptlets -n libzfs5
+%ldconfig_scriptlets -n libzfs6
 %else
-%post -n libzfs5 -p /sbin/ldconfig
-%postun -n libzfs5 -p /sbin/ldconfig
+%post -n libzfs6 -p /sbin/ldconfig
+%postun -n libzfs6 -p /sbin/ldconfig
 %endif
 
-%package -n libzfs5-devel
+%package -n libzfs6-devel
 Summary:        Development headers
 Group:          System Environment/Kernel
-Requires:       libzfs5%{?_isa} = %{version}-%{release}
-Requires:       libzpool5%{?_isa} = %{version}-%{release}
+Requires:       libzfs6%{?_isa} = %{version}-%{release}
+Requires:       libzpool6%{?_isa} = %{version}-%{release}
 Requires:       libnvpair3%{?_isa} = %{version}-%{release}
 Requires:       libuutil3%{?_isa} = %{version}-%{release}
-Provides:       libzpool5-devel = %{version}-%{release}
+Provides:       libzpool6-devel = %{version}-%{release}
 Provides:       libnvpair3-devel = %{version}-%{release}
 Provides:       libuutil3-devel = %{version}-%{release}
 Obsoletes:      zfs-devel <= %{version}
 Obsoletes:      libzfs2-devel <= %{version}
 Obsoletes:      libzfs4-devel <= %{version}
+Obsoletes:      libzfs5-devel <= %{version}
 
-%description -n libzfs5-devel
+%description -n libzfs6-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}%{?centos}%{?fedora}%{?suse_version}%{?openEuler}
 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}
 # Enforce `python36-` package prefix for CentOS 7
 # since dependencies come from EPEL and are named this way
 %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}-%{release}
+Requires:       libzfs6 = %{version}-%{release}
 Requires:       libnvpair3 = %{version}-%{release}
 Requires:       libffi
 Requires:       python%{__python_pkg_version}
 
 %if 0%{?centos} == 7
 Requires:       python36-cffi
 %else
 Requires:       python%{__python_pkg_version}-cffi
 %endif
 
 %if 0%{?rhel}%{?centos}%{?fedora}%{?suse_version}%{?openEuler}
 %if 0%{?centos} == 7
 BuildRequires:  python36-packaging
 BuildRequires:  python36-devel
 BuildRequires:  python36-cffi
 BuildRequires:  python36-setuptools
 %else
 BuildRequires:  python%{__python_pkg_version}-packaging
 BuildRequires:  python%{__python_pkg_version}-devel
 BuildRequires:  python%{__python_pkg_version}-cffi
 BuildRequires:  python%{__python_pkg_version}-setuptools
 %endif
 
 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:       initramfs-tools
 
 %description initramfs
 This package contains a initramfs module used to construct an initramfs
 image which is ZFS aware.
 %endif
 
 %if %{with pam}
 %package -n pam_zfs_key
 Summary:        PAM module for encrypted ZFS datasets
 
 %if 0%{?rhel}%{?centos}%{?fedora}%{?suse_version}%{?openEuler}
 BuildRequires:  pam-devel
 %endif
 
 %description -n pam_zfs_key
 This package contains the pam_zfs_key PAM module, which provides
 support for unlocking datasets on user login.
 %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 %{with ubsan}
     %define ubsan --enable-ubsan
 %else
     %define ubsan --disable-ubsan
 %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} \
     %{ubsan} \
     %{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 \
     -or -name zilstat \) \
     -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-load-key
     /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-load-key
     /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 3 scripts
 %{_bindir}/arc_summary
 %{_bindir}/arcstat
 %{_bindir}/dbufstat
 %{_bindir}/zilstat
 # 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/*
 
 %config(noreplace) %{_bashcompletiondir}/zfs
 %config(noreplace) %{_bashcompletiondir}/zpool
 
-%files -n libzpool5
+%files -n libzpool6
 %{_libdir}/libzpool.so.*
 
 %files -n libnvpair3
 %{_libdir}/libnvpair.so.*
 
 %files -n libuutil3
 %{_libdir}/libuutil.so.*
 
-%files -n libzfs5
+%files -n libzfs6
 %{_libdir}/libzfs*.so.*
 
-%files -n libzfs5-devel
+%files -n libzfs6-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.md
 %{_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.md
 /usr/share/initramfs-tools/*
 %else
 # Since we're not building the initramfs package,
 # ignore those files.
 %exclude /usr/share/initramfs-tools
 %endif
 
 %if %{with pam}
 %files -n pam_zfs_key
 %{_libdir}/security/*
 %{_datadir}/pam-configs/*
 %endif
diff --git a/sys/contrib/openzfs/tests/runfiles/common.run b/sys/contrib/openzfs/tests/runfiles/common.run
index f89a4b3e0aae..fc4adc42d00a 100644
--- a/sys/contrib/openzfs/tests/runfiles/common.run
+++ b/sys/contrib/openzfs/tests/runfiles/common.run
@@ -1,1070 +1,1070 @@
 #
 # 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 = ['dosmode', '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', 'alloc_class_014_neg', 'alloc_class_015_pos']
 tags = ['functional', 'alloc_class']
 
 [tests/functional/append]
 tests = ['file_append', 'threadsappend_001_pos']
 tags = ['functional', 'append']
 
 [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/bclone]
 tests = ['bclone_crossfs_corner_cases_limited',
     'bclone_crossfs_data',
     'bclone_crossfs_embedded',
     'bclone_crossfs_hole',
     'bclone_diffprops_all',
     'bclone_diffprops_checksum',
     'bclone_diffprops_compress',
     'bclone_diffprops_copies',
     'bclone_diffprops_recordsize',
     'bclone_prop_sync',
     'bclone_samefs_corner_cases_limited',
     'bclone_samefs_data',
     'bclone_samefs_embedded',
     'bclone_samefs_hole']
 tags = ['functional', 'bclone']
 timeout = 7200
 
 [tests/functional/block_cloning]
 tests = ['block_cloning_clone_mmap_cached',
     'block_cloning_copyfilerange',
     'block_cloning_copyfilerange_partial',
     'block_cloning_copyfilerange_fallback',
     'block_cloning_disabled_copyfilerange',
     'block_cloning_copyfilerange_cross_dataset',
     'block_cloning_cross_enc_dataset',
     'block_cloning_copyfilerange_fallback_same_txg',
     'block_cloning_replay', 'block_cloning_replay_encrypted',
     'block_cloning_lwb_buffer_overflow', 'block_cloning_clone_mmap_write',
     'block_cloning_rlimit_fsize']
 tags = ['functional', 'block_cloning']
 
 [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_rename', 'tst.snapshot_simple',
     'tst.bookmark.create', 'tst.bookmark.copy',
     'tst.terminate_by_signal'
     ]
 tags = ['functional', 'channel_program', 'synctask_core']
 
 [tests/functional/checksum]
 tests = ['run_edonr_test', 'run_sha2_test', 'run_skein_test', 'run_blake3_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/json]
 tests = ['json_sanity']
 tags = ['functional', 'cli_root', 'json']
 
 [tests/functional/cli_root/zinject]
 tests = ['zinject_args']
 pre =
 post =
 tags = ['functional', 'cli_root', 'zinject']
 
 [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_encrypted', 'zdb_label_checksum',
     'zdb_object_range_neg', 'zdb_object_range_pos', 'zdb_objset_id',
     'zdb_decompress_zstd', 'zdb_recover', 'zdb_recover_2', 'zdb_backup']
 pre =
 post =
 tags = ['functional', 'cli_root', 'zdb']
 timeout = 1200
 
 [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',
     'zfs_clone_rm_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/zpool_prefetch]
 tests = ['zpool_prefetch_001_pos']
 tags = ['functional', 'cli_root', 'zpool_prefetch']
 
 [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', 'zfs_diff_mangle']
 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_https', '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', 'zfs_mount_recursive']
 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',
     'receive-o-x_props_aliases',
     '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',
     'zfs_receive_-wR-encrypted-mix', 'zfs_receive_corrective',
     'zfs_receive_compressed_corrective', 'zfs_receive_large_block_corrective']
 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_encrypted_unloaded',
     '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', 'zfs_set_nomount']
 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',
     'zfs_share_after_mount']
 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', 'zfs_wait_getsubopt']
 tags = ['functional', 'cli_root', 'zfs_wait']
 
 [tests/functional/cli_root/zhack]
 tests = ['zhack_label_repair_001', 'zhack_label_repair_002',
     'zhack_label_repair_003', 'zhack_label_repair_004']
 pre =
 post =
 tags = ['functional', 'cli_root', 'zhack']
 
 [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',
     'zpool_add--allow-ashift-mismatch']
 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',
     'zpool_export_parallel_pos', 'zpool_export_parallel_admin']
 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', 'vdev_get_001_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_log_missing',
     'import_paths_changed',
     'import_rewind_config_changed',
     'import_rewind_device_replaced',
     'zpool_import_status', 'zpool_import_parallel_pos',
     'zpool_import_parallel_neg', 'zpool_import_parallel_admin']
 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_uninit',
     '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_reguid]
 tests = ['zpool_reguid_001_pos', 'zpool_reguid_002_neg']
 tags = ['functional', 'cli_root', 'zpool_reguid']
 
 [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',
     'zpool_resilver_concurrent']
 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',
     'zpool_error_scrub_001_pos', 'zpool_error_scrub_002_pos',
     'zpool_error_scrub_003_pos', 'zpool_error_scrub_004_pos']
 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', 'vdev_set_001_pos',
     'user_property_001_pos', 'user_property_002_neg']
 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_003_pos', 'zpool_status_004_pos',
     'zpool_status_005_pos', 'zpool_status_006_pos',
     'zpool_status_007_pos', 'zpool_status_008_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',
     'zilstat_001_pos']
 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_005_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', 'cp_files_002_pos', 'cp_stress']
 tags = ['functional', 'cp_files']
 
 [tests/functional/zap_shrink]
 tests = ['zap_shrink_001_pos']
 tags = ['functional', 'zap_shrink']
 
 [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/dedup]
 tests = ['dedup_legacy_create', 'dedup_fdt_create', 'dedup_fdt_import',
     'dedup_legacy_create', 'dedup_legacy_import', 'dedup_legacy_fdt_upgrade',
     'dedup_legacy_fdt_mixed', 'dedup_quota']
 pre =
 post =
 tags = ['functional', 'dedup']
 
 [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/direct]
 tests = ['dio_aligned_block', 'dio_async_always', 'dio_async_fio_ioengines',
     'dio_compression', 'dio_dedup', 'dio_encryption', 'dio_grow_block',
     'dio_max_recordsize', 'dio_mixed', 'dio_mmap', 'dio_overwrites',
-    'dio_property', 'dio_random', 'dio_recordsize', 'dio_unaligned_block',
-    'dio_unaligned_filesize']
+    'dio_property', 'dio_random', 'dio_read_verify', 'dio_recordsize',
+    'dio_unaligned_block', 'dio_unaligned_filesize']
 tags = ['functional', 'direct']
 
 [tests/functional/exec]
 tests = ['exec_001_pos', 'exec_002_neg']
 tags = ['functional', 'exec']
 
 [tests/functional/fallocate]
 tests = ['fallocate_punch-hole']
 tags = ['functional', 'fallocate']
 
 [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]
 pre =
 post =
 tests = ['hkdf_test']
 tags = ['functional', 'hkdf']
 
 [tests/functional/inheritance]
 tests = ['inherit_001_pos']
 pre =
 tags = ['functional', 'inheritance']
 
 [tests/functional/io]
 tests = ['mmap', 'posixaio', 'psync', 'sync']
 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/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_mixed', 'mmap_read_001_pos', 'mmap_seek_001_pos',
     'mmap_sync_001_pos', 'mmap_write_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', 'enospc_ganging', 'enospc_rm']
 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_expand_001_pos',
     'raidz_expand_002_pos', 'raidz_expand_003_neg', 'raidz_expand_003_pos',
     'raidz_expand_004_pos', 'raidz_expand_005_pos', 'raidz_expand_006_neg',
     'raidz_expand_007_neg']
 tags = ['functional', 'raidz']
 timeout = 1200
 
 [tests/functional/redundancy]
 tests = ['redundancy_draid', 'redundancy_draid1', 'redundancy_draid2',
     'redundancy_draid3', 'redundancy_draid_damaged1',
     'redundancy_draid_damaged2', '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_indirect',
     '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', 'removal_reservation']
 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', 'rsend_025_pos',
     'rsend_026_neg', 'rsend_027_pos', 'rsend_028_neg', 'rsend_029_neg',
     'rsend_030_pos', 'rsend_031_pos', 'send-c_verify_ratio',
     'send-c_verify_contents', 'send-c_props', 'send-c_incremental',
     'send-c_volume', 'send-c_zstream_recompress', '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_incremental',
     'send_encrypted_freeobjects', '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', 'send_raw_spill_block', 'send_raw_ashift',
     'send_raw_large_blocks']
 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', 'slog_016_pos']
 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_018_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/stat]
 tests = ['stat_001_pos']
 tags = ['functional', 'stat']
 
 [tests/functional/suid]
 tests = ['suid_write_to_suid', 'suid_write_to_sgid', 'suid_write_to_suid_sgid',
     'suid_write_to_none', 'suid_write_zil_replay']
 tags = ['functional', 'suid']
 
 [tests/functional/trim]
 tests = ['autotrim_integrity', 'autotrim_config', 'autotrim_trim_integrity',
     'trim_integrity', 'trim_config', 'trim_l2arc']
 tags = ['functional', 'trim']
 
 [tests/functional/truncate]
 tests = ['truncate_001_pos', 'truncate_002_pos', 'truncate_timestamps']
 tags = ['functional', 'truncate']
 
 [tests/functional/upgrade]
 tests = ['upgrade_userobj_001_pos', 'upgrade_readonly_pool']
 tags = ['functional', 'upgrade']
 
 [tests/functional/userquota]
 tests = [
     'userquota_001_pos', 'userquota_002_pos', 'userquota_003_pos',
     'userquota_004_pos', 'userquota_005_neg', 'userquota_006_pos',
     'userquota_007_pos', 'userquota_008_pos', 'userquota_009_pos',
     'userquota_010_pos', 'userquota_011_pos', 'userquota_012_neg',
     'userspace_001_pos', 'userspace_002_pos', 'userspace_encrypted',
     'userspace_send_encrypted', 'userspace_encrypted_13709']
 tags = ['functional', 'userquota']
 
 [tests/functional/vdev_disk:Linux]
 pre =
 post =
 tests = ['page_alignment']
 tags = ['functional', 'vdev_disk']
 
 [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', 'xattr_compat']
 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_trim', 'zvol_misc_volmode', 'zvol_misc_zil']
 tags = ['functional', 'zvol', 'zvol_misc']
 
 [tests/functional/zvol/zvol_stress]
 tests = ['zvol_stress']
 tags = ['functional', 'zvol', 'zvol_stress']
 
 [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/zfs-tests/cmd/manipulate_user_buffer.c b/sys/contrib/openzfs/tests/zfs-tests/cmd/manipulate_user_buffer.c
index 714f42200557..173581094443 100644
--- a/sys/contrib/openzfs/tests/zfs-tests/cmd/manipulate_user_buffer.c
+++ b/sys/contrib/openzfs/tests/zfs-tests/cmd/manipulate_user_buffer.c
@@ -1,272 +1,334 @@
 /*
  * CDDL HEADER START
  *
  * The contents of this file are subject to the terms of the
  * Common Development and Distribution License (the "License").
  * You may not use this file except in compliance with the License.
  *
  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  * or https://opensource.org/licenses/CDDL-1.0.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  *
  * When distributing Covered Code, include this CDDL HEADER in each
  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  * If applicable, add the following below this CDDL HEADER, with the
  * fields enclosed by brackets "[]" replaced with your own identifying
  * information: Portions Copyright [yyyy] [name of copyright owner]
  *
  * CDDL HEADER END
  */
 
 /*
- * Copyright (c) 2022 by Triad National Security, LLC.
+ * Copyright (c) 2024 by Triad National Security, LLC.
  */
 
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <pthread.h>
 #include <assert.h>
 
 #ifndef MIN
 #define	MIN(a, b)	((a) < (b)) ? (a) : (b)
 #endif
 
-static char *outputfile = NULL;
+static char *filename = NULL;
 static int blocksize = 131072; /* 128K */
-static int wr_err_expected = 0;
+static int err_expected = 0;
+static int read_op = 0;
+static int write_op = 0;
 static int numblocks = 100;
 static char *execname = NULL;
 static int print_usage = 0;
 static int randompattern = 0;
-static int ofd;
+static int fd;
 char *buf = NULL;
 
 typedef struct {
-	int entire_file_written;
+	int entire_file_completed;
 } pthread_args_t;
 
 static void
 usage(void)
 {
 	(void) fprintf(stderr,
-	    "usage %s -o outputfile [-b blocksize] [-e wr_error_expected]\n"
-	    "         [-n numblocks] [-p randpattern] [-h help]\n"
+	    "usage %s -f filename [-b blocksize] [-e wr_error_expected]\n"
+	    "         [-n numblocks] [-p randompattern] -r read_op \n"
+	    "         -w write_op [-h help]\n"
 	    "\n"
 	    "Testing whether checksum verify works correctly for O_DIRECT.\n"
 	    "when manipulating the contents of a userspace buffer.\n"
 	    "\n"
-	    "    outputfile:      File to write to.\n"
-	    "    blocksize:       Size of each block to write (must be at \n"
-	    "                     least >= 512).\n"
-	    "    wr_err_expected: Whether pwrite() is expected to return EIO\n"
-	    "                     while manipulating the contents of the\n"
-	    "                     buffer.\n"
-	    "    numblocks:       Total number of blocksized blocks to\n"
-	    "                     write.\n"
-	    "    randpattern:     Fill data buffer with random data. Default\n"
-	    "                     behavior is to fill the buffer with the \n"
-	    "                     known data pattern (0xdeadbeef).\n"
+	    "    filename:       File to read or write to.\n"
+	    "    blocksize:      Size of each block to write (must be at \n"
+	    "                    least >= 512).\n"
+	    "    err_expected:   Whether write() is expected to return EIO\n"
+	    "                    while manipulating the contents of the\n"
+	    "                    buffer.\n"
+	    "    numblocks:      Total number of blocksized blocks to\n"
+	    "                    write.\n"
+	    "    read_op:        Perform reads to the filename file while\n"
+	    "                    while manipulating the buffer contents\n"
+	    "    write_op:       Perform writes to the filename file while\n"
+	    "                    manipulating the buffer contents\n"
+	    "    randompattern:  Fill data buffer with random data for \n"
+	    "                    writes. Default behavior is to fill the \n"
+	    "                    buffer with known data pattern (0xdeadbeef)\n"
 	    "    help:           Print usage information and exit.\n"
 	    "\n"
 	    "    Required parameters:\n"
-	    "    outputfile\n"
+	    "    filename\n"
+	    "    read_op or write_op\n"
 	    "\n"
 	    "    Default Values:\n"
 	    "    blocksize       -> 131072\n"
 	    "    wr_err_expexted -> false\n"
 	    "    numblocks       -> 100\n"
-	    "    randpattern     -> false\n",
+	    "    randompattern   -> false\n",
 	    execname);
 	(void) exit(1);
 }
 
 static void
 parse_options(int argc, char *argv[])
 {
 	int c;
 	int errflag = 0;
 	extern char *optarg;
 	extern int optind, optopt;
 	execname = argv[0];
 
-	while ((c = getopt(argc, argv, "b:ehn:o:p")) != -1) {
+	while ((c = getopt(argc, argv, "b:ef:hn:rw")) != -1) {
 		switch (c) {
 			case 'b':
 				blocksize = atoi(optarg);
 				break;
 
 			case 'e':
-				wr_err_expected = 1;
+				err_expected = 1;
 				break;
 
+			case 'f':
+				filename = optarg;
+				break;
+
+
 			case 'h':
 				print_usage = 1;
 				break;
 
 			case 'n':
 				numblocks = atoi(optarg);
 				break;
 
-			case 'o':
-				outputfile = optarg;
+			case 'r':
+				read_op = 1;
 				break;
 
-			case 'p':
-				randompattern = 1;
+			case 'w':
+				write_op = 1;
 				break;
 
 			case ':':
 				(void) fprintf(stderr,
 				    "Option -%c requires an opertand\n",
 				    optopt);
 				errflag++;
 				break;
 			case '?':
 			default:
 				(void) fprintf(stderr,
 				    "Unrecognized option: -%c\n", optopt);
 				errflag++;
 				break;
 		}
 	}
 
 	if (errflag || print_usage == 1)
 		(void) usage();
 
-	if (blocksize < 512 || outputfile == NULL || numblocks <= 0) {
+	if (blocksize < 512 || filename == NULL || numblocks <= 0 ||
+	    (read_op == 0 && write_op == 0)) {
 		(void) fprintf(stderr,
 		    "Required paramater(s) missing or invalid.\n");
 		(void) usage();
 	}
 }
 
 /*
  * Write blocksize * numblocks to the file using O_DIRECT.
  */
 static void *
 write_thread(void *arg)
 {
 	size_t offset = 0;
 	int total_data = blocksize * numblocks;
 	int left = total_data;
 	ssize_t wrote = 0;
 	pthread_args_t *args = (pthread_args_t *)arg;
 
-	while (!args->entire_file_written) {
-		wrote = pwrite(ofd, buf, blocksize, offset);
+	while (!args->entire_file_completed) {
+		wrote = pwrite(fd, buf, blocksize, offset);
 		if (wrote != blocksize) {
-			if (wr_err_expected)
+			if (err_expected)
 				assert(errno == EIO);
 			else
 				exit(2);
 		}
 
 		offset = ((offset + blocksize) % total_data);
 		left -= blocksize;
 
 		if (left == 0)
-			args->entire_file_written = 1;
+			args->entire_file_completed = 1;
+	}
+
+	pthread_exit(NULL);
+}
+
+/*
+ * Read blocksize * numblocks to the file using O_DIRECT.
+ */
+static void *
+read_thread(void *arg)
+{
+	size_t offset = 0;
+	int total_data = blocksize * numblocks;
+	int left = total_data;
+	ssize_t read = 0;
+	pthread_args_t *args = (pthread_args_t *)arg;
+
+	while (!args->entire_file_completed) {
+		read = pread(fd, buf, blocksize, offset);
+		if (read != blocksize) {
+			exit(2);
+		}
+
+		offset = ((offset + blocksize) % total_data);
+		left -= blocksize;
+
+		if (left == 0)
+			args->entire_file_completed = 1;
 	}
 
 	pthread_exit(NULL);
 }
 
 /*
  * Update the buffers contents with random data.
  */
 static void *
 manipulate_buf_thread(void *arg)
 {
 	size_t rand_offset;
 	char rand_char;
 	pthread_args_t *args = (pthread_args_t *)arg;
 
-	while (!args->entire_file_written) {
+	while (!args->entire_file_completed) {
 		rand_offset = (rand() % blocksize);
 		rand_char = (rand() % (126 - 33) + 33);
 		buf[rand_offset] = rand_char;
 	}
 
 	pthread_exit(NULL);
 }
 
 int
 main(int argc, char *argv[])
 {
 	const char *datapattern = "0xdeadbeef";
-	int ofd_flags = O_WRONLY | O_CREAT | O_DIRECT;
+	int fd_flags = O_DIRECT;
 	mode_t mode = S_IRUSR | S_IWUSR;
-	pthread_t write_thr;
+	pthread_t io_thr;
 	pthread_t manipul_thr;
 	int left = blocksize;
 	int offset = 0;
 	int rc;
 	pthread_args_t args = { 0 };
 
 	parse_options(argc, argv);
 
-	ofd = open(outputfile, ofd_flags, mode);
-	if (ofd == -1) {
-		(void) fprintf(stderr, "%s, %s\n", execname, outputfile);
+	if (write_op) {
+		fd_flags |= (O_WRONLY | O_CREAT);
+	} else {
+		fd_flags |= O_RDONLY;
+	}
+
+	fd = open(filename, fd_flags, mode);
+	if (fd == -1) {
+		(void) fprintf(stderr, "%s, %s\n", execname, filename);
 		perror("open");
 		exit(2);
 	}
 
 	int err = posix_memalign((void **)&buf, sysconf(_SC_PAGE_SIZE),
 	    blocksize);
 	if (err != 0) {
 		(void) fprintf(stderr,
 		    "%s: %s\n", execname, strerror(err));
 		exit(2);
 	}
 
-	if (!randompattern) {
-		/* Putting known data pattern in buffer */
-		while (left) {
-			size_t amt = MIN(strlen(datapattern), left);
-			memcpy(&buf[offset], datapattern, amt);
-			offset += amt;
-			left -= amt;
+	if (write_op) {
+		if (!randompattern) {
+			/* Putting known data pattern in buffer */
+			while (left) {
+				size_t amt = MIN(strlen(datapattern), left);
+				memcpy(&buf[offset], datapattern, amt);
+				offset += amt;
+				left -= amt;
+			}
+		} else {
+			/* Putting random data in buffer */
+			for (int i = 0; i < blocksize; i++)
+				buf[i] = rand();
 		}
-	} else {
-		/* Putting random data in buffer */
-		for (int i = 0; i < blocksize; i++)
-			buf[i] = rand();
 	}
 
-	/*
-	 * Writing using O_DIRECT while manipulating the buffer contents until
-	 * the entire file is written.
-	 */
 	if ((rc = pthread_create(&manipul_thr, NULL, manipulate_buf_thread,
 	    &args))) {
 		fprintf(stderr, "error: pthreads_create, manipul_thr, "
 		    "rc: %d\n", rc);
 		exit(2);
 	}
 
-	if ((rc = pthread_create(&write_thr, NULL, write_thread, &args))) {
-		fprintf(stderr, "error: pthreads_create, write_thr, "
-		    "rc: %d\n", rc);
-		exit(2);
+	if (write_op) {
+		/*
+		 * Writing using O_DIRECT while manipulating the buffer contents
+		 * until the entire file is written.
+		 */
+		if ((rc = pthread_create(&io_thr, NULL, write_thread, &args))) {
+			fprintf(stderr, "error: pthreads_create, io_thr, "
+			    "rc: %d\n", rc);
+			exit(2);
+		}
+	} else {
+		/*
+		 * Reading using O_DIRECT while manipulating the buffer contents
+		 * until the entire file is read.
+		 */
+		if ((rc = pthread_create(&io_thr, NULL, read_thread, &args))) {
+			fprintf(stderr, "error: pthreads_create, io_thr, "
+			    "rc: %d\n", rc);
+			exit(2);
+		}
 	}
 
-	pthread_join(write_thr, NULL);
+	pthread_join(io_thr, NULL);
 	pthread_join(manipul_thr, NULL);
 
-	assert(args.entire_file_written == 1);
+	assert(args.entire_file_completed == 1);
 
-	(void) close(ofd);
+	(void) close(fd);
 
 	free(buf);
 
 	return (0);
 }
diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/Makefile.am b/sys/contrib/openzfs/tests/zfs-tests/tests/Makefile.am
index 206ee8ac1542..bc767b9f624f 100644
--- a/sys/contrib/openzfs/tests/zfs-tests/tests/Makefile.am
+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/Makefile.am
@@ -1,2178 +1,2179 @@
 CLEANFILES =
 dist_noinst_DATA =
 include $(top_srcdir)/config/Substfiles.am
 
 
 datadir_zfs_tests_testsdir = $(datadir)/$(PACKAGE)/zfs-tests/tests
 nobase_dist_datadir_zfs_tests_tests_DATA = \
 	perf/nfs-sample.cfg \
 	perf/perf.shlib \
 	\
 	perf/fio/mkfiles.fio \
 	perf/fio/random_reads.fio \
 	perf/fio/random_readwrite.fio \
 	perf/fio/random_readwrite_fixed.fio \
 	perf/fio/random_writes.fio \
 	perf/fio/sequential_reads.fio \
 	perf/fio/sequential_readwrite.fio \
 	perf/fio/sequential_writes.fio
 
 nobase_dist_datadir_zfs_tests_tests_SCRIPTS = \
 	perf/regression/random_reads.ksh \
 	perf/regression/random_readwrite.ksh \
 	perf/regression/random_readwrite_fixed.ksh \
 	perf/regression/random_writes.ksh \
 	perf/regression/random_writes_zil.ksh \
 	perf/regression/sequential_reads_arc_cached_clone.ksh \
 	perf/regression/sequential_reads_arc_cached.ksh \
 	perf/regression/sequential_reads_dbuf_cached.ksh \
 	perf/regression/sequential_reads.ksh \
 	perf/regression/sequential_writes.ksh \
 	perf/regression/setup.ksh \
 	\
 	perf/scripts/prefetch_io.sh
 
 # These lists can be regenerated by running make regen-tests at the root, or, on a *clean* source:
 #   find functional/ ! -type d ! -name .gitignore ! -name .dirstamp ! -name '*.Po' ! -executable   -name '*.in'                                              | sort | sed 's/\.in$//;s/^/\t/;$!s/$/ \\/'
 #   find functional/ ! -type d ! -name .gitignore ! -name .dirstamp ! -name '*.Po'   -executable   -name '*.in'                                              | sort | sed 's/\.in$//;s/^/\t/;$!s/$/ \\/'
 #   find functional/ ! -type d ! -name .gitignore ! -name .dirstamp ! -name '*.Po'               ! -name '*.in' ! -name '*.c'  | grep  -Fe /simd -e /tmpfile | sort | sed           's/^/\t/;$!s/$/ \\/'
 #   find functional/ ! -type d ! -name .gitignore ! -name .dirstamp ! -name '*.Po' ! -executable ! -name '*.in' ! -name '*.c'  | grep -vFe /simd -e /tmpfile | sort | sed           's/^/\t/;$!s/$/ \\/'
 #   find functional/ ! -type d ! -name .gitignore ! -name .dirstamp ! -name '*.Po'   -executable ! -name '*.in' ! -name '*.c'  | grep -vFe /simd -e /tmpfile | sort | sed           's/^/\t/;$!s/$/ \\/'
 #
 # simd and tmpfile are Linux-only and not installed elsewhere
 #
 # C programs are specced in ../Makefile.am above as part of the main Makefile
 
 find_common := find functional/ ! -type d ! -name .gitignore ! -name .dirstamp ! -name '*.Po'
 regen:
 	@$(MAKE) -C $(top_builddir) clean
 	@$(MAKE) clean
 	$(SED) $(ac_inplace) '/^# -- >8 --/q' Makefile.am
 	echo >> Makefile.am
 	echo 'nobase_nodist_datadir_zfs_tests_tests_DATA = \' >> Makefile.am
 	$(find_common) ! -executable   -name '*.in'                                              | sort | sed 's/\.in$$//;s/^/\t/;$$!s/$$/ \\/' >> Makefile.am
 	echo 'nobase_nodist_datadir_zfs_tests_tests_SCRIPTS = \' >> Makefile.am
 	$(find_common)   -executable   -name '*.in'                                              | sort | sed 's/\.in$$//;s/^/\t/;$$!s/$$/ \\/' >> Makefile.am
 	echo >> Makefile.am
 	echo 'SUBSTFILES += $$(nobase_nodist_datadir_zfs_tests_tests_DATA) $$(nobase_nodist_datadir_zfs_tests_tests_SCRIPTS)' >> Makefile.am
 	echo >> Makefile.am
 	echo 'if BUILD_LINUX' >> Makefile.am
 	echo 'nobase_dist_datadir_zfs_tests_tests_SCRIPTS += \' >> Makefile.am
 	$(find_common)               ! -name '*.in' ! -name '*.c'  | grep  -Fe /simd -e /tmpfile | sort | sed           's/^/\t/;$$!s/$$/ \\/' >> Makefile.am
 	echo 'endif' >> Makefile.am
 	echo >> Makefile.am
 	echo 'nobase_dist_datadir_zfs_tests_tests_DATA += \' >> Makefile.am
 	$(find_common) ! -executable ! -name '*.in' ! -name '*.c'  | grep -vFe /simd -e /tmpfile | sort | sed           's/^/\t/;$$!s/$$/ \\/' >> Makefile.am
 	echo >> Makefile.am
 	echo 'nobase_dist_datadir_zfs_tests_tests_SCRIPTS += \' >> Makefile.am
 	$(find_common)   -executable ! -name '*.in' ! -name '*.c'  | grep -vFe /simd -e /tmpfile | sort | sed           's/^/\t/;$$!s/$$/ \\/' >> Makefile.am
 
 # -- >8 --
 
 nobase_nodist_datadir_zfs_tests_tests_DATA = \
 	functional/pam/utilities.kshlib
 nobase_nodist_datadir_zfs_tests_tests_SCRIPTS = \
 	functional/pyzfs/pyzfs_unittest.ksh
 
 SUBSTFILES += $(nobase_nodist_datadir_zfs_tests_tests_DATA) $(nobase_nodist_datadir_zfs_tests_tests_SCRIPTS)
 
 if BUILD_LINUX
 nobase_dist_datadir_zfs_tests_tests_SCRIPTS += \
 	functional/simd/simd_supported.ksh \
 	functional/tmpfile/cleanup.ksh \
 	functional/tmpfile/setup.ksh
 endif
 
 nobase_dist_datadir_zfs_tests_tests_DATA += \
 	functional/acl/acl.cfg \
 	functional/acl/acl_common.kshlib \
 	functional/alloc_class/alloc_class.cfg \
 	functional/alloc_class/alloc_class.kshlib \
 	functional/atime/atime.cfg \
 	functional/atime/atime_common.kshlib \
 	functional/bclone/bclone.cfg \
 	functional/bclone/bclone_common.kshlib \
 	functional/bclone/bclone_corner_cases.kshlib \
 	functional/block_cloning/block_cloning.kshlib \
 	functional/cache/cache.cfg \
 	functional/cache/cache.kshlib \
 	functional/cachefile/cachefile.cfg \
 	functional/cachefile/cachefile.kshlib \
 	functional/casenorm/casenorm.cfg \
 	functional/casenorm/casenorm.kshlib \
 	functional/channel_program/channel_common.kshlib \
 	functional/channel_program/lua_core/tst.args_to_lua.out \
 	functional/channel_program/lua_core/tst.args_to_lua.zcp \
 	functional/channel_program/lua_core/tst.divide_by_zero.err \
 	functional/channel_program/lua_core/tst.divide_by_zero.zcp \
 	functional/channel_program/lua_core/tst.exists.zcp \
 	functional/channel_program/lua_core/tst.large_prog.out \
 	functional/channel_program/lua_core/tst.large_prog.zcp \
 	functional/channel_program/lua_core/tst.lib_base.lua \
 	functional/channel_program/lua_core/tst.lib_coroutine.lua \
 	functional/channel_program/lua_core/tst.lib_strings.lua \
 	functional/channel_program/lua_core/tst.lib_table.lua \
 	functional/channel_program/lua_core/tst.nested_neg.zcp \
 	functional/channel_program/lua_core/tst.nested_pos.zcp \
 	functional/channel_program/lua_core/tst.recursive.zcp \
 	functional/channel_program/lua_core/tst.return_large.zcp \
 	functional/channel_program/lua_core/tst.return_recursive_table.zcp \
 	functional/channel_program/lua_core/tst.stack_gsub.err \
 	functional/channel_program/lua_core/tst.stack_gsub.zcp \
 	functional/channel_program/lua_core/tst.timeout.zcp \
 	functional/channel_program/synctask_core/tst.bookmark.copy.zcp \
 	functional/channel_program/synctask_core/tst.bookmark.create.zcp \
 	functional/channel_program/synctask_core/tst.get_index_props.out \
 	functional/channel_program/synctask_core/tst.get_index_props.zcp \
 	functional/channel_program/synctask_core/tst.get_number_props.out \
 	functional/channel_program/synctask_core/tst.get_number_props.zcp \
 	functional/channel_program/synctask_core/tst.get_string_props.out \
 	functional/channel_program/synctask_core/tst.get_string_props.zcp \
 	functional/channel_program/synctask_core/tst.promote_conflict.zcp \
 	functional/channel_program/synctask_core/tst.set_props.zcp \
 	functional/channel_program/synctask_core/tst.snapshot_destroy.zcp \
 	functional/channel_program/synctask_core/tst.snapshot_neg.zcp \
 	functional/channel_program/synctask_core/tst.snapshot_recursive.zcp \
 	functional/channel_program/synctask_core/tst.snapshot_rename.zcp \
 	functional/channel_program/synctask_core/tst.snapshot_simple.zcp \
 	functional/checksum/default.cfg \
 	functional/clean_mirror/clean_mirror_common.kshlib \
 	functional/clean_mirror/default.cfg \
 	functional/cli_root/cli_common.kshlib \
 	functional/cli_root/zfs_copies/zfs_copies.cfg \
 	functional/cli_root/zfs_copies/zfs_copies.kshlib \
 	functional/cli_root/zfs_create/properties.kshlib \
 	functional/cli_root/zfs_create/zfs_create.cfg \
 	functional/cli_root/zfs_create/zfs_create_common.kshlib \
 	functional/cli_root/zfs_destroy/zfs_destroy.cfg \
 	functional/cli_root/zfs_destroy/zfs_destroy_common.kshlib \
 	functional/cli_root/zfs_get/zfs_get_common.kshlib \
 	functional/cli_root/zfs_get/zfs_get_list_d.kshlib \
 	functional/cli_root/zfs_jail/jail.conf \
 	functional/cli_root/zfs_load-key/HEXKEY \
 	functional/cli_root/zfs_load-key/PASSPHRASE \
 	functional/cli_root/zfs_load-key/RAWKEY \
 	functional/cli_root/zfs_load-key/zfs_load-key.cfg \
 	functional/cli_root/zfs_load-key/zfs_load-key_common.kshlib \
 	functional/cli_root/zfs_mount/zfs_mount.cfg \
 	functional/cli_root/zfs_mount/zfs_mount.kshlib \
 	functional/cli_root/zfs_promote/zfs_promote.cfg \
 	functional/cli_root/zfs_receive/zstd_test_data.txt \
 	functional/cli_root/zfs_rename/zfs_rename.cfg \
 	functional/cli_root/zfs_rename/zfs_rename.kshlib \
 	functional/cli_root/zfs_rollback/zfs_rollback.cfg \
 	functional/cli_root/zfs_rollback/zfs_rollback_common.kshlib \
 	functional/cli_root/zfs_send/zfs_send.cfg \
 	functional/cli_root/zfs_set/zfs_set_common.kshlib \
 	functional/cli_root/zfs_share/zfs_share.cfg \
 	functional/cli_root/zfs_snapshot/zfs_snapshot.cfg \
 	functional/cli_root/zfs_unmount/zfs_unmount.cfg \
 	functional/cli_root/zfs_unmount/zfs_unmount.kshlib \
 	functional/cli_root/zfs_upgrade/zfs_upgrade.kshlib \
 	functional/cli_root/zfs_wait/zfs_wait.kshlib \
 	functional/cli_root/zpool_add/zpool_add.cfg \
 	functional/cli_root/zpool_add/zpool_add.kshlib \
 	functional/cli_root/zpool_clear/zpool_clear.cfg \
 	functional/cli_root/zpool_create/draidcfg.gz \
 	functional/cli_root/zpool_create/zpool_create.cfg \
 	functional/cli_root/zpool_create/zpool_create.shlib \
 	functional/cli_root/zpool_destroy/zpool_destroy.cfg \
 	functional/cli_root/zpool_events/zpool_events.cfg \
 	functional/cli_root/zpool_events/zpool_events.kshlib \
 	functional/cli_root/zpool_expand/zpool_expand.cfg \
 	functional/cli_root/zpool_export/zpool_export.cfg \
 	functional/cli_root/zpool_export/zpool_export.kshlib \
 	functional/cli_root/zpool_get/vdev_get.cfg \
 	functional/cli_root/zpool_get/zpool_get.cfg \
 	functional/cli_root/zpool_get/zpool_get_parsable.cfg \
 	functional/cli_root/zpool_import/blockfiles/cryptv0.dat.bz2 \
 	functional/cli_root/zpool_import/blockfiles/missing_ivset.dat.bz2 \
 	functional/cli_root/zpool_import/blockfiles/unclean_export.dat.bz2 \
 	functional/cli_root/zpool_import/zpool_import.cfg \
 	functional/cli_root/zpool_import/zpool_import.kshlib \
 	functional/cli_root/zpool_initialize/zpool_initialize.kshlib \
 	functional/cli_root/zpool_labelclear/labelclear.cfg \
 	functional/cli_root/zpool_remove/zpool_remove.cfg \
 	functional/cli_root/zpool_reopen/zpool_reopen.cfg \
 	functional/cli_root/zpool_reopen/zpool_reopen.shlib \
 	functional/cli_root/zpool_resilver/zpool_resilver.cfg \
 	functional/cli_root/zpool_scrub/zpool_scrub.cfg \
 	functional/cli_root/zpool_split/zpool_split.cfg \
 	functional/cli_root/zpool_trim/zpool_trim.kshlib \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-broken-mirror1.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-broken-mirror2.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v10.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v11.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v12.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v13.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v14.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v15.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v1.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v1mirror1.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v1mirror2.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v1mirror3.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v1raidz1.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v1raidz2.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v1raidz3.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v1stripe1.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v1stripe2.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v1stripe3.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v2.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v2mirror1.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v2mirror2.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v2mirror3.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v2raidz1.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v2raidz2.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v2raidz3.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v2stripe1.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v2stripe2.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v2stripe3.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v3.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v3hotspare1.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v3hotspare2.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v3hotspare3.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v3mirror1.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v3mirror2.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v3mirror3.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v3raidz1.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v3raidz21.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v3raidz22.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v3raidz23.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v3raidz2.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v3raidz3.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v3stripe1.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v3stripe2.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v3stripe3.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v4.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v5.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v6.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v7.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v8.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v999.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-v9.dat.bz2 \
 	functional/cli_root/zpool_upgrade/blockfiles/zfs-pool-vBROKEN.dat.bz2 \
 	functional/cli_root/zpool_upgrade/zpool_upgrade.cfg \
 	functional/cli_root/zpool_upgrade/zpool_upgrade.kshlib \
 	functional/cli_root/zpool_wait/zpool_wait.kshlib \
 	functional/cli_root/zhack/library.kshlib \
 	functional/cli_user/misc/misc.cfg \
 	functional/cli_user/zfs_list/zfs_list.cfg \
 	functional/cli_user/zfs_list/zfs_list.kshlib \
 	functional/compression/compress.cfg \
 	functional/compression/testpool_zstd.tar.gz \
 	functional/deadman/deadman.cfg \
 	functional/delegate/delegate.cfg \
 	functional/delegate/delegate_common.kshlib \
 	functional/devices/devices.cfg \
 	functional/devices/devices_common.kshlib \
 	functional/direct/dio.cfg \
 	functional/direct/dio.kshlib \
 	functional/events/events.cfg \
 	functional/events/events_common.kshlib \
 	functional/fault/fault.cfg \
 	functional/grow/grow.cfg \
 	functional/history/history.cfg \
 	functional/history/history_common.kshlib \
 	functional/history/i386.migratedpool.DAT.Z \
 	functional/history/i386.orig_history.txt \
 	functional/history/sparc.migratedpool.DAT.Z \
 	functional/history/sparc.orig_history.txt \
 	functional/history/zfs-pool-v4.dat.Z \
 	functional/inheritance/config001.cfg \
 	functional/inheritance/config002.cfg \
 	functional/inheritance/config003.cfg \
 	functional/inheritance/config004.cfg \
 	functional/inheritance/config005.cfg \
 	functional/inheritance/config006.cfg \
 	functional/inheritance/config007.cfg \
 	functional/inheritance/config008.cfg \
 	functional/inheritance/config009.cfg \
 	functional/inheritance/config010.cfg \
 	functional/inheritance/config011.cfg \
 	functional/inheritance/config012.cfg \
 	functional/inheritance/config013.cfg \
 	functional/inheritance/config014.cfg \
 	functional/inheritance/config015.cfg \
 	functional/inheritance/config016.cfg \
 	functional/inheritance/config017.cfg \
 	functional/inheritance/config018.cfg \
 	functional/inheritance/config019.cfg \
 	functional/inheritance/config020.cfg \
 	functional/inheritance/config021.cfg \
 	functional/inheritance/config022.cfg \
 	functional/inheritance/config023.cfg \
 	functional/inheritance/config024.cfg \
 	functional/inheritance/inherit.kshlib \
 	functional/inheritance/README.config \
 	functional/inheritance/README.state \
 	functional/inheritance/state001.cfg \
 	functional/inheritance/state002.cfg \
 	functional/inheritance/state003.cfg \
 	functional/inheritance/state004.cfg \
 	functional/inheritance/state005.cfg \
 	functional/inheritance/state006.cfg \
 	functional/inheritance/state007.cfg \
 	functional/inheritance/state008.cfg \
 	functional/inheritance/state009.cfg \
 	functional/inheritance/state010.cfg \
 	functional/inheritance/state011.cfg \
 	functional/inheritance/state012.cfg \
 	functional/inheritance/state013.cfg \
 	functional/inheritance/state014.cfg \
 	functional/inheritance/state015.cfg \
 	functional/inheritance/state016.cfg \
 	functional/inheritance/state017.cfg \
 	functional/inheritance/state018.cfg \
 	functional/inheritance/state019.cfg \
 	functional/inheritance/state020.cfg \
 	functional/inheritance/state021.cfg \
 	functional/inheritance/state022.cfg \
 	functional/inheritance/state023.cfg \
 	functional/inheritance/state024.cfg \
 	functional/inuse/inuse.cfg \
 	functional/io/io.cfg \
 	functional/l2arc/l2arc.cfg \
 	functional/largest_pool/largest_pool.cfg \
 	functional/migration/migration.cfg \
 	functional/migration/migration.kshlib \
 	functional/mmap/mmap.cfg \
 	functional/mmp/mmp.cfg \
 	functional/mmp/mmp.kshlib \
 	functional/mv_files/mv_files.cfg \
 	functional/mv_files/mv_files_common.kshlib \
 	functional/nopwrite/nopwrite.shlib \
 	functional/no_space/enospc.cfg \
 	functional/online_offline/online_offline.cfg \
 	functional/pool_checkpoint/pool_checkpoint.kshlib \
 	functional/projectquota/projectquota.cfg \
 	functional/projectquota/projectquota_common.kshlib \
 	functional/quota/quota.cfg \
 	functional/quota/quota.kshlib \
 	functional/redacted_send/redacted.cfg \
 	functional/redacted_send/redacted.kshlib \
 	functional/redundancy/redundancy.cfg \
 	functional/redundancy/redundancy.kshlib \
 	functional/refreserv/refreserv.cfg \
 	functional/removal/removal.kshlib \
 	functional/replacement/replacement.cfg \
 	functional/reservation/reservation.cfg \
 	functional/reservation/reservation.shlib \
 	functional/rsend/dedup_encrypted_zvol.bz2 \
 	functional/rsend/dedup_encrypted_zvol.zsend.bz2 \
 	functional/rsend/dedup.zsend.bz2 \
 	functional/rsend/fs.tar.gz \
 	functional/rsend/rsend.cfg \
 	functional/rsend/rsend.kshlib \
 	functional/scrub_mirror/default.cfg \
 	functional/scrub_mirror/scrub_mirror_common.kshlib \
 	functional/slog/slog.cfg \
 	functional/slog/slog.kshlib \
 	functional/snapshot/snapshot.cfg \
 	functional/snapused/snapused.kshlib \
 	functional/sparse/sparse.cfg \
 	functional/trim/trim.cfg \
 	functional/trim/trim.kshlib \
 	functional/truncate/truncate.cfg \
 	functional/upgrade/upgrade_common.kshlib \
 	functional/user_namespace/user_namespace.cfg \
 	functional/user_namespace/user_namespace_common.kshlib \
 	functional/userquota/13709_reproducer.bz2 \
 	functional/userquota/userquota.cfg \
 	functional/userquota/userquota_common.kshlib \
 	functional/vdev_zaps/vdev_zaps.kshlib \
 	functional/xattr/xattr.cfg \
 	functional/xattr/xattr_common.kshlib \
 	functional/zvol/zvol.cfg \
 	functional/zvol/zvol_cli/zvol_cli.cfg \
 	functional/zvol/zvol_common.shlib \
 	functional/zvol/zvol_ENOSPC/zvol_ENOSPC.cfg \
 	functional/zvol/zvol_misc/zvol_misc_common.kshlib \
 	functional/zvol/zvol_swap/zvol_swap.cfg \
 	functional/idmap_mount/idmap_mount.cfg \
 	functional/idmap_mount/idmap_mount_common.kshlib
 
 nobase_dist_datadir_zfs_tests_tests_SCRIPTS += \
 	functional/acl/off/cleanup.ksh \
 	functional/acl/off/dosmode.ksh \
 	functional/acl/off/posixmode.ksh \
 	functional/acl/off/setup.ksh \
 	functional/acl/posix/cleanup.ksh \
 	functional/acl/posix/posix_001_pos.ksh \
 	functional/acl/posix/posix_002_pos.ksh \
 	functional/acl/posix/posix_003_pos.ksh \
 	functional/acl/posix/posix_004_pos.ksh \
 	functional/acl/posix-sa/cleanup.ksh \
 	functional/acl/posix-sa/posix_001_pos.ksh \
 	functional/acl/posix-sa/posix_002_pos.ksh \
 	functional/acl/posix-sa/posix_003_pos.ksh \
 	functional/acl/posix-sa/posix_004_pos.ksh \
 	functional/acl/posix-sa/setup.ksh \
 	functional/acl/posix/setup.ksh \
 	functional/alloc_class/alloc_class_001_pos.ksh \
 	functional/alloc_class/alloc_class_002_neg.ksh \
 	functional/alloc_class/alloc_class_003_pos.ksh \
 	functional/alloc_class/alloc_class_004_pos.ksh \
 	functional/alloc_class/alloc_class_005_pos.ksh \
 	functional/alloc_class/alloc_class_006_pos.ksh \
 	functional/alloc_class/alloc_class_007_pos.ksh \
 	functional/alloc_class/alloc_class_008_pos.ksh \
 	functional/alloc_class/alloc_class_009_pos.ksh \
 	functional/alloc_class/alloc_class_010_pos.ksh \
 	functional/alloc_class/alloc_class_011_neg.ksh \
 	functional/alloc_class/alloc_class_012_pos.ksh \
 	functional/alloc_class/alloc_class_013_pos.ksh \
 	functional/alloc_class/alloc_class_014_neg.ksh \
 	functional/alloc_class/alloc_class_015_pos.ksh \
 	functional/alloc_class/cleanup.ksh \
 	functional/alloc_class/setup.ksh \
 	functional/append/file_append.ksh \
 	functional/append/threadsappend_001_pos.ksh \
 	functional/append/cleanup.ksh \
 	functional/append/setup.ksh \
 	functional/arc/arcstats_runtime_tuning.ksh \
 	functional/arc/cleanup.ksh \
 	functional/arc/dbufstats_001_pos.ksh \
 	functional/arc/dbufstats_002_pos.ksh \
 	functional/arc/dbufstats_003_pos.ksh \
 	functional/arc/setup.ksh \
 	functional/atime/atime_001_pos.ksh \
 	functional/atime/atime_002_neg.ksh \
 	functional/atime/atime_003_pos.ksh \
 	functional/atime/cleanup.ksh \
 	functional/atime/root_atime_off.ksh \
 	functional/atime/root_atime_on.ksh \
 	functional/atime/root_relatime_on.ksh \
 	functional/atime/setup.ksh \
 	functional/bclone/bclone_crossfs_corner_cases.ksh \
 	functional/bclone/bclone_crossfs_corner_cases_limited.ksh \
 	functional/bclone/bclone_crossfs_data.ksh \
 	functional/bclone/bclone_crossfs_embedded.ksh \
 	functional/bclone/bclone_crossfs_hole.ksh \
 	functional/bclone/bclone_diffprops_all.ksh \
 	functional/bclone/bclone_diffprops_checksum.ksh \
 	functional/bclone/bclone_diffprops_compress.ksh \
 	functional/bclone/bclone_diffprops_copies.ksh \
 	functional/bclone/bclone_diffprops_recordsize.ksh \
 	functional/bclone/bclone_prop_sync.ksh \
 	functional/bclone/bclone_samefs_corner_cases.ksh \
 	functional/bclone/bclone_samefs_corner_cases_limited.ksh \
 	functional/bclone/bclone_samefs_data.ksh \
 	functional/bclone/bclone_samefs_embedded.ksh \
 	functional/bclone/bclone_samefs_hole.ksh \
 	functional/bclone/cleanup.ksh \
 	functional/bclone/setup.ksh \
 	functional/block_cloning/cleanup.ksh \
 	functional/block_cloning/setup.ksh \
 	functional/block_cloning/block_cloning_clone_mmap_cached.ksh \
 	functional/block_cloning/block_cloning_clone_mmap_write.ksh \
 	functional/block_cloning/block_cloning_copyfilerange_cross_dataset.ksh \
 	functional/block_cloning/block_cloning_copyfilerange_fallback.ksh \
 	functional/block_cloning/block_cloning_copyfilerange_fallback_same_txg.ksh \
 	functional/block_cloning/block_cloning_copyfilerange.ksh \
 	functional/block_cloning/block_cloning_copyfilerange_partial.ksh \
 	functional/block_cloning/block_cloning_disabled_copyfilerange.ksh \
 	functional/block_cloning/block_cloning_disabled_ficlone.ksh \
 	functional/block_cloning/block_cloning_disabled_ficlonerange.ksh \
 	functional/block_cloning/block_cloning_ficlone.ksh \
 	functional/block_cloning/block_cloning_ficlonerange.ksh \
 	functional/block_cloning/block_cloning_ficlonerange_partial.ksh \
 	functional/block_cloning/block_cloning_cross_enc_dataset.ksh \
 	functional/block_cloning/block_cloning_replay.ksh \
 	functional/block_cloning/block_cloning_replay_encrypted.ksh \
 	functional/block_cloning/block_cloning_lwb_buffer_overflow.ksh \
 	functional/block_cloning/block_cloning_rlimit_fsize.ksh \
 	functional/bootfs/bootfs_001_pos.ksh \
 	functional/bootfs/bootfs_002_neg.ksh \
 	functional/bootfs/bootfs_003_pos.ksh \
 	functional/bootfs/bootfs_004_neg.ksh \
 	functional/bootfs/bootfs_005_neg.ksh \
 	functional/bootfs/bootfs_006_pos.ksh \
 	functional/bootfs/bootfs_007_pos.ksh \
 	functional/bootfs/bootfs_008_pos.ksh \
 	functional/bootfs/cleanup.ksh \
 	functional/bootfs/setup.ksh \
 	functional/btree/btree_negative.ksh \
 	functional/btree/btree_positive.ksh \
 	functional/cache/cache_001_pos.ksh \
 	functional/cache/cache_002_pos.ksh \
 	functional/cache/cache_003_pos.ksh \
 	functional/cache/cache_004_neg.ksh \
 	functional/cache/cache_005_neg.ksh \
 	functional/cache/cache_006_pos.ksh \
 	functional/cache/cache_007_neg.ksh \
 	functional/cache/cache_008_neg.ksh \
 	functional/cache/cache_009_pos.ksh \
 	functional/cache/cache_010_pos.ksh \
 	functional/cache/cache_011_pos.ksh \
 	functional/cache/cache_012_pos.ksh \
 	functional/cache/cleanup.ksh \
 	functional/cachefile/cachefile_001_pos.ksh \
 	functional/cachefile/cachefile_002_pos.ksh \
 	functional/cachefile/cachefile_003_pos.ksh \
 	functional/cachefile/cachefile_004_pos.ksh \
 	functional/cachefile/cleanup.ksh \
 	functional/cachefile/setup.ksh \
 	functional/cache/setup.ksh \
 	functional/casenorm/case_all_values.ksh \
 	functional/casenorm/cleanup.ksh \
 	functional/casenorm/insensitive_formd_delete.ksh \
 	functional/casenorm/insensitive_formd_lookup.ksh \
 	functional/casenorm/insensitive_none_delete.ksh \
 	functional/casenorm/insensitive_none_lookup.ksh \
 	functional/casenorm/mixed_create_failure.ksh \
 	functional/casenorm/mixed_formd_delete.ksh \
 	functional/casenorm/mixed_formd_lookup_ci.ksh \
 	functional/casenorm/mixed_formd_lookup.ksh \
 	functional/casenorm/mixed_none_delete.ksh \
 	functional/casenorm/mixed_none_lookup_ci.ksh \
 	functional/casenorm/mixed_none_lookup.ksh \
 	functional/casenorm/norm_all_values.ksh \
 	functional/casenorm/sensitive_formd_delete.ksh \
 	functional/casenorm/sensitive_formd_lookup.ksh \
 	functional/casenorm/sensitive_none_delete.ksh \
 	functional/casenorm/sensitive_none_lookup.ksh \
 	functional/casenorm/setup.ksh \
 	functional/channel_program/lua_core/cleanup.ksh \
 	functional/channel_program/lua_core/setup.ksh \
 	functional/channel_program/lua_core/tst.args_to_lua.ksh \
 	functional/channel_program/lua_core/tst.divide_by_zero.ksh \
 	functional/channel_program/lua_core/tst.exists.ksh \
 	functional/channel_program/lua_core/tst.integer_illegal.ksh \
 	functional/channel_program/lua_core/tst.integer_overflow.ksh \
 	functional/channel_program/lua_core/tst.language_functions_neg.ksh \
 	functional/channel_program/lua_core/tst.language_functions_pos.ksh \
 	functional/channel_program/lua_core/tst.large_prog.ksh \
 	functional/channel_program/lua_core/tst.libraries.ksh \
 	functional/channel_program/lua_core/tst.memory_limit.ksh \
 	functional/channel_program/lua_core/tst.nested_neg.ksh \
 	functional/channel_program/lua_core/tst.nested_pos.ksh \
 	functional/channel_program/lua_core/tst.nvlist_to_lua.ksh \
 	functional/channel_program/lua_core/tst.recursive_neg.ksh \
 	functional/channel_program/lua_core/tst.recursive_pos.ksh \
 	functional/channel_program/lua_core/tst.return_large.ksh \
 	functional/channel_program/lua_core/tst.return_nvlist_neg.ksh \
 	functional/channel_program/lua_core/tst.return_nvlist_pos.ksh \
 	functional/channel_program/lua_core/tst.return_recursive_table.ksh \
 	functional/channel_program/lua_core/tst.stack_gsub.ksh \
 	functional/channel_program/lua_core/tst.timeout.ksh \
 	functional/channel_program/synctask_core/cleanup.ksh \
 	functional/channel_program/synctask_core/setup.ksh \
 	functional/channel_program/synctask_core/tst.bookmark.copy.ksh \
 	functional/channel_program/synctask_core/tst.bookmark.create.ksh \
 	functional/channel_program/synctask_core/tst.destroy_fs.ksh \
 	functional/channel_program/synctask_core/tst.destroy_snap.ksh \
 	functional/channel_program/synctask_core/tst.get_count_and_limit.ksh \
 	functional/channel_program/synctask_core/tst.get_index_props.ksh \
 	functional/channel_program/synctask_core/tst.get_mountpoint.ksh \
 	functional/channel_program/synctask_core/tst.get_neg.ksh \
 	functional/channel_program/synctask_core/tst.get_number_props.ksh \
 	functional/channel_program/synctask_core/tst.get_string_props.ksh \
 	functional/channel_program/synctask_core/tst.get_type.ksh \
 	functional/channel_program/synctask_core/tst.get_userquota.ksh \
 	functional/channel_program/synctask_core/tst.get_written.ksh \
 	functional/channel_program/synctask_core/tst.inherit.ksh \
 	functional/channel_program/synctask_core/tst.list_bookmarks.ksh \
 	functional/channel_program/synctask_core/tst.list_children.ksh \
 	functional/channel_program/synctask_core/tst.list_clones.ksh \
 	functional/channel_program/synctask_core/tst.list_holds.ksh \
 	functional/channel_program/synctask_core/tst.list_snapshots.ksh \
 	functional/channel_program/synctask_core/tst.list_system_props.ksh \
 	functional/channel_program/synctask_core/tst.list_user_props.ksh \
 	functional/channel_program/synctask_core/tst.parse_args_neg.ksh \
 	functional/channel_program/synctask_core/tst.promote_conflict.ksh \
 	functional/channel_program/synctask_core/tst.promote_multiple.ksh \
 	functional/channel_program/synctask_core/tst.promote_simple.ksh \
 	functional/channel_program/synctask_core/tst.rollback_mult.ksh \
 	functional/channel_program/synctask_core/tst.rollback_one.ksh \
 	functional/channel_program/synctask_core/tst.set_props.ksh \
 	functional/channel_program/synctask_core/tst.snapshot_destroy.ksh \
 	functional/channel_program/synctask_core/tst.snapshot_neg.ksh \
 	functional/channel_program/synctask_core/tst.snapshot_recursive.ksh \
 	functional/channel_program/synctask_core/tst.snapshot_rename.ksh \
 	functional/channel_program/synctask_core/tst.snapshot_simple.ksh \
 	functional/channel_program/synctask_core/tst.terminate_by_signal.ksh \
 	functional/chattr/chattr_001_pos.ksh \
 	functional/chattr/chattr_002_neg.ksh \
 	functional/chattr/cleanup.ksh \
 	functional/chattr/setup.ksh \
 	functional/checksum/cleanup.ksh \
 	functional/checksum/filetest_001_pos.ksh \
 	functional/checksum/filetest_002_pos.ksh \
 	functional/checksum/run_blake3_test.ksh \
 	functional/checksum/run_edonr_test.ksh \
 	functional/checksum/run_sha2_test.ksh \
 	functional/checksum/run_skein_test.ksh \
 	functional/checksum/setup.ksh \
 	functional/clean_mirror/clean_mirror_001_pos.ksh \
 	functional/clean_mirror/clean_mirror_002_pos.ksh \
 	functional/clean_mirror/clean_mirror_003_pos.ksh \
 	functional/clean_mirror/clean_mirror_004_pos.ksh \
 	functional/clean_mirror/cleanup.ksh \
 	functional/clean_mirror/setup.ksh \
 	functional/cli_root/json/cleanup.ksh \
 	functional/cli_root/json/setup.ksh \
 	functional/cli_root/json/json_sanity.ksh \
 	functional/cli_root/zinject/zinject_args.ksh \
 	functional/cli_root/zdb/zdb_002_pos.ksh \
 	functional/cli_root/zdb/zdb_003_pos.ksh \
 	functional/cli_root/zdb/zdb_004_pos.ksh \
 	functional/cli_root/zdb/zdb_005_pos.ksh \
 	functional/cli_root/zdb/zdb_006_pos.ksh \
 	functional/cli_root/zdb/zdb_args_neg.ksh \
 	functional/cli_root/zdb/zdb_args_pos.ksh \
 	functional/cli_root/zdb/zdb_backup.ksh \
 	functional/cli_root/zdb/zdb_block_size_histogram.ksh \
 	functional/cli_root/zdb/zdb_checksum.ksh \
 	functional/cli_root/zdb/zdb_decompress.ksh \
 	functional/cli_root/zdb/zdb_decompress_zstd.ksh \
 	functional/cli_root/zdb/zdb_display_block.ksh \
 	functional/cli_root/zdb/zdb_encrypted.ksh \
 	functional/cli_root/zdb/zdb_label_checksum.ksh \
 	functional/cli_root/zdb/zdb_object_range_neg.ksh \
 	functional/cli_root/zdb/zdb_object_range_pos.ksh \
 	functional/cli_root/zdb/zdb_objset_id.ksh \
 	functional/cli_root/zdb/zdb_recover_2.ksh \
 	functional/cli_root/zdb/zdb_recover.ksh \
 	functional/cli_root/zfs_bookmark/cleanup.ksh \
 	functional/cli_root/zfs_bookmark/setup.ksh \
 	functional/cli_root/zfs_bookmark/zfs_bookmark_cliargs.ksh \
 	functional/cli_root/zfs_change-key/cleanup.ksh \
 	functional/cli_root/zfs_change-key/setup.ksh \
 	functional/cli_root/zfs_change-key/zfs_change-key_child.ksh \
 	functional/cli_root/zfs_change-key/zfs_change-key_clones.ksh \
 	functional/cli_root/zfs_change-key/zfs_change-key_format.ksh \
 	functional/cli_root/zfs_change-key/zfs_change-key_inherit.ksh \
 	functional/cli_root/zfs_change-key/zfs_change-key.ksh \
 	functional/cli_root/zfs_change-key/zfs_change-key_load.ksh \
 	functional/cli_root/zfs_change-key/zfs_change-key_location.ksh \
 	functional/cli_root/zfs_change-key/zfs_change-key_pbkdf2iters.ksh \
 	functional/cli_root/zfs/cleanup.ksh \
 	functional/cli_root/zfs_clone/cleanup.ksh \
 	functional/cli_root/zfs_clone/setup.ksh \
 	functional/cli_root/zfs_clone/zfs_clone_001_neg.ksh \
 	functional/cli_root/zfs_clone/zfs_clone_002_pos.ksh \
 	functional/cli_root/zfs_clone/zfs_clone_003_pos.ksh \
 	functional/cli_root/zfs_clone/zfs_clone_004_pos.ksh \
 	functional/cli_root/zfs_clone/zfs_clone_005_pos.ksh \
 	functional/cli_root/zfs_clone/zfs_clone_006_pos.ksh \
 	functional/cli_root/zfs_clone/zfs_clone_007_pos.ksh \
 	functional/cli_root/zfs_clone/zfs_clone_008_neg.ksh \
 	functional/cli_root/zfs_clone/zfs_clone_009_neg.ksh \
 	functional/cli_root/zfs_clone/zfs_clone_010_pos.ksh \
 	functional/cli_root/zfs_clone/zfs_clone_deeply_nested.ksh \
 	functional/cli_root/zfs_clone/zfs_clone_encrypted.ksh \
 	functional/cli_root/zfs_clone/zfs_clone_rm_nested.ksh \
 	functional/cli_root/zfs_copies/cleanup.ksh \
 	functional/cli_root/zfs_copies/setup.ksh \
 	functional/cli_root/zfs_copies/zfs_copies_001_pos.ksh \
 	functional/cli_root/zfs_copies/zfs_copies_002_pos.ksh \
 	functional/cli_root/zfs_copies/zfs_copies_003_pos.ksh \
 	functional/cli_root/zfs_copies/zfs_copies_004_neg.ksh \
 	functional/cli_root/zfs_copies/zfs_copies_005_neg.ksh \
 	functional/cli_root/zfs_copies/zfs_copies_006_pos.ksh \
 	functional/cli_root/zfs_create/cleanup.ksh \
 	functional/cli_root/zfs_create/setup.ksh \
 	functional/cli_root/zfs_create/zfs_create_001_pos.ksh \
 	functional/cli_root/zfs_create/zfs_create_002_pos.ksh \
 	functional/cli_root/zfs_create/zfs_create_003_pos.ksh \
 	functional/cli_root/zfs_create/zfs_create_004_pos.ksh \
 	functional/cli_root/zfs_create/zfs_create_005_pos.ksh \
 	functional/cli_root/zfs_create/zfs_create_006_pos.ksh \
 	functional/cli_root/zfs_create/zfs_create_007_pos.ksh \
 	functional/cli_root/zfs_create/zfs_create_008_neg.ksh \
 	functional/cli_root/zfs_create/zfs_create_009_neg.ksh \
 	functional/cli_root/zfs_create/zfs_create_010_neg.ksh \
 	functional/cli_root/zfs_create/zfs_create_011_pos.ksh \
 	functional/cli_root/zfs_create/zfs_create_012_pos.ksh \
 	functional/cli_root/zfs_create/zfs_create_013_pos.ksh \
 	functional/cli_root/zfs_create/zfs_create_014_pos.ksh \
 	functional/cli_root/zfs_create/zfs_create_crypt_combos.ksh \
 	functional/cli_root/zfs_create/zfs_create_dryrun.ksh \
 	functional/cli_root/zfs_create/zfs_create_encrypted.ksh \
 	functional/cli_root/zfs_create/zfs_create_nomount.ksh \
 	functional/cli_root/zfs_create/zfs_create_verbose.ksh \
 	functional/cli_root/zfs_destroy/cleanup.ksh \
 	functional/cli_root/zfs_destroy/setup.ksh \
 	functional/cli_root/zfs_destroy/zfs_clone_livelist_condense_and_disable.ksh \
 	functional/cli_root/zfs_destroy/zfs_clone_livelist_condense_races.ksh \
 	functional/cli_root/zfs_destroy/zfs_clone_livelist_dedup.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_001_pos.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_002_pos.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_003_pos.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_004_pos.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_005_neg.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_006_neg.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_007_neg.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_008_pos.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_009_pos.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_010_pos.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_011_pos.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_012_pos.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_013_neg.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_014_pos.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_015_pos.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_016_pos.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_clone_livelist.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_dev_removal_condense.ksh \
 	functional/cli_root/zfs_destroy/zfs_destroy_dev_removal.ksh \
 	functional/cli_root/zfs_diff/cleanup.ksh \
 	functional/cli_root/zfs_diff/setup.ksh \
 	functional/cli_root/zfs_diff/zfs_diff_changes.ksh \
 	functional/cli_root/zfs_diff/zfs_diff_cliargs.ksh \
 	functional/cli_root/zfs_diff/zfs_diff_encrypted.ksh \
 	functional/cli_root/zfs_diff/zfs_diff_mangle.ksh \
 	functional/cli_root/zfs_diff/zfs_diff_timestamp.ksh \
 	functional/cli_root/zfs_diff/zfs_diff_types.ksh \
 	functional/cli_root/zfs_get/cleanup.ksh \
 	functional/cli_root/zfs_get/setup.ksh \
 	functional/cli_root/zfs_get/zfs_get_001_pos.ksh \
 	functional/cli_root/zfs_get/zfs_get_002_pos.ksh \
 	functional/cli_root/zfs_get/zfs_get_003_pos.ksh \
 	functional/cli_root/zfs_get/zfs_get_004_pos.ksh \
 	functional/cli_root/zfs_get/zfs_get_005_neg.ksh \
 	functional/cli_root/zfs_get/zfs_get_006_neg.ksh \
 	functional/cli_root/zfs_get/zfs_get_007_neg.ksh \
 	functional/cli_root/zfs_get/zfs_get_008_pos.ksh \
 	functional/cli_root/zfs_get/zfs_get_009_pos.ksh \
 	functional/cli_root/zfs_get/zfs_get_010_neg.ksh \
 	functional/cli_root/zfs_ids_to_path/cleanup.ksh \
 	functional/cli_root/zfs_ids_to_path/setup.ksh \
 	functional/cli_root/zfs_ids_to_path/zfs_ids_to_path_001_pos.ksh \
 	functional/cli_root/zfs_inherit/cleanup.ksh \
 	functional/cli_root/zfs_inherit/setup.ksh \
 	functional/cli_root/zfs_inherit/zfs_inherit_001_neg.ksh \
 	functional/cli_root/zfs_inherit/zfs_inherit_002_neg.ksh \
 	functional/cli_root/zfs_inherit/zfs_inherit_003_pos.ksh \
 	functional/cli_root/zfs_inherit/zfs_inherit_mountpoint.ksh \
 	functional/cli_root/zfs_jail/cleanup.ksh \
 	functional/cli_root/zfs_jail/setup.ksh \
 	functional/cli_root/zfs_jail/zfs_jail_001_pos.ksh \
 	functional/cli_root/zfs_load-key/cleanup.ksh \
 	functional/cli_root/zfs_load-key/setup.ksh \
 	functional/cli_root/zfs_load-key/zfs_load-key_all.ksh \
 	functional/cli_root/zfs_load-key/zfs_load-key_file.ksh \
 	functional/cli_root/zfs_load-key/zfs_load-key_https.ksh \
 	functional/cli_root/zfs_load-key/zfs_load-key.ksh \
 	functional/cli_root/zfs_load-key/zfs_load-key_location.ksh \
 	functional/cli_root/zfs_load-key/zfs_load-key_noop.ksh \
 	functional/cli_root/zfs_load-key/zfs_load-key_recursive.ksh \
 	functional/cli_root/zfs_mount/cleanup.ksh \
 	functional/cli_root/zfs_mount/setup.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_001_pos.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_002_pos.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_003_pos.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_004_pos.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_005_pos.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_006_pos.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_007_pos.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_008_pos.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_009_neg.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_010_neg.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_011_neg.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_012_pos.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_013_pos.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_014_neg.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_all_001_pos.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_all_fail.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_all_mountpoints.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_encrypted.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_recursive.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_remount.ksh \
 	functional/cli_root/zfs_mount/zfs_mount_test_race.ksh \
 	functional/cli_root/zfs_mount/zfs_multi_mount.ksh \
 	functional/cli_root/zfs_program/cleanup.ksh \
 	functional/cli_root/zfs_program/setup.ksh \
 	functional/cli_root/zfs_program/zfs_program_json.ksh \
 	functional/cli_root/zfs_promote/cleanup.ksh \
 	functional/cli_root/zfs_promote/setup.ksh \
 	functional/cli_root/zfs_promote/zfs_promote_001_pos.ksh \
 	functional/cli_root/zfs_promote/zfs_promote_002_pos.ksh \
 	functional/cli_root/zfs_promote/zfs_promote_003_pos.ksh \
 	functional/cli_root/zfs_promote/zfs_promote_004_pos.ksh \
 	functional/cli_root/zfs_promote/zfs_promote_005_pos.ksh \
 	functional/cli_root/zfs_promote/zfs_promote_006_neg.ksh \
 	functional/cli_root/zfs_promote/zfs_promote_007_neg.ksh \
 	functional/cli_root/zfs_promote/zfs_promote_008_pos.ksh \
 	functional/cli_root/zfs_promote/zfs_promote_encryptionroot.ksh \
 	functional/cli_root/zfs_property/cleanup.ksh \
 	functional/cli_root/zfs_property/setup.ksh \
 	functional/cli_root/zfs_property/zfs_written_property_001_pos.ksh \
 	functional/cli_root/zfs_receive/cleanup.ksh \
 	functional/cli_root/zfs_receive/receive-o-x_props_aliases.ksh \
 	functional/cli_root/zfs_receive/receive-o-x_props_override.ksh \
 	functional/cli_root/zfs_receive/setup.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_001_pos.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_002_pos.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_003_pos.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_004_neg.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_005_neg.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_006_pos.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_007_neg.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_008_pos.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_009_neg.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_010_pos.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_011_pos.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_012_pos.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_013_pos.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_014_pos.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_015_pos.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_016_pos.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_-e.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_from_encrypted.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_from_zstd.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_new_props.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_raw_-d.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_raw_incremental.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_raw.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_to_encrypted.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_-wR-encrypted-mix.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_corrective.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_compressed_corrective.ksh \
 	functional/cli_root/zfs_receive/zfs_receive_large_block_corrective.ksh \
 	functional/cli_root/zfs_rename/cleanup.ksh \
 	functional/cli_root/zfs_rename/setup.ksh \
 	functional/cli_root/zfs_rename/zfs_rename_001_pos.ksh \
 	functional/cli_root/zfs_rename/zfs_rename_002_pos.ksh \
 	functional/cli_root/zfs_rename/zfs_rename_003_pos.ksh \
 	functional/cli_root/zfs_rename/zfs_rename_004_neg.ksh \
 	functional/cli_root/zfs_rename/zfs_rename_005_neg.ksh \
 	functional/cli_root/zfs_rename/zfs_rename_006_pos.ksh \
 	functional/cli_root/zfs_rename/zfs_rename_007_pos.ksh \
 	functional/cli_root/zfs_rename/zfs_rename_008_pos.ksh \
 	functional/cli_root/zfs_rename/zfs_rename_009_neg.ksh \
 	functional/cli_root/zfs_rename/zfs_rename_010_neg.ksh \
 	functional/cli_root/zfs_rename/zfs_rename_011_pos.ksh \
 	functional/cli_root/zfs_rename/zfs_rename_012_neg.ksh \
 	functional/cli_root/zfs_rename/zfs_rename_013_pos.ksh \
 	functional/cli_root/zfs_rename/zfs_rename_014_neg.ksh \
 	functional/cli_root/zfs_rename/zfs_rename_encrypted_child.ksh \
 	functional/cli_root/zfs_rename/zfs_rename_mountpoint.ksh \
 	functional/cli_root/zfs_rename/zfs_rename_nounmount.ksh \
 	functional/cli_root/zfs_rename/zfs_rename_to_encrypted.ksh \
 	functional/cli_root/zfs_reservation/cleanup.ksh \
 	functional/cli_root/zfs_reservation/setup.ksh \
 	functional/cli_root/zfs_reservation/zfs_reservation_001_pos.ksh \
 	functional/cli_root/zfs_reservation/zfs_reservation_002_pos.ksh \
 	functional/cli_root/zfs_rollback/cleanup.ksh \
 	functional/cli_root/zfs_rollback/setup.ksh \
 	functional/cli_root/zfs_rollback/zfs_rollback_001_pos.ksh \
 	functional/cli_root/zfs_rollback/zfs_rollback_002_pos.ksh \
 	functional/cli_root/zfs_rollback/zfs_rollback_003_neg.ksh \
 	functional/cli_root/zfs_rollback/zfs_rollback_004_neg.ksh \
 	functional/cli_root/zfs_send/cleanup.ksh \
 	functional/cli_root/zfs_send/setup.ksh \
 	functional/cli_root/zfs_send/zfs_send_001_pos.ksh \
 	functional/cli_root/zfs_send/zfs_send_002_pos.ksh \
 	functional/cli_root/zfs_send/zfs_send_003_pos.ksh \
 	functional/cli_root/zfs_send/zfs_send_004_neg.ksh \
 	functional/cli_root/zfs_send/zfs_send_005_pos.ksh \
 	functional/cli_root/zfs_send/zfs_send_006_pos.ksh \
 	functional/cli_root/zfs_send/zfs_send_007_pos.ksh \
 	functional/cli_root/zfs_send/zfs_send-b.ksh \
 	functional/cli_root/zfs_send/zfs_send_encrypted.ksh \
 	functional/cli_root/zfs_send/zfs_send_encrypted_unloaded.ksh \
 	functional/cli_root/zfs_send/zfs_send_raw.ksh \
 	functional/cli_root/zfs_send/zfs_send_skip_missing.ksh \
 	functional/cli_root/zfs_send/zfs_send_sparse.ksh \
 	functional/cli_root/zfs_set/cache_001_pos.ksh \
 	functional/cli_root/zfs_set/cache_002_neg.ksh \
 	functional/cli_root/zfs_set/canmount_001_pos.ksh \
 	functional/cli_root/zfs_set/canmount_002_pos.ksh \
 	functional/cli_root/zfs_set/canmount_003_pos.ksh \
 	functional/cli_root/zfs_set/canmount_004_pos.ksh \
 	functional/cli_root/zfs_set/checksum_001_pos.ksh \
 	functional/cli_root/zfs_set/cleanup.ksh \
 	functional/cli_root/zfs_set/compression_001_pos.ksh \
 	functional/cli_root/zfs_set/mountpoint_001_pos.ksh \
 	functional/cli_root/zfs_set/mountpoint_002_pos.ksh \
 	functional/cli_root/zfs_set/mountpoint_003_pos.ksh \
 	functional/cli_root/zfs_set/onoffs_001_pos.ksh \
 	functional/cli_root/zfs_set/property_alias_001_pos.ksh \
 	functional/cli_root/zfs_set/readonly_001_pos.ksh \
 	functional/cli_root/zfs_set/reservation_001_neg.ksh \
 	functional/cli_root/zfs_set/ro_props_001_pos.ksh \
 	functional/cli_root/zfs_set/setup.ksh \
 	functional/cli_root/zfs_set/share_mount_001_neg.ksh \
 	functional/cli_root/zfs_set/snapdir_001_pos.ksh \
 	functional/cli_root/zfs/setup.ksh \
 	functional/cli_root/zfs_set/user_property_001_pos.ksh \
 	functional/cli_root/zfs_set/user_property_002_pos.ksh \
 	functional/cli_root/zfs_set/user_property_003_neg.ksh \
 	functional/cli_root/zfs_set/user_property_004_pos.ksh \
 	functional/cli_root/zfs_set/version_001_neg.ksh \
 	functional/cli_root/zfs_set/zfs_set_001_neg.ksh \
 	functional/cli_root/zfs_set/zfs_set_002_neg.ksh \
 	functional/cli_root/zfs_set/zfs_set_003_neg.ksh \
 	functional/cli_root/zfs_set/zfs_set_feature_activation.ksh \
 	functional/cli_root/zfs_set/zfs_set_keylocation.ksh \
 	functional/cli_root/zfs_set/zfs_set_nomount.ksh \
 	functional/cli_root/zfs_share/cleanup.ksh \
 	functional/cli_root/zfs_share/setup.ksh \
 	functional/cli_root/zfs_share/zfs_share_001_pos.ksh \
 	functional/cli_root/zfs_share/zfs_share_002_pos.ksh \
 	functional/cli_root/zfs_share/zfs_share_003_pos.ksh \
 	functional/cli_root/zfs_share/zfs_share_004_pos.ksh \
 	functional/cli_root/zfs_share/zfs_share_005_pos.ksh \
 	functional/cli_root/zfs_share/zfs_share_006_pos.ksh \
 	functional/cli_root/zfs_share/zfs_share_007_neg.ksh \
 	functional/cli_root/zfs_share/zfs_share_008_neg.ksh \
 	functional/cli_root/zfs_share/zfs_share_009_neg.ksh \
 	functional/cli_root/zfs_share/zfs_share_010_neg.ksh \
 	functional/cli_root/zfs_share/zfs_share_011_pos.ksh \
 	functional/cli_root/zfs_share/zfs_share_012_pos.ksh \
 	functional/cli_root/zfs_share/zfs_share_013_pos.ksh \
 	functional/cli_root/zfs_share/zfs_share_concurrent_shares.ksh \
 	functional/cli_root/zfs_share/zfs_share_after_mount.ksh \
 	functional/cli_root/zfs_snapshot/cleanup.ksh \
 	functional/cli_root/zfs_snapshot/setup.ksh \
 	functional/cli_root/zfs_snapshot/zfs_snapshot_001_neg.ksh \
 	functional/cli_root/zfs_snapshot/zfs_snapshot_002_neg.ksh \
 	functional/cli_root/zfs_snapshot/zfs_snapshot_003_neg.ksh \
 	functional/cli_root/zfs_snapshot/zfs_snapshot_004_neg.ksh \
 	functional/cli_root/zfs_snapshot/zfs_snapshot_005_neg.ksh \
 	functional/cli_root/zfs_snapshot/zfs_snapshot_006_pos.ksh \
 	functional/cli_root/zfs_snapshot/zfs_snapshot_007_neg.ksh \
 	functional/cli_root/zfs_snapshot/zfs_snapshot_008_neg.ksh \
 	functional/cli_root/zfs_snapshot/zfs_snapshot_009_pos.ksh \
 	functional/cli_root/zfs_sysfs/cleanup.ksh \
 	functional/cli_root/zfs_sysfs/setup.ksh \
 	functional/cli_root/zfs_sysfs/zfeature_set_unsupported.ksh \
 	functional/cli_root/zfs_sysfs/zfs_get_unsupported.ksh \
 	functional/cli_root/zfs_sysfs/zfs_set_unsupported.ksh \
 	functional/cli_root/zfs_sysfs/zfs_sysfs_live.ksh \
 	functional/cli_root/zfs_sysfs/zpool_get_unsupported.ksh \
 	functional/cli_root/zfs_sysfs/zpool_set_unsupported.ksh \
 	functional/cli_root/zfs_unload-key/cleanup.ksh \
 	functional/cli_root/zfs_unload-key/setup.ksh \
 	functional/cli_root/zfs_unload-key/zfs_unload-key_all.ksh \
 	functional/cli_root/zfs_unload-key/zfs_unload-key.ksh \
 	functional/cli_root/zfs_unload-key/zfs_unload-key_recursive.ksh \
 	functional/cli_root/zfs_unmount/cleanup.ksh \
 	functional/cli_root/zfs_unmount/setup.ksh \
 	functional/cli_root/zfs_unmount/zfs_unmount_001_pos.ksh \
 	functional/cli_root/zfs_unmount/zfs_unmount_002_pos.ksh \
 	functional/cli_root/zfs_unmount/zfs_unmount_003_pos.ksh \
 	functional/cli_root/zfs_unmount/zfs_unmount_004_pos.ksh \
 	functional/cli_root/zfs_unmount/zfs_unmount_005_pos.ksh \
 	functional/cli_root/zfs_unmount/zfs_unmount_006_pos.ksh \
 	functional/cli_root/zfs_unmount/zfs_unmount_007_neg.ksh \
 	functional/cli_root/zfs_unmount/zfs_unmount_008_neg.ksh \
 	functional/cli_root/zfs_unmount/zfs_unmount_009_pos.ksh \
 	functional/cli_root/zfs_unmount/zfs_unmount_all_001_pos.ksh \
 	functional/cli_root/zfs_unmount/zfs_unmount_nested.ksh \
 	functional/cli_root/zfs_unmount/zfs_unmount_unload_keys.ksh \
 	functional/cli_root/zfs_unshare/cleanup.ksh \
 	functional/cli_root/zfs_unshare/setup.ksh \
 	functional/cli_root/zfs_unshare/zfs_unshare_001_pos.ksh \
 	functional/cli_root/zfs_unshare/zfs_unshare_002_pos.ksh \
 	functional/cli_root/zfs_unshare/zfs_unshare_003_pos.ksh \
 	functional/cli_root/zfs_unshare/zfs_unshare_004_neg.ksh \
 	functional/cli_root/zfs_unshare/zfs_unshare_005_neg.ksh \
 	functional/cli_root/zfs_unshare/zfs_unshare_006_pos.ksh \
 	functional/cli_root/zfs_unshare/zfs_unshare_007_pos.ksh \
 	functional/cli_root/zfs_unshare/zfs_unshare_008_pos.ksh \
 	functional/cli_root/zfs_upgrade/cleanup.ksh \
 	functional/cli_root/zfs_upgrade/setup.ksh \
 	functional/cli_root/zfs_upgrade/zfs_upgrade_001_pos.ksh \
 	functional/cli_root/zfs_upgrade/zfs_upgrade_002_pos.ksh \
 	functional/cli_root/zfs_upgrade/zfs_upgrade_003_pos.ksh \
 	functional/cli_root/zfs_upgrade/zfs_upgrade_004_pos.ksh \
 	functional/cli_root/zfs_upgrade/zfs_upgrade_005_pos.ksh \
 	functional/cli_root/zfs_upgrade/zfs_upgrade_006_neg.ksh \
 	functional/cli_root/zfs_upgrade/zfs_upgrade_007_neg.ksh \
 	functional/cli_root/zfs_wait/cleanup.ksh \
 	functional/cli_root/zfs_wait/setup.ksh \
 	functional/cli_root/zfs_wait/zfs_wait_deleteq.ksh \
 	functional/cli_root/zfs_wait/zfs_wait_getsubopt.ksh \
 	functional/cli_root/zfs/zfs_001_neg.ksh \
 	functional/cli_root/zfs/zfs_002_pos.ksh \
 	functional/cli_root/zfs/zfs_003_neg.ksh \
 	functional/cli_root/zhack/zhack_label_repair_001.ksh \
 	functional/cli_root/zhack/zhack_label_repair_002.ksh \
 	functional/cli_root/zhack/zhack_label_repair_003.ksh \
 	functional/cli_root/zhack/zhack_label_repair_004.ksh \
 	functional/cli_root/zpool_add/add_nested_replacing_spare.ksh \
 	functional/cli_root/zpool_add/add-o_ashift.ksh \
 	functional/cli_root/zpool_add/add_prop_ashift.ksh \
 	functional/cli_root/zpool_add/cleanup.ksh \
 	functional/cli_root/zpool_add/setup.ksh \
 	functional/cli_root/zpool_add/zpool_add--allow-ashift-mismatch.ksh \
 	functional/cli_root/zpool_add/zpool_add_001_pos.ksh \
 	functional/cli_root/zpool_add/zpool_add_002_pos.ksh \
 	functional/cli_root/zpool_add/zpool_add_003_pos.ksh \
 	functional/cli_root/zpool_add/zpool_add_004_pos.ksh \
 	functional/cli_root/zpool_add/zpool_add_005_pos.ksh \
 	functional/cli_root/zpool_add/zpool_add_006_pos.ksh \
 	functional/cli_root/zpool_add/zpool_add_007_neg.ksh \
 	functional/cli_root/zpool_add/zpool_add_008_neg.ksh \
 	functional/cli_root/zpool_add/zpool_add_009_neg.ksh \
 	functional/cli_root/zpool_add/zpool_add_010_pos.ksh \
 	functional/cli_root/zpool_add/zpool_add_dryrun_output.ksh \
 	functional/cli_root/zpool_attach/attach-o_ashift.ksh \
 	functional/cli_root/zpool_attach/cleanup.ksh \
 	functional/cli_root/zpool_attach/setup.ksh \
 	functional/cli_root/zpool_attach/zpool_attach_001_neg.ksh \
 	functional/cli_root/zpool/cleanup.ksh \
 	functional/cli_root/zpool_clear/cleanup.ksh \
 	functional/cli_root/zpool_clear/setup.ksh \
 	functional/cli_root/zpool_clear/zpool_clear_001_pos.ksh \
 	functional/cli_root/zpool_clear/zpool_clear_002_neg.ksh \
 	functional/cli_root/zpool_clear/zpool_clear_003_neg.ksh \
 	functional/cli_root/zpool_clear/zpool_clear_readonly.ksh \
 	functional/cli_root/zpool_create/cleanup.ksh \
 	functional/cli_root/zpool_create/create-o_ashift.ksh \
 	functional/cli_root/zpool_create/setup.ksh \
 	functional/cli_root/zpool_create/zpool_create_001_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_002_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_003_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_004_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_005_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_006_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_007_neg.ksh \
 	functional/cli_root/zpool_create/zpool_create_008_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_009_neg.ksh \
 	functional/cli_root/zpool_create/zpool_create_010_neg.ksh \
 	functional/cli_root/zpool_create/zpool_create_011_neg.ksh \
 	functional/cli_root/zpool_create/zpool_create_012_neg.ksh \
 	functional/cli_root/zpool_create/zpool_create_014_neg.ksh \
 	functional/cli_root/zpool_create/zpool_create_015_neg.ksh \
 	functional/cli_root/zpool_create/zpool_create_016_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_017_neg.ksh \
 	functional/cli_root/zpool_create/zpool_create_018_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_019_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_020_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_021_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_022_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_023_neg.ksh \
 	functional/cli_root/zpool_create/zpool_create_024_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_crypt_combos.ksh \
 	functional/cli_root/zpool_create/zpool_create_draid_001_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_draid_002_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_draid_003_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_draid_004_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_dryrun_output.ksh \
 	functional/cli_root/zpool_create/zpool_create_encrypted.ksh \
 	functional/cli_root/zpool_create/zpool_create_features_001_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_features_002_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_features_003_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_features_004_neg.ksh \
 	functional/cli_root/zpool_create/zpool_create_features_005_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_features_006_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_features_007_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_features_008_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_features_009_pos.ksh \
 	functional/cli_root/zpool_create/zpool_create_tempname.ksh \
 	functional/cli_root/zpool_destroy/zpool_destroy_001_pos.ksh \
 	functional/cli_root/zpool_destroy/zpool_destroy_002_pos.ksh \
 	functional/cli_root/zpool_destroy/zpool_destroy_003_neg.ksh \
 	functional/cli_root/zpool_detach/cleanup.ksh \
 	functional/cli_root/zpool_detach/setup.ksh \
 	functional/cli_root/zpool_detach/zpool_detach_001_neg.ksh \
 	functional/cli_root/zpool_events/cleanup.ksh \
 	functional/cli_root/zpool_events/setup.ksh \
 	functional/cli_root/zpool_events/zpool_events_clear.ksh \
 	functional/cli_root/zpool_events/zpool_events_clear_retained.ksh \
 	functional/cli_root/zpool_events/zpool_events_cliargs.ksh \
 	functional/cli_root/zpool_events/zpool_events_duplicates.ksh \
 	functional/cli_root/zpool_events/zpool_events_errors.ksh \
 	functional/cli_root/zpool_events/zpool_events_follow.ksh \
 	functional/cli_root/zpool_events/zpool_events_poolname.ksh \
 	functional/cli_root/zpool_expand/cleanup.ksh \
 	functional/cli_root/zpool_expand/setup.ksh \
 	functional/cli_root/zpool_expand/zpool_expand_001_pos.ksh \
 	functional/cli_root/zpool_expand/zpool_expand_002_pos.ksh \
 	functional/cli_root/zpool_expand/zpool_expand_003_neg.ksh \
 	functional/cli_root/zpool_expand/zpool_expand_004_pos.ksh \
 	functional/cli_root/zpool_expand/zpool_expand_005_pos.ksh \
 	functional/cli_root/zpool_export/cleanup.ksh \
 	functional/cli_root/zpool_export/setup.ksh \
 	functional/cli_root/zpool_export/zpool_export_001_pos.ksh \
 	functional/cli_root/zpool_export/zpool_export_002_pos.ksh \
 	functional/cli_root/zpool_export/zpool_export_003_neg.ksh \
 	functional/cli_root/zpool_export/zpool_export_004_pos.ksh \
 	functional/cli_root/zpool_export/zpool_export_parallel_admin.ksh \
 	functional/cli_root/zpool_export/zpool_export_parallel_pos.ksh \
 	functional/cli_root/zpool_get/cleanup.ksh \
 	functional/cli_root/zpool_get/setup.ksh \
 	functional/cli_root/zpool_get/vdev_get_001_pos.ksh \
 	functional/cli_root/zpool_get/zpool_get_001_pos.ksh \
 	functional/cli_root/zpool_get/zpool_get_002_pos.ksh \
 	functional/cli_root/zpool_get/zpool_get_003_pos.ksh \
 	functional/cli_root/zpool_get/zpool_get_004_neg.ksh \
 	functional/cli_root/zpool_get/zpool_get_005_pos.ksh \
 	functional/cli_root/zpool_history/cleanup.ksh \
 	functional/cli_root/zpool_history/setup.ksh \
 	functional/cli_root/zpool_history/zpool_history_001_neg.ksh \
 	functional/cli_root/zpool_history/zpool_history_002_pos.ksh \
 	functional/cli_root/zpool_import/cleanup.ksh \
 	functional/cli_root/zpool_import/import_cachefile_device_added.ksh \
 	functional/cli_root/zpool_import/import_cachefile_device_removed.ksh \
 	functional/cli_root/zpool_import/import_cachefile_device_replaced.ksh \
 	functional/cli_root/zpool_import/import_cachefile_mirror_attached.ksh \
 	functional/cli_root/zpool_import/import_cachefile_mirror_detached.ksh \
 	functional/cli_root/zpool_import/import_cachefile_paths_changed.ksh \
 	functional/cli_root/zpool_import/import_cachefile_shared_device.ksh \
 	functional/cli_root/zpool_import/import_devices_missing.ksh \
 	functional/cli_root/zpool_import/import_log_missing.ksh \
 	functional/cli_root/zpool_import/import_paths_changed.ksh \
 	functional/cli_root/zpool_import/import_rewind_config_changed.ksh \
 	functional/cli_root/zpool_import/import_rewind_device_replaced.ksh \
 	functional/cli_root/zpool_import/setup.ksh \
 	functional/cli_root/zpool_import/zpool_import_001_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_002_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_003_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_004_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_005_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_006_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_007_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_008_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_009_neg.ksh \
 	functional/cli_root/zpool_import/zpool_import_010_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_011_neg.ksh \
 	functional/cli_root/zpool_import/zpool_import_012_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_013_neg.ksh \
 	functional/cli_root/zpool_import/zpool_import_014_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_015_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_016_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_017_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_all_001_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_encrypted.ksh \
 	functional/cli_root/zpool_import/zpool_import_encrypted_load.ksh \
 	functional/cli_root/zpool_import/zpool_import_errata3.ksh \
 	functional/cli_root/zpool_import/zpool_import_errata4.ksh \
 	functional/cli_root/zpool_import/zpool_import_features_001_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_features_002_neg.ksh \
 	functional/cli_root/zpool_import/zpool_import_features_003_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_hostid_changed.ksh \
 	functional/cli_root/zpool_import/zpool_import_hostid_changed_unclean_export.ksh \
 	functional/cli_root/zpool_import/zpool_import_hostid_changed_cachefile.ksh \
 	functional/cli_root/zpool_import/zpool_import_hostid_changed_cachefile_unclean_export.ksh \
 	functional/cli_root/zpool_import/zpool_import_missing_001_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_missing_002_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_missing_003_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_rename_001_pos.ksh \
 	functional/cli_root/zpool_import/zpool_import_status.ksh \
 	functional/cli_root/zpool_import/zpool_import_parallel_admin.ksh \
 	functional/cli_root/zpool_import/zpool_import_parallel_neg.ksh \
 	functional/cli_root/zpool_import/zpool_import_parallel_pos.ksh \
 	functional/cli_root/zpool_initialize/cleanup.ksh \
 	functional/cli_root/zpool_initialize/zpool_initialize_attach_detach_add_remove.ksh \
 	functional/cli_root/zpool_initialize/zpool_initialize_fault_export_import_online.ksh \
 	functional/cli_root/zpool_initialize/zpool_initialize_import_export.ksh \
 	functional/cli_root/zpool_initialize/zpool_initialize_offline_export_import_online.ksh \
 	functional/cli_root/zpool_initialize/zpool_initialize_online_offline.ksh \
 	functional/cli_root/zpool_initialize/zpool_initialize_split.ksh \
 	functional/cli_root/zpool_initialize/zpool_initialize_start_and_cancel_neg.ksh \
 	functional/cli_root/zpool_initialize/zpool_initialize_start_and_cancel_pos.ksh \
 	functional/cli_root/zpool_initialize/zpool_initialize_suspend_resume.ksh \
 	functional/cli_root/zpool_initialize/zpool_initialize_uninit.ksh \
 	functional/cli_root/zpool_initialize/zpool_initialize_unsupported_vdevs.ksh \
 	functional/cli_root/zpool_initialize/zpool_initialize_verify_checksums.ksh \
 	functional/cli_root/zpool_initialize/zpool_initialize_verify_initialized.ksh \
 	functional/cli_root/zpool_labelclear/zpool_labelclear_active.ksh \
 	functional/cli_root/zpool_labelclear/zpool_labelclear_exported.ksh \
 	functional/cli_root/zpool_labelclear/zpool_labelclear_removed.ksh \
 	functional/cli_root/zpool_labelclear/zpool_labelclear_valid.ksh \
 	functional/cli_root/zpool_offline/cleanup.ksh \
 	functional/cli_root/zpool_offline/setup.ksh \
 	functional/cli_root/zpool_offline/zpool_offline_001_pos.ksh \
 	functional/cli_root/zpool_offline/zpool_offline_002_neg.ksh \
 	functional/cli_root/zpool_offline/zpool_offline_003_pos.ksh \
 	functional/cli_root/zpool_online/cleanup.ksh \
 	functional/cli_root/zpool_online/setup.ksh \
 	functional/cli_root/zpool_online/zpool_online_001_pos.ksh \
 	functional/cli_root/zpool_online/zpool_online_002_neg.ksh \
 	functional/cli_root/zpool_prefetch/cleanup.ksh \
 	functional/cli_root/zpool_prefetch/setup.ksh \
 	functional/cli_root/zpool_prefetch/zpool_prefetch_001_pos.ksh \
 	functional/cli_root/zpool_reguid/cleanup.ksh \
 	functional/cli_root/zpool_reguid/setup.ksh \
 	functional/cli_root/zpool_reguid/zpool_reguid_001_pos.ksh \
 	functional/cli_root/zpool_reguid/zpool_reguid_002_neg.ksh \
 	functional/cli_root/zpool_remove/cleanup.ksh \
 	functional/cli_root/zpool_remove/setup.ksh \
 	functional/cli_root/zpool_remove/zpool_remove_001_neg.ksh \
 	functional/cli_root/zpool_remove/zpool_remove_002_pos.ksh \
 	functional/cli_root/zpool_remove/zpool_remove_003_pos.ksh \
 	functional/cli_root/zpool_reopen/cleanup.ksh \
 	functional/cli_root/zpool_reopen/setup.ksh \
 	functional/cli_root/zpool_reopen/zpool_reopen_001_pos.ksh \
 	functional/cli_root/zpool_reopen/zpool_reopen_002_pos.ksh \
 	functional/cli_root/zpool_reopen/zpool_reopen_003_pos.ksh \
 	functional/cli_root/zpool_reopen/zpool_reopen_004_pos.ksh \
 	functional/cli_root/zpool_reopen/zpool_reopen_005_pos.ksh \
 	functional/cli_root/zpool_reopen/zpool_reopen_006_neg.ksh \
 	functional/cli_root/zpool_reopen/zpool_reopen_007_pos.ksh \
 	functional/cli_root/zpool_replace/cleanup.ksh \
 	functional/cli_root/zpool_replace/replace-o_ashift.ksh \
 	functional/cli_root/zpool_replace/replace_prop_ashift.ksh \
 	functional/cli_root/zpool_replace/setup.ksh \
 	functional/cli_root/zpool_replace/zpool_replace_001_neg.ksh \
 	functional/cli_root/zpool_resilver/cleanup.ksh \
 	functional/cli_root/zpool_resilver/setup.ksh \
 	functional/cli_root/zpool_resilver/zpool_resilver_bad_args.ksh \
 	functional/cli_root/zpool_resilver/zpool_resilver_restart.ksh \
 	functional/cli_root/zpool_resilver/zpool_resilver_concurrent.ksh \
 	functional/cli_root/zpool_scrub/cleanup.ksh \
 	functional/cli_root/zpool_scrub/setup.ksh \
 	functional/cli_root/zpool_scrub/zpool_scrub_001_neg.ksh \
 	functional/cli_root/zpool_scrub/zpool_scrub_002_pos.ksh \
 	functional/cli_root/zpool_scrub/zpool_scrub_003_pos.ksh \
 	functional/cli_root/zpool_scrub/zpool_scrub_004_pos.ksh \
 	functional/cli_root/zpool_scrub/zpool_scrub_005_pos.ksh \
 	functional/cli_root/zpool_scrub/zpool_scrub_encrypted_unloaded.ksh \
 	functional/cli_root/zpool_scrub/zpool_scrub_multiple_copies.ksh \
 	functional/cli_root/zpool_scrub/zpool_scrub_offline_device.ksh \
 	functional/cli_root/zpool_scrub/zpool_scrub_print_repairing.ksh \
 	functional/cli_root/zpool_scrub/zpool_error_scrub_001_pos.ksh \
 	functional/cli_root/zpool_scrub/zpool_error_scrub_002_pos.ksh \
 	functional/cli_root/zpool_scrub/zpool_error_scrub_003_pos.ksh \
 	functional/cli_root/zpool_scrub/zpool_error_scrub_004_pos.ksh \
 	functional/cli_root/zpool_set/cleanup.ksh \
 	functional/cli_root/zpool_set/setup.ksh \
 	functional/cli_root/zpool/setup.ksh \
 	functional/cli_root/zpool_set/vdev_set_001_pos.ksh \
 	functional/cli_root/zpool_set/zpool_set_common.kshlib \
 	functional/cli_root/zpool_set/zpool_set_001_pos.ksh \
 	functional/cli_root/zpool_set/zpool_set_002_neg.ksh \
 	functional/cli_root/zpool_set/zpool_set_003_neg.ksh \
 	functional/cli_root/zpool_set/zpool_set_ashift.ksh \
 	functional/cli_root/zpool_set/user_property_001_pos.ksh \
 	functional/cli_root/zpool_set/user_property_002_neg.ksh \
 	functional/cli_root/zpool_set/zpool_set_features.ksh \
 	functional/cli_root/zpool_split/cleanup.ksh \
 	functional/cli_root/zpool_split/setup.ksh \
 	functional/cli_root/zpool_split/zpool_split_cliargs.ksh \
 	functional/cli_root/zpool_split/zpool_split_devices.ksh \
 	functional/cli_root/zpool_split/zpool_split_dryrun_output.ksh \
 	functional/cli_root/zpool_split/zpool_split_encryption.ksh \
 	functional/cli_root/zpool_split/zpool_split_indirect.ksh \
 	functional/cli_root/zpool_split/zpool_split_props.ksh \
 	functional/cli_root/zpool_split/zpool_split_resilver.ksh \
 	functional/cli_root/zpool_split/zpool_split_vdevs.ksh \
 	functional/cli_root/zpool_split/zpool_split_wholedisk.ksh \
 	functional/cli_root/zpool_status/cleanup.ksh \
 	functional/cli_root/zpool_status/setup.ksh \
 	functional/cli_root/zpool_status/zpool_status_001_pos.ksh \
 	functional/cli_root/zpool_status/zpool_status_002_pos.ksh \
 	functional/cli_root/zpool_status/zpool_status_003_pos.ksh \
 	functional/cli_root/zpool_status/zpool_status_004_pos.ksh \
 	functional/cli_root/zpool_status/zpool_status_005_pos.ksh \
 	functional/cli_root/zpool_status/zpool_status_006_pos.ksh \
 	functional/cli_root/zpool_status/zpool_status_007_pos.ksh \
 	functional/cli_root/zpool_status/zpool_status_008_pos.ksh \
 	functional/cli_root/zpool_status/zpool_status_features_001_pos.ksh \
 	functional/cli_root/zpool_sync/cleanup.ksh \
 	functional/cli_root/zpool_sync/setup.ksh \
 	functional/cli_root/zpool_sync/zpool_sync_001_pos.ksh \
 	functional/cli_root/zpool_sync/zpool_sync_002_neg.ksh \
 	functional/cli_root/zpool_trim/cleanup.ksh \
 	functional/cli_root/zpool_trim/setup.ksh \
 	functional/cli_root/zpool_trim/zpool_trim_attach_detach_add_remove.ksh \
 	functional/cli_root/zpool_trim/zpool_trim_fault_export_import_online.ksh \
 	functional/cli_root/zpool_trim/zpool_trim_import_export.ksh \
 	functional/cli_root/zpool_trim/zpool_trim_multiple.ksh \
 	functional/cli_root/zpool_trim/zpool_trim_neg.ksh \
 	functional/cli_root/zpool_trim/zpool_trim_offline_export_import_online.ksh \
 	functional/cli_root/zpool_trim/zpool_trim_online_offline.ksh \
 	functional/cli_root/zpool_trim/zpool_trim_partial.ksh \
 	functional/cli_root/zpool_trim/zpool_trim_rate.ksh \
 	functional/cli_root/zpool_trim/zpool_trim_rate_neg.ksh \
 	functional/cli_root/zpool_trim/zpool_trim_secure.ksh \
 	functional/cli_root/zpool_trim/zpool_trim_split.ksh \
 	functional/cli_root/zpool_trim/zpool_trim_start_and_cancel_neg.ksh \
 	functional/cli_root/zpool_trim/zpool_trim_start_and_cancel_pos.ksh \
 	functional/cli_root/zpool_trim/zpool_trim_suspend_resume.ksh \
 	functional/cli_root/zpool_trim/zpool_trim_unsupported_vdevs.ksh \
 	functional/cli_root/zpool_trim/zpool_trim_verify_checksums.ksh \
 	functional/cli_root/zpool_trim/zpool_trim_verify_trimmed.ksh \
 	functional/cli_root/zpool_upgrade/cleanup.ksh \
 	functional/cli_root/zpool_upgrade/setup.ksh \
 	functional/cli_root/zpool_upgrade/zpool_upgrade_001_pos.ksh \
 	functional/cli_root/zpool_upgrade/zpool_upgrade_002_pos.ksh \
 	functional/cli_root/zpool_upgrade/zpool_upgrade_003_pos.ksh \
 	functional/cli_root/zpool_upgrade/zpool_upgrade_004_pos.ksh \
 	functional/cli_root/zpool_upgrade/zpool_upgrade_005_neg.ksh \
 	functional/cli_root/zpool_upgrade/zpool_upgrade_006_neg.ksh \
 	functional/cli_root/zpool_upgrade/zpool_upgrade_007_pos.ksh \
 	functional/cli_root/zpool_upgrade/zpool_upgrade_008_pos.ksh \
 	functional/cli_root/zpool_upgrade/zpool_upgrade_009_neg.ksh \
 	functional/cli_root/zpool_upgrade/zpool_upgrade_features_001_pos.ksh \
 	functional/cli_root/zpool_wait/cleanup.ksh \
 	functional/cli_root/zpool_wait/scan/cleanup.ksh \
 	functional/cli_root/zpool_wait/scan/setup.ksh \
 	functional/cli_root/zpool_wait/scan/zpool_wait_rebuild.ksh \
 	functional/cli_root/zpool_wait/scan/zpool_wait_replace_cancel.ksh \
 	functional/cli_root/zpool_wait/scan/zpool_wait_replace.ksh \
 	functional/cli_root/zpool_wait/scan/zpool_wait_resilver.ksh \
 	functional/cli_root/zpool_wait/scan/zpool_wait_scrub_basic.ksh \
 	functional/cli_root/zpool_wait/scan/zpool_wait_scrub_cancel.ksh \
 	functional/cli_root/zpool_wait/scan/zpool_wait_scrub_flag.ksh \
 	functional/cli_root/zpool_wait/setup.ksh \
 	functional/cli_root/zpool_wait/zpool_wait_discard.ksh \
 	functional/cli_root/zpool_wait/zpool_wait_freeing.ksh \
 	functional/cli_root/zpool_wait/zpool_wait_initialize_basic.ksh \
 	functional/cli_root/zpool_wait/zpool_wait_initialize_cancel.ksh \
 	functional/cli_root/zpool_wait/zpool_wait_initialize_flag.ksh \
 	functional/cli_root/zpool_wait/zpool_wait_multiple.ksh \
 	functional/cli_root/zpool_wait/zpool_wait_no_activity.ksh \
 	functional/cli_root/zpool_wait/zpool_wait_remove_cancel.ksh \
 	functional/cli_root/zpool_wait/zpool_wait_remove.ksh \
 	functional/cli_root/zpool_wait/zpool_wait_trim_basic.ksh \
 	functional/cli_root/zpool_wait/zpool_wait_trim_cancel.ksh \
 	functional/cli_root/zpool_wait/zpool_wait_trim_flag.ksh \
 	functional/cli_root/zpool_wait/zpool_wait_usage.ksh \
 	functional/cli_root/zpool/zpool_001_neg.ksh \
 	functional/cli_root/zpool/zpool_002_pos.ksh \
 	functional/cli_root/zpool/zpool_003_pos.ksh \
 	functional/cli_root/zpool/zpool_colors.ksh \
 	functional/cli_user/misc/arcstat_001_pos.ksh \
 	functional/cli_user/misc/arc_summary_001_pos.ksh \
 	functional/cli_user/misc/arc_summary_002_neg.ksh \
 	functional/cli_user/misc/zilstat_001_pos.ksh \
 	functional/cli_user/misc/cleanup.ksh \
 	functional/cli_user/misc/setup.ksh \
 	functional/cli_user/misc/zdb_001_neg.ksh \
 	functional/cli_user/misc/zfs_001_neg.ksh \
 	functional/cli_user/misc/zfs_allow_001_neg.ksh \
 	functional/cli_user/misc/zfs_clone_001_neg.ksh \
 	functional/cli_user/misc/zfs_create_001_neg.ksh \
 	functional/cli_user/misc/zfs_destroy_001_neg.ksh \
 	functional/cli_user/misc/zfs_get_001_neg.ksh \
 	functional/cli_user/misc/zfs_inherit_001_neg.ksh \
 	functional/cli_user/misc/zfs_mount_001_neg.ksh \
 	functional/cli_user/misc/zfs_promote_001_neg.ksh \
 	functional/cli_user/misc/zfs_receive_001_neg.ksh \
 	functional/cli_user/misc/zfs_rename_001_neg.ksh \
 	functional/cli_user/misc/zfs_rollback_001_neg.ksh \
 	functional/cli_user/misc/zfs_send_001_neg.ksh \
 	functional/cli_user/misc/zfs_set_001_neg.ksh \
 	functional/cli_user/misc/zfs_share_001_neg.ksh \
 	functional/cli_user/misc/zfs_snapshot_001_neg.ksh \
 	functional/cli_user/misc/zfs_unallow_001_neg.ksh \
 	functional/cli_user/misc/zfs_unmount_001_neg.ksh \
 	functional/cli_user/misc/zfs_unshare_001_neg.ksh \
 	functional/cli_user/misc/zfs_upgrade_001_neg.ksh \
 	functional/cli_user/misc/zpool_001_neg.ksh \
 	functional/cli_user/misc/zpool_add_001_neg.ksh \
 	functional/cli_user/misc/zpool_attach_001_neg.ksh \
 	functional/cli_user/misc/zpool_clear_001_neg.ksh \
 	functional/cli_user/misc/zpool_create_001_neg.ksh \
 	functional/cli_user/misc/zpool_destroy_001_neg.ksh \
 	functional/cli_user/misc/zpool_detach_001_neg.ksh \
 	functional/cli_user/misc/zpool_export_001_neg.ksh \
 	functional/cli_user/misc/zpool_get_001_neg.ksh \
 	functional/cli_user/misc/zpool_history_001_neg.ksh \
 	functional/cli_user/misc/zpool_import_001_neg.ksh \
 	functional/cli_user/misc/zpool_import_002_neg.ksh \
 	functional/cli_user/misc/zpool_offline_001_neg.ksh \
 	functional/cli_user/misc/zpool_online_001_neg.ksh \
 	functional/cli_user/misc/zpool_remove_001_neg.ksh \
 	functional/cli_user/misc/zpool_replace_001_neg.ksh \
 	functional/cli_user/misc/zpool_scrub_001_neg.ksh \
 	functional/cli_user/misc/zpool_set_001_neg.ksh \
 	functional/cli_user/misc/zpool_status_001_neg.ksh \
 	functional/cli_user/misc/zpool_upgrade_001_neg.ksh \
 	functional/cli_user/misc/zpool_wait_privilege.ksh \
 	functional/cli_user/zfs_list/cleanup.ksh \
 	functional/cli_user/zfs_list/setup.ksh \
 	functional/cli_user/zfs_list/zfs_list_001_pos.ksh \
 	functional/cli_user/zfs_list/zfs_list_002_pos.ksh \
 	functional/cli_user/zfs_list/zfs_list_003_pos.ksh \
 	functional/cli_user/zfs_list/zfs_list_004_neg.ksh \
 	functional/cli_user/zfs_list/zfs_list_005_neg.ksh \
 	functional/cli_user/zfs_list/zfs_list_007_pos.ksh \
 	functional/cli_user/zfs_list/zfs_list_008_neg.ksh \
 	functional/cli_user/zpool_iostat/cleanup.ksh \
 	functional/cli_user/zpool_iostat/setup.ksh \
 	functional/cli_user/zpool_iostat/zpool_iostat_001_neg.ksh \
 	functional/cli_user/zpool_iostat/zpool_iostat_002_pos.ksh \
 	functional/cli_user/zpool_iostat/zpool_iostat_003_neg.ksh \
 	functional/cli_user/zpool_iostat/zpool_iostat_004_pos.ksh \
 	functional/cli_user/zpool_iostat/zpool_iostat_005_pos.ksh \
 	functional/cli_user/zpool_iostat/zpool_iostat_-c_disable.ksh \
 	functional/cli_user/zpool_iostat/zpool_iostat_-c_homedir.ksh \
 	functional/cli_user/zpool_iostat/zpool_iostat_-c_searchpath.ksh \
 	functional/cli_user/zpool_list/cleanup.ksh \
 	functional/cli_user/zpool_list/setup.ksh \
 	functional/cli_user/zpool_list/zpool_list_001_pos.ksh \
 	functional/cli_user/zpool_list/zpool_list_002_neg.ksh \
 	functional/cli_user/zpool_status/cleanup.ksh \
 	functional/cli_user/zpool_status/setup.ksh \
 	functional/cli_user/zpool_status/zpool_status_003_pos.ksh \
 	functional/cli_user/zpool_status/zpool_status_-c_disable.ksh \
 	functional/cli_user/zpool_status/zpool_status_-c_homedir.ksh \
 	functional/cli_user/zpool_status/zpool_status_-c_searchpath.ksh \
 	functional/compression/cleanup.ksh \
 	functional/compression/compress_001_pos.ksh \
 	functional/compression/compress_002_pos.ksh \
 	functional/compression/compress_003_pos.ksh \
 	functional/compression/compress_004_pos.ksh \
 	functional/compression/compress_zstd_bswap.ksh \
 	functional/compression/l2arc_compressed_arc_disabled.ksh \
 	functional/compression/l2arc_compressed_arc.ksh \
 	functional/compression/l2arc_encrypted.ksh \
 	functional/compression/l2arc_encrypted_no_compressed_arc.ksh \
 	functional/compression/setup.ksh \
 	functional/cp_files/cleanup.ksh \
 	functional/cp_files/cp_files_001_pos.ksh \
 	functional/cp_files/cp_files_002_pos.ksh \
 	functional/cp_files/cp_stress.ksh \
 	functional/cp_files/setup.ksh \
 	functional/crtime/cleanup.ksh \
 	functional/crtime/crtime_001_pos.ksh \
 	functional/crtime/setup.ksh \
 	functional/ctime/cleanup.ksh \
 	functional/ctime/ctime_001_pos.ksh \
 	functional/ctime/setup.ksh \
 	functional/deadman/deadman_ratelimit.ksh \
 	functional/deadman/deadman_sync.ksh \
 	functional/deadman/deadman_zio.ksh \
 	functional/dedup/cleanup.ksh \
 	functional/dedup/setup.ksh \
 	functional/dedup/dedup_fdt_create.ksh \
 	functional/dedup/dedup_fdt_import.ksh \
 	functional/dedup/dedup_legacy_create.ksh \
 	functional/dedup/dedup_legacy_import.ksh \
 	functional/dedup/dedup_legacy_fdt_upgrade.ksh \
 	functional/dedup/dedup_legacy_fdt_mixed.ksh \
 	functional/dedup/dedup_quota.ksh \
 	functional/delegate/cleanup.ksh \
 	functional/delegate/setup.ksh \
 	functional/delegate/zfs_allow_001_pos.ksh \
 	functional/delegate/zfs_allow_002_pos.ksh \
 	functional/delegate/zfs_allow_003_pos.ksh \
 	functional/delegate/zfs_allow_004_pos.ksh \
 	functional/delegate/zfs_allow_005_pos.ksh \
 	functional/delegate/zfs_allow_006_pos.ksh \
 	functional/delegate/zfs_allow_007_pos.ksh \
 	functional/delegate/zfs_allow_008_pos.ksh \
 	functional/delegate/zfs_allow_009_neg.ksh \
 	functional/delegate/zfs_allow_010_pos.ksh \
 	functional/delegate/zfs_allow_011_neg.ksh \
 	functional/delegate/zfs_allow_012_neg.ksh \
 	functional/delegate/zfs_unallow_001_pos.ksh \
 	functional/delegate/zfs_unallow_002_pos.ksh \
 	functional/delegate/zfs_unallow_003_pos.ksh \
 	functional/delegate/zfs_unallow_004_pos.ksh \
 	functional/delegate/zfs_unallow_005_pos.ksh \
 	functional/delegate/zfs_unallow_006_pos.ksh \
 	functional/delegate/zfs_unallow_007_neg.ksh \
 	functional/delegate/zfs_unallow_008_neg.ksh \
 	functional/devices/cleanup.ksh \
 	functional/devices/devices_001_pos.ksh \
 	functional/devices/devices_002_neg.ksh \
 	functional/devices/devices_003_pos.ksh \
 	functional/devices/setup.ksh \
 	functional/direct/dio_aligned_block.ksh \
 	functional/direct/dio_async_always.ksh \
 	functional/direct/dio_async_fio_ioengines.ksh \
 	functional/direct/dio_compression.ksh \
 	functional/direct/dio_dedup.ksh \
 	functional/direct/dio_encryption.ksh \
 	functional/direct/dio_grow_block.ksh \
 	functional/direct/dio_max_recordsize.ksh \
 	functional/direct/dio_mixed.ksh \
 	functional/direct/dio_mmap.ksh \
 	functional/direct/dio_overwrites.ksh \
 	functional/direct/dio_property.ksh \
 	functional/direct/dio_random.ksh \
+	functional/direct/dio_read_verify.ksh \
 	functional/direct/dio_recordsize.ksh \
 	functional/direct/dio_unaligned_block.ksh \
 	functional/direct/dio_unaligned_filesize.ksh \
 	functional/direct/dio_write_verify.ksh \
 	functional/direct/dio_write_stable_pages.ksh \
 	functional/direct/setup.ksh \
 	functional/direct/cleanup.ksh \
 	functional/dos_attributes/cleanup.ksh \
 	functional/dos_attributes/read_dos_attrs_001.ksh \
 	functional/dos_attributes/setup.ksh \
 	functional/dos_attributes/write_dos_attrs_001.ksh \
 	functional/events/cleanup.ksh \
 	functional/events/events_001_pos.ksh \
 	functional/events/events_002_pos.ksh \
 	functional/events/setup.ksh \
 	functional/events/zed_cksum_config.ksh \
 	functional/events/zed_cksum_reported.ksh \
 	functional/events/zed_diagnose_multiple.ksh \
 	functional/events/zed_fd_spill.ksh \
 	functional/events/zed_io_config.ksh \
 	functional/events/zed_rc_filter.ksh \
 	functional/events/zed_slow_io.ksh \
 	functional/events/zed_slow_io_many_vdevs.ksh \
 	functional/exec/cleanup.ksh \
 	functional/exec/exec_001_pos.ksh \
 	functional/exec/exec_002_neg.ksh \
 	functional/exec/setup.ksh \
 	functional/fadvise/cleanup.ksh \
 	functional/fadvise/fadvise_sequential.ksh \
 	functional/fadvise/setup.ksh \
 	functional/fallocate/cleanup.ksh \
 	functional/fallocate/fallocate_prealloc.ksh \
 	functional/fallocate/fallocate_punch-hole.ksh \
 	functional/fallocate/fallocate_zero-range.ksh \
 	functional/fallocate/setup.ksh \
 	functional/fault/auto_offline_001_pos.ksh \
 	functional/fault/auto_online_001_pos.ksh \
 	functional/fault/auto_online_002_pos.ksh \
 	functional/fault/auto_replace_001_pos.ksh \
 	functional/fault/auto_replace_002_pos.ksh \
 	functional/fault/auto_spare_001_pos.ksh \
 	functional/fault/auto_spare_002_pos.ksh \
 	functional/fault/auto_spare_ashift.ksh \
 	functional/fault/auto_spare_multiple.ksh \
 	functional/fault/auto_spare_shared.ksh \
 	functional/fault/cleanup.ksh \
 	functional/fault/decompress_fault.ksh \
 	functional/fault/decrypt_fault.ksh \
 	functional/fault/fault_limits.ksh \
 	functional/fault/scrub_after_resilver.ksh \
 	functional/fault/suspend_resume_single.ksh \
 	functional/fault/setup.ksh \
 	functional/fault/zpool_status_-s.ksh \
 	functional/features/async_destroy/async_destroy_001_pos.ksh \
 	functional/features/async_destroy/cleanup.ksh \
 	functional/features/async_destroy/setup.ksh \
 	functional/features/large_dnode/cleanup.ksh \
 	functional/features/large_dnode/large_dnode_001_pos.ksh \
 	functional/features/large_dnode/large_dnode_002_pos.ksh \
 	functional/features/large_dnode/large_dnode_003_pos.ksh \
 	functional/features/large_dnode/large_dnode_004_neg.ksh \
 	functional/features/large_dnode/large_dnode_005_pos.ksh \
 	functional/features/large_dnode/large_dnode_006_pos.ksh \
 	functional/features/large_dnode/large_dnode_007_neg.ksh \
 	functional/features/large_dnode/large_dnode_008_pos.ksh \
 	functional/features/large_dnode/large_dnode_009_pos.ksh \
 	functional/features/large_dnode/setup.ksh \
 	functional/grow/grow_pool_001_pos.ksh \
 	functional/grow/grow_replicas_001_pos.ksh \
 	functional/history/cleanup.ksh \
 	functional/history/history_001_pos.ksh \
 	functional/history/history_002_pos.ksh \
 	functional/history/history_003_pos.ksh \
 	functional/history/history_004_pos.ksh \
 	functional/history/history_005_neg.ksh \
 	functional/history/history_006_neg.ksh \
 	functional/history/history_007_pos.ksh \
 	functional/history/history_008_pos.ksh \
 	functional/history/history_009_pos.ksh \
 	functional/history/history_010_pos.ksh \
 	functional/history/setup.ksh \
 	functional/inheritance/cleanup.ksh \
 	functional/inheritance/inherit_001_pos.ksh \
 	functional/inuse/inuse_001_pos.ksh \
 	functional/inuse/inuse_003_pos.ksh \
 	functional/inuse/inuse_004_pos.ksh \
 	functional/inuse/inuse_005_pos.ksh \
 	functional/inuse/inuse_006_pos.ksh \
 	functional/inuse/inuse_007_pos.ksh \
 	functional/inuse/inuse_008_pos.ksh \
 	functional/inuse/inuse_009_pos.ksh \
 	functional/inuse/setup.ksh \
 	functional/io/cleanup.ksh \
 	functional/io/io_uring.ksh \
 	functional/io/libaio.ksh \
 	functional/io/mmap.ksh \
 	functional/io/posixaio.ksh \
 	functional/io/psync.ksh \
 	functional/io/setup.ksh \
 	functional/io/sync.ksh \
 	functional/l2arc/cleanup.ksh \
 	functional/l2arc/l2arc_arcstats_pos.ksh \
 	functional/l2arc/l2arc_l2miss_pos.ksh \
 	functional/l2arc/l2arc_mfuonly_pos.ksh \
 	functional/l2arc/persist_l2arc_001_pos.ksh \
 	functional/l2arc/persist_l2arc_002_pos.ksh \
 	functional/l2arc/persist_l2arc_003_neg.ksh \
 	functional/l2arc/persist_l2arc_004_pos.ksh \
 	functional/l2arc/persist_l2arc_005_pos.ksh \
 	functional/l2arc/setup.ksh \
 	functional/large_files/cleanup.ksh \
 	functional/large_files/large_files_001_pos.ksh \
 	functional/large_files/large_files_002_pos.ksh \
 	functional/large_files/setup.ksh \
 	functional/largest_pool/largest_pool_001_pos.ksh \
 	functional/libzfs/cleanup.ksh \
 	functional/libzfs/libzfs_input.ksh \
 	functional/libzfs/setup.ksh \
 	functional/limits/cleanup.ksh \
 	functional/limits/filesystem_count.ksh \
 	functional/limits/filesystem_limit.ksh \
 	functional/limits/setup.ksh \
 	functional/limits/snapshot_count.ksh \
 	functional/limits/snapshot_limit.ksh \
 	functional/link_count/cleanup.ksh \
 	functional/link_count/link_count_001.ksh \
 	functional/link_count/link_count_root_inode.ksh \
 	functional/link_count/setup.ksh \
 	functional/longname/cleanup.ksh \
 	functional/longname/longname_001_pos.ksh \
 	functional/longname/longname_002_pos.ksh \
 	functional/longname/longname_003_pos.ksh \
 	functional/longname/setup.ksh \
 	functional/log_spacemap/log_spacemap_import_logs.ksh \
 	functional/migration/cleanup.ksh \
 	functional/migration/migration_001_pos.ksh \
 	functional/migration/migration_002_pos.ksh \
 	functional/migration/migration_003_pos.ksh \
 	functional/migration/migration_004_pos.ksh \
 	functional/migration/migration_005_pos.ksh \
 	functional/migration/migration_006_pos.ksh \
 	functional/migration/migration_007_pos.ksh \
 	functional/migration/migration_008_pos.ksh \
 	functional/migration/migration_009_pos.ksh \
 	functional/migration/migration_010_pos.ksh \
 	functional/migration/migration_011_pos.ksh \
 	functional/migration/migration_012_pos.ksh \
 	functional/migration/setup.ksh \
 	functional/mmap/cleanup.ksh \
 	functional/mmap/mmap_libaio_001_pos.ksh \
 	functional/mmap/mmap_mixed.ksh \
 	functional/mmap/mmap_read_001_pos.ksh \
 	functional/mmap/mmap_seek_001_pos.ksh \
 	functional/mmap/mmap_sync_001_pos.ksh \
 	functional/mmap/mmap_write_001_pos.ksh \
 	functional/mmap/setup.ksh \
 	functional/mmp/cleanup.ksh \
 	functional/mmp/mmp_active_import.ksh \
 	functional/mmp/mmp_exported_import.ksh \
 	functional/mmp/mmp_hostid.ksh \
 	functional/mmp/mmp_inactive_import.ksh \
 	functional/mmp/mmp_interval.ksh \
 	functional/mmp/mmp_on_off.ksh \
 	functional/mmp/mmp_on_thread.ksh \
 	functional/mmp/mmp_on_uberblocks.ksh \
 	functional/mmp/mmp_on_zdb.ksh \
 	functional/mmp/mmp_reset_interval.ksh \
 	functional/mmp/mmp_write_distribution.ksh \
 	functional/mmp/mmp_write_slow_disk.ksh \
 	functional/mmp/mmp_write_uberblocks.ksh \
 	functional/mmp/multihost_history.ksh \
 	functional/mmp/setup.ksh \
 	functional/mount/cleanup.ksh \
 	functional/mount/setup.ksh \
 	functional/mount/umount_001.ksh \
 	functional/mount/umountall_001.ksh \
 	functional/mount/umount_unlinked_drain.ksh \
 	functional/mv_files/cleanup.ksh \
 	functional/mv_files/mv_files_001_pos.ksh \
 	functional/mv_files/mv_files_002_pos.ksh \
 	functional/mv_files/random_creation.ksh \
 	functional/mv_files/setup.ksh \
 	functional/nestedfs/cleanup.ksh \
 	functional/nestedfs/nestedfs_001_pos.ksh \
 	functional/nestedfs/setup.ksh \
 	functional/nopwrite/cleanup.ksh \
 	functional/nopwrite/nopwrite_copies.ksh \
 	functional/nopwrite/nopwrite_mtime.ksh \
 	functional/nopwrite/nopwrite_negative.ksh \
 	functional/nopwrite/nopwrite_promoted_clone.ksh \
 	functional/nopwrite/nopwrite_recsize.ksh \
 	functional/nopwrite/nopwrite_sync.ksh \
 	functional/nopwrite/nopwrite_varying_compression.ksh \
 	functional/nopwrite/nopwrite_volume.ksh \
 	functional/nopwrite/setup.ksh \
 	functional/no_space/cleanup.ksh \
 	functional/no_space/enospc_001_pos.ksh \
 	functional/no_space/enospc_002_pos.ksh \
 	functional/no_space/enospc_003_pos.ksh \
 	functional/no_space/enospc_df.ksh \
 	functional/no_space/enospc_ganging.ksh \
 	functional/no_space/enospc_rm.ksh \
 	functional/no_space/setup.ksh \
 	functional/online_offline/cleanup.ksh \
 	functional/online_offline/online_offline_001_pos.ksh \
 	functional/online_offline/online_offline_002_neg.ksh \
 	functional/online_offline/online_offline_003_neg.ksh \
 	functional/online_offline/setup.ksh \
 	functional/pam/cleanup.ksh \
 	functional/pam/pam_basic.ksh \
 	functional/pam/pam_change_unmounted.ksh \
 	functional/pam/pam_nounmount.ksh \
 	functional/pam/pam_recursive.ksh \
 	functional/pam/pam_short_password.ksh \
 	functional/pam/setup.ksh \
 	functional/pool_checkpoint/checkpoint_after_rewind.ksh \
 	functional/pool_checkpoint/checkpoint_big_rewind.ksh \
 	functional/pool_checkpoint/checkpoint_capacity.ksh \
 	functional/pool_checkpoint/checkpoint_conf_change.ksh \
 	functional/pool_checkpoint/checkpoint_discard_busy.ksh \
 	functional/pool_checkpoint/checkpoint_discard.ksh \
 	functional/pool_checkpoint/checkpoint_discard_many.ksh \
 	functional/pool_checkpoint/checkpoint_indirect.ksh \
 	functional/pool_checkpoint/checkpoint_invalid.ksh \
 	functional/pool_checkpoint/checkpoint_lun_expsz.ksh \
 	functional/pool_checkpoint/checkpoint_open.ksh \
 	functional/pool_checkpoint/checkpoint_removal.ksh \
 	functional/pool_checkpoint/checkpoint_rewind.ksh \
 	functional/pool_checkpoint/checkpoint_ro_rewind.ksh \
 	functional/pool_checkpoint/checkpoint_sm_scale.ksh \
 	functional/pool_checkpoint/checkpoint_twice.ksh \
 	functional/pool_checkpoint/checkpoint_vdev_add.ksh \
 	functional/pool_checkpoint/checkpoint_zdb.ksh \
 	functional/pool_checkpoint/checkpoint_zhack_feat.ksh \
 	functional/pool_checkpoint/cleanup.ksh \
 	functional/pool_checkpoint/setup.ksh \
 	functional/pool_names/pool_names_001_pos.ksh \
 	functional/pool_names/pool_names_002_neg.ksh \
 	functional/poolversion/cleanup.ksh \
 	functional/poolversion/poolversion_001_pos.ksh \
 	functional/poolversion/poolversion_002_pos.ksh \
 	functional/poolversion/setup.ksh \
 	functional/privilege/cleanup.ksh \
 	functional/privilege/privilege_001_pos.ksh \
 	functional/privilege/privilege_002_pos.ksh \
 	functional/privilege/setup.ksh \
 	functional/procfs/cleanup.ksh \
 	functional/procfs/pool_state.ksh \
 	functional/procfs/procfs_list_basic.ksh \
 	functional/procfs/procfs_list_concurrent_readers.ksh \
 	functional/procfs/procfs_list_stale_read.ksh \
 	functional/procfs/setup.ksh \
 	functional/projectquota/cleanup.ksh \
 	functional/projectquota/projectid_001_pos.ksh \
 	functional/projectquota/projectid_002_pos.ksh \
 	functional/projectquota/projectid_003_pos.ksh \
 	functional/projectquota/projectquota_001_pos.ksh \
 	functional/projectquota/projectquota_002_pos.ksh \
 	functional/projectquota/projectquota_003_pos.ksh \
 	functional/projectquota/projectquota_004_neg.ksh \
 	functional/projectquota/projectquota_005_pos.ksh \
 	functional/projectquota/projectquota_006_pos.ksh \
 	functional/projectquota/projectquota_007_pos.ksh \
 	functional/projectquota/projectquota_008_pos.ksh \
 	functional/projectquota/projectquota_009_pos.ksh \
 	functional/projectquota/projectspace_001_pos.ksh \
 	functional/projectquota/projectspace_002_pos.ksh \
 	functional/projectquota/projectspace_003_pos.ksh \
 	functional/projectquota/projectspace_004_pos.ksh \
 	functional/projectquota/projecttree_001_pos.ksh \
 	functional/projectquota/projecttree_002_pos.ksh \
 	functional/projectquota/projecttree_003_neg.ksh \
 	functional/projectquota/setup.ksh \
 	functional/quota/cleanup.ksh \
 	functional/quota/quota_001_pos.ksh \
 	functional/quota/quota_002_pos.ksh \
 	functional/quota/quota_003_pos.ksh \
 	functional/quota/quota_004_pos.ksh \
 	functional/quota/quota_005_pos.ksh \
 	functional/quota/quota_006_neg.ksh \
 	functional/quota/setup.ksh \
 	functional/raidz/cleanup.ksh \
 	functional/raidz/raidz_001_neg.ksh \
 	functional/raidz/raidz_002_pos.ksh \
 	functional/raidz/raidz_expand_001_pos.ksh \
 	functional/raidz/raidz_expand_002_pos.ksh \
 	functional/raidz/raidz_expand_003_neg.ksh \
 	functional/raidz/raidz_expand_003_pos.ksh \
 	functional/raidz/raidz_expand_004_pos.ksh \
 	functional/raidz/raidz_expand_005_pos.ksh \
 	functional/raidz/raidz_expand_006_neg.ksh \
 	functional/raidz/raidz_expand_007_neg.ksh \
 	functional/raidz/setup.ksh \
 	functional/redacted_send/cleanup.ksh \
 	functional/redacted_send/redacted_compressed.ksh \
 	functional/redacted_send/redacted_contents.ksh \
 	functional/redacted_send/redacted_deleted.ksh \
 	functional/redacted_send/redacted_disabled_feature.ksh \
 	functional/redacted_send/redacted_embedded.ksh \
 	functional/redacted_send/redacted_holes.ksh \
 	functional/redacted_send/redacted_incrementals.ksh \
 	functional/redacted_send/redacted_largeblocks.ksh \
 	functional/redacted_send/redacted_many_clones.ksh \
 	functional/redacted_send/redacted_mixed_recsize.ksh \
 	functional/redacted_send/redacted_mounts.ksh \
 	functional/redacted_send/redacted_negative.ksh \
 	functional/redacted_send/redacted_origin.ksh \
 	functional/redacted_send/redacted_panic.ksh \
 	functional/redacted_send/redacted_props.ksh \
 	functional/redacted_send/redacted_resume.ksh \
 	functional/redacted_send/redacted_size.ksh \
 	functional/redacted_send/redacted_volume.ksh \
 	functional/redacted_send/setup.ksh \
 	functional/redundancy/cleanup.ksh \
 	functional/redundancy/redundancy_draid1.ksh \
 	functional/redundancy/redundancy_draid2.ksh \
 	functional/redundancy/redundancy_draid3.ksh \
 	functional/redundancy/redundancy_draid_damaged1.ksh \
 	functional/redundancy/redundancy_draid_damaged2.ksh \
 	functional/redundancy/redundancy_draid.ksh \
 	functional/redundancy/redundancy_draid_spare1.ksh \
 	functional/redundancy/redundancy_draid_spare2.ksh \
 	functional/redundancy/redundancy_draid_spare3.ksh \
 	functional/redundancy/redundancy_mirror.ksh \
 	functional/redundancy/redundancy_raidz1.ksh \
 	functional/redundancy/redundancy_raidz2.ksh \
 	functional/redundancy/redundancy_raidz3.ksh \
 	functional/redundancy/redundancy_raidz.ksh \
 	functional/redundancy/redundancy_stripe.ksh \
 	functional/redundancy/setup.ksh \
 	functional/refquota/cleanup.ksh \
 	functional/refquota/refquota_001_pos.ksh \
 	functional/refquota/refquota_002_pos.ksh \
 	functional/refquota/refquota_003_pos.ksh \
 	functional/refquota/refquota_004_pos.ksh \
 	functional/refquota/refquota_005_pos.ksh \
 	functional/refquota/refquota_006_neg.ksh \
 	functional/refquota/refquota_007_neg.ksh \
 	functional/refquota/refquota_008_neg.ksh \
 	functional/refquota/setup.ksh \
 	functional/refreserv/cleanup.ksh \
 	functional/refreserv/refreserv_001_pos.ksh \
 	functional/refreserv/refreserv_002_pos.ksh \
 	functional/refreserv/refreserv_003_pos.ksh \
 	functional/refreserv/refreserv_004_pos.ksh \
 	functional/refreserv/refreserv_005_pos.ksh \
 	functional/refreserv/refreserv_multi_raidz.ksh \
 	functional/refreserv/refreserv_raidz.ksh \
 	functional/refreserv/setup.ksh \
 	functional/removal/cleanup.ksh \
 	functional/removal/removal_all_vdev.ksh \
 	functional/removal/removal_cancel.ksh \
 	functional/removal/removal_check_space.ksh \
 	functional/removal/removal_condense_export.ksh \
 	functional/removal/removal_multiple_indirection.ksh \
 	functional/removal/removal_nopwrite.ksh \
 	functional/removal/removal_remap_deadlists.ksh \
 	functional/removal/removal_reservation.ksh \
 	functional/removal/removal_resume_export.ksh \
 	functional/removal/removal_sanity.ksh \
 	functional/removal/removal_with_add.ksh \
 	functional/removal/removal_with_create_fs.ksh \
 	functional/removal/removal_with_dedup.ksh \
 	functional/removal/removal_with_errors.ksh \
 	functional/removal/removal_with_export.ksh \
 	functional/removal/removal_with_faulted.ksh \
 	functional/removal/removal_with_ganging.ksh \
 	functional/removal/removal_with_indirect.ksh \
 	functional/removal/removal_with_remove.ksh \
 	functional/removal/removal_with_scrub.ksh \
 	functional/removal/removal_with_send.ksh \
 	functional/removal/removal_with_send_recv.ksh \
 	functional/removal/removal_with_snapshot.ksh \
 	functional/removal/removal_with_write.ksh \
 	functional/removal/removal_with_zdb.ksh \
 	functional/removal/remove_attach_mirror.ksh \
 	functional/removal/remove_expanded.ksh \
 	functional/removal/remove_indirect.ksh \
 	functional/removal/remove_mirror.ksh \
 	functional/removal/remove_mirror_sanity.ksh \
 	functional/removal/remove_raidz.ksh \
 	functional/rename_dirs/cleanup.ksh \
 	functional/rename_dirs/rename_dirs_001_pos.ksh \
 	functional/rename_dirs/setup.ksh \
 	functional/renameat2/cleanup.ksh \
 	functional/renameat2/setup.ksh \
 	functional/renameat2/renameat2_exchange.ksh \
 	functional/renameat2/renameat2_noreplace.ksh \
 	functional/renameat2/renameat2_whiteout.ksh \
 	functional/replacement/attach_import.ksh \
 	functional/replacement/attach_multiple.ksh \
 	functional/replacement/attach_rebuild.ksh \
 	functional/replacement/attach_resilver.ksh \
 	functional/replacement/cleanup.ksh \
 	functional/replacement/detach.ksh \
 	functional/replacement/rebuild_disabled_feature.ksh \
 	functional/replacement/rebuild_multiple.ksh \
 	functional/replacement/rebuild_raidz.ksh \
 	functional/replacement/replace_import.ksh \
 	functional/replacement/replace_rebuild.ksh \
 	functional/replacement/replace_resilver.ksh \
 	functional/replacement/resilver_restart_001.ksh \
 	functional/replacement/resilver_restart_002.ksh \
 	functional/replacement/scrub_cancel.ksh \
 	functional/replacement/setup.ksh \
 	functional/reservation/cleanup.ksh \
 	functional/reservation/reservation_001_pos.ksh \
 	functional/reservation/reservation_002_pos.ksh \
 	functional/reservation/reservation_003_pos.ksh \
 	functional/reservation/reservation_004_pos.ksh \
 	functional/reservation/reservation_005_pos.ksh \
 	functional/reservation/reservation_006_pos.ksh \
 	functional/reservation/reservation_007_pos.ksh \
 	functional/reservation/reservation_008_pos.ksh \
 	functional/reservation/reservation_009_pos.ksh \
 	functional/reservation/reservation_010_pos.ksh \
 	functional/reservation/reservation_011_pos.ksh \
 	functional/reservation/reservation_012_pos.ksh \
 	functional/reservation/reservation_013_pos.ksh \
 	functional/reservation/reservation_014_pos.ksh \
 	functional/reservation/reservation_015_pos.ksh \
 	functional/reservation/reservation_016_pos.ksh \
 	functional/reservation/reservation_017_pos.ksh \
 	functional/reservation/reservation_018_pos.ksh \
 	functional/reservation/reservation_019_pos.ksh \
 	functional/reservation/reservation_020_pos.ksh \
 	functional/reservation/reservation_021_neg.ksh \
 	functional/reservation/reservation_022_pos.ksh \
 	functional/reservation/setup.ksh \
 	functional/rootpool/cleanup.ksh \
 	functional/rootpool/rootpool_002_neg.ksh \
 	functional/rootpool/rootpool_003_neg.ksh \
 	functional/rootpool/rootpool_007_pos.ksh \
 	functional/rootpool/setup.ksh \
 	functional/rsend/cleanup.ksh \
 	functional/rsend/recv_dedup_encrypted_zvol.ksh \
 	functional/rsend/recv_dedup.ksh \
 	functional/rsend/rsend_001_pos.ksh \
 	functional/rsend/rsend_002_pos.ksh \
 	functional/rsend/rsend_003_pos.ksh \
 	functional/rsend/rsend_004_pos.ksh \
 	functional/rsend/rsend_005_pos.ksh \
 	functional/rsend/rsend_006_pos.ksh \
 	functional/rsend/rsend_007_pos.ksh \
 	functional/rsend/rsend_008_pos.ksh \
 	functional/rsend/rsend_009_pos.ksh \
 	functional/rsend/rsend_010_pos.ksh \
 	functional/rsend/rsend_011_pos.ksh \
 	functional/rsend/rsend_012_pos.ksh \
 	functional/rsend/rsend_013_pos.ksh \
 	functional/rsend/rsend_014_pos.ksh \
 	functional/rsend/rsend_016_neg.ksh \
 	functional/rsend/rsend_019_pos.ksh \
 	functional/rsend/rsend_020_pos.ksh \
 	functional/rsend/rsend_021_pos.ksh \
 	functional/rsend/rsend_022_pos.ksh \
 	functional/rsend/rsend_024_pos.ksh \
 	functional/rsend/rsend_025_pos.ksh \
 	functional/rsend/rsend_026_neg.ksh \
 	functional/rsend/rsend_027_pos.ksh \
 	functional/rsend/rsend_028_neg.ksh \
 	functional/rsend/rsend_029_neg.ksh \
 	functional/rsend/rsend_030_pos.ksh \
 	functional/rsend/rsend_031_pos.ksh \
 	functional/rsend/send-c_embedded_blocks.ksh \
 	functional/rsend/send-c_incremental.ksh \
 	functional/rsend/send-c_longname.ksh \
 	functional/rsend/send-c_lz4_disabled.ksh \
 	functional/rsend/send-c_mixed_compression.ksh \
 	functional/rsend/send-c_props.ksh \
 	functional/rsend/send-c_recv_dedup.ksh \
 	functional/rsend/send-c_recv_lz4_disabled.ksh \
 	functional/rsend/send-c_resume.ksh \
 	functional/rsend/send-c_stream_size_estimate.ksh \
 	functional/rsend/send-c_verify_contents.ksh \
 	functional/rsend/send-c_verify_ratio.ksh \
 	functional/rsend/send-c_volume.ksh \
 	functional/rsend/send-c_zstream_recompress.ksh \
 	functional/rsend/send-c_zstreamdump.ksh \
 	functional/rsend/send-cpL_varied_recsize.ksh \
 	functional/rsend/send_doall.ksh \
 	functional/rsend/send_encrypted_incremental.ksh \
 	functional/rsend/send_encrypted_files.ksh \
 	functional/rsend/send_encrypted_freeobjects.ksh \
 	functional/rsend/send_encrypted_hierarchy.ksh \
 	functional/rsend/send_encrypted_props.ksh \
 	functional/rsend/send_encrypted_truncated_files.ksh \
 	functional/rsend/send_freeobjects.ksh \
 	functional/rsend/send_holds.ksh \
 	functional/rsend/send_hole_birth.ksh \
 	functional/rsend/send_invalid.ksh \
 	functional/rsend/send-L_toggle.ksh \
 	functional/rsend/send_mixed_raw.ksh \
 	functional/rsend/send_partial_dataset.ksh \
 	functional/rsend/send_raw_ashift.ksh \
 	functional/rsend/send_raw_spill_block.ksh \
 	functional/rsend/send_raw_large_blocks.ksh \
 	functional/rsend/send_realloc_dnode_size.ksh \
 	functional/rsend/send_realloc_encrypted_files.ksh \
 	functional/rsend/send_realloc_files.ksh \
 	functional/rsend/send_spill_block.ksh \
 	functional/rsend/send-wR_encrypted_zvol.ksh \
 	functional/rsend/setup.ksh \
 	functional/scrub_mirror/cleanup.ksh \
 	functional/scrub_mirror/scrub_mirror_001_pos.ksh \
 	functional/scrub_mirror/scrub_mirror_002_pos.ksh \
 	functional/scrub_mirror/scrub_mirror_003_pos.ksh \
 	functional/scrub_mirror/scrub_mirror_004_pos.ksh \
 	functional/scrub_mirror/setup.ksh \
 	functional/slog/cleanup.ksh \
 	functional/slog/setup.ksh \
 	functional/slog/slog_001_pos.ksh \
 	functional/slog/slog_002_pos.ksh \
 	functional/slog/slog_003_pos.ksh \
 	functional/slog/slog_004_pos.ksh \
 	functional/slog/slog_005_pos.ksh \
 	functional/slog/slog_006_pos.ksh \
 	functional/slog/slog_007_pos.ksh \
 	functional/slog/slog_008_neg.ksh \
 	functional/slog/slog_009_neg.ksh \
 	functional/slog/slog_010_neg.ksh \
 	functional/slog/slog_011_neg.ksh \
 	functional/slog/slog_012_neg.ksh \
 	functional/slog/slog_013_pos.ksh \
 	functional/slog/slog_014_pos.ksh \
 	functional/slog/slog_015_neg.ksh \
 	functional/slog/slog_016_pos.ksh \
 	functional/slog/slog_replay_fs_001.ksh \
 	functional/slog/slog_replay_fs_002.ksh \
 	functional/slog/slog_replay_volume.ksh \
 	functional/snapshot/cleanup.ksh \
 	functional/snapshot/clone_001_pos.ksh \
 	functional/snapshot/rollback_001_pos.ksh \
 	functional/snapshot/rollback_002_pos.ksh \
 	functional/snapshot/rollback_003_pos.ksh \
 	functional/snapshot/setup.ksh \
 	functional/snapshot/snapshot_001_pos.ksh \
 	functional/snapshot/snapshot_002_pos.ksh \
 	functional/snapshot/snapshot_003_pos.ksh \
 	functional/snapshot/snapshot_004_pos.ksh \
 	functional/snapshot/snapshot_005_pos.ksh \
 	functional/snapshot/snapshot_006_pos.ksh \
 	functional/snapshot/snapshot_007_pos.ksh \
 	functional/snapshot/snapshot_008_pos.ksh \
 	functional/snapshot/snapshot_009_pos.ksh \
 	functional/snapshot/snapshot_010_pos.ksh \
 	functional/snapshot/snapshot_011_pos.ksh \
 	functional/snapshot/snapshot_012_pos.ksh \
 	functional/snapshot/snapshot_013_pos.ksh \
 	functional/snapshot/snapshot_014_pos.ksh \
 	functional/snapshot/snapshot_015_pos.ksh \
 	functional/snapshot/snapshot_016_pos.ksh \
 	functional/snapshot/snapshot_017_pos.ksh \
 	functional/snapshot/snapshot_018_pos.ksh \
 	functional/snapused/cleanup.ksh \
 	functional/snapused/setup.ksh \
 	functional/snapused/snapused_001_pos.ksh \
 	functional/snapused/snapused_002_pos.ksh \
 	functional/snapused/snapused_003_pos.ksh \
 	functional/snapused/snapused_004_pos.ksh \
 	functional/snapused/snapused_005_pos.ksh \
 	functional/sparse/cleanup.ksh \
 	functional/sparse/setup.ksh \
 	functional/sparse/sparse_001_pos.ksh \
 	functional/stat/cleanup.ksh \
 	functional/stat/setup.ksh \
 	functional/stat/stat_001_pos.ksh \
 	functional/suid/cleanup.ksh \
 	functional/suid/setup.ksh \
 	functional/suid/suid_write_to_none.ksh \
 	functional/suid/suid_write_to_sgid.ksh \
 	functional/suid/suid_write_to_suid.ksh \
 	functional/suid/suid_write_to_suid_sgid.ksh \
 	functional/suid/suid_write_zil_replay.ksh \
 	functional/trim/autotrim_config.ksh \
 	functional/trim/autotrim_integrity.ksh \
 	functional/trim/autotrim_trim_integrity.ksh \
 	functional/trim/cleanup.ksh \
 	functional/trim/setup.ksh \
 	functional/trim/trim_config.ksh \
 	functional/trim/trim_integrity.ksh \
 	functional/trim/trim_l2arc.ksh \
 	functional/truncate/cleanup.ksh \
 	functional/truncate/setup.ksh \
 	functional/truncate/truncate_001_pos.ksh \
 	functional/truncate/truncate_002_pos.ksh \
 	functional/truncate/truncate_timestamps.ksh \
 	functional/upgrade/cleanup.ksh \
 	functional/upgrade/setup.ksh \
 	functional/upgrade/upgrade_projectquota_001_pos.ksh \
 	functional/upgrade/upgrade_projectquota_002_pos.ksh \
 	functional/upgrade/upgrade_readonly_pool.ksh \
 	functional/upgrade/upgrade_userobj_001_pos.ksh \
 	functional/user_namespace/cleanup.ksh \
 	functional/user_namespace/setup.ksh \
 	functional/user_namespace/user_namespace_001.ksh \
 	functional/user_namespace/user_namespace_002.ksh \
 	functional/user_namespace/user_namespace_003.ksh \
 	functional/user_namespace/user_namespace_004.ksh \
 	functional/userquota/cleanup.ksh \
 	functional/userquota/groupspace_001_pos.ksh \
 	functional/userquota/groupspace_002_pos.ksh \
 	functional/userquota/groupspace_003_pos.ksh \
 	functional/userquota/setup.ksh \
 	functional/userquota/userquota_001_pos.ksh \
 	functional/userquota/userquota_002_pos.ksh \
 	functional/userquota/userquota_003_pos.ksh \
 	functional/userquota/userquota_004_pos.ksh \
 	functional/userquota/userquota_005_neg.ksh \
 	functional/userquota/userquota_006_pos.ksh \
 	functional/userquota/userquota_007_pos.ksh \
 	functional/userquota/userquota_008_pos.ksh \
 	functional/userquota/userquota_009_pos.ksh \
 	functional/userquota/userquota_010_pos.ksh \
 	functional/userquota/userquota_011_pos.ksh \
 	functional/userquota/userquota_012_neg.ksh \
 	functional/userquota/userquota_013_pos.ksh \
 	functional/userquota/userspace_001_pos.ksh \
 	functional/userquota/userspace_002_pos.ksh \
 	functional/userquota/userspace_003_pos.ksh \
 	functional/userquota/userspace_encrypted.ksh \
 	functional/userquota/userspace_send_encrypted.ksh \
 	functional/userquota/userspace_encrypted_13709.ksh \
 	functional/vdev_zaps/cleanup.ksh \
 	functional/vdev_zaps/setup.ksh \
 	functional/vdev_zaps/vdev_zaps_001_pos.ksh \
 	functional/vdev_zaps/vdev_zaps_002_pos.ksh \
 	functional/vdev_zaps/vdev_zaps_003_pos.ksh \
 	functional/vdev_zaps/vdev_zaps_004_pos.ksh \
 	functional/vdev_zaps/vdev_zaps_005_pos.ksh \
 	functional/vdev_zaps/vdev_zaps_006_pos.ksh \
 	functional/vdev_zaps/vdev_zaps_007_pos.ksh \
 	functional/write_dirs/cleanup.ksh \
 	functional/write_dirs/setup.ksh \
 	functional/write_dirs/write_dirs_001_pos.ksh \
 	functional/write_dirs/write_dirs_002_pos.ksh \
 	functional/xattr/cleanup.ksh \
 	functional/xattr/setup.ksh \
 	functional/xattr/xattr_001_pos.ksh \
 	functional/xattr/xattr_002_neg.ksh \
 	functional/xattr/xattr_003_neg.ksh \
 	functional/xattr/xattr_004_pos.ksh \
 	functional/xattr/xattr_005_pos.ksh \
 	functional/xattr/xattr_006_pos.ksh \
 	functional/xattr/xattr_007_neg.ksh \
 	functional/xattr/xattr_008_pos.ksh \
 	functional/xattr/xattr_009_neg.ksh \
 	functional/xattr/xattr_010_neg.ksh \
 	functional/xattr/xattr_011_pos.ksh \
 	functional/xattr/xattr_012_pos.ksh \
 	functional/xattr/xattr_013_pos.ksh \
 	functional/xattr/xattr_compat.ksh \
 	functional/zap_shrink/cleanup.ksh \
 	functional/zap_shrink/zap_shrink_001_pos.ksh \
 	functional/zap_shrink/setup.ksh \
 	functional/zpool_influxdb/cleanup.ksh \
 	functional/zpool_influxdb/setup.ksh \
 	functional/zpool_influxdb/zpool_influxdb.ksh \
 	functional/zvol/zvol_cli/cleanup.ksh \
 	functional/zvol/zvol_cli/setup.ksh \
 	functional/zvol/zvol_cli/zvol_cli_001_pos.ksh \
 	functional/zvol/zvol_cli/zvol_cli_002_pos.ksh \
 	functional/zvol/zvol_cli/zvol_cli_003_neg.ksh \
 	functional/zvol/zvol_ENOSPC/cleanup.ksh \
 	functional/zvol/zvol_ENOSPC/setup.ksh \
 	functional/zvol/zvol_ENOSPC/zvol_ENOSPC_001_pos.ksh \
 	functional/zvol/zvol_misc/cleanup.ksh \
 	functional/zvol/zvol_misc/setup.ksh \
 	functional/zvol/zvol_misc/zvol_misc_001_neg.ksh \
 	functional/zvol/zvol_misc/zvol_misc_002_pos.ksh \
 	functional/zvol/zvol_misc/zvol_misc_003_neg.ksh \
 	functional/zvol/zvol_misc/zvol_misc_004_pos.ksh \
 	functional/zvol/zvol_misc/zvol_misc_005_neg.ksh \
 	functional/zvol/zvol_misc/zvol_misc_006_pos.ksh \
 	functional/zvol/zvol_misc/zvol_misc_fua.ksh \
 	functional/zvol/zvol_misc/zvol_misc_hierarchy.ksh \
 	functional/zvol/zvol_misc/zvol_misc_rename_inuse.ksh \
 	functional/zvol/zvol_misc/zvol_misc_snapdev.ksh \
 	functional/zvol/zvol_misc/zvol_misc_trim.ksh \
 	functional/zvol/zvol_misc/zvol_misc_volmode.ksh \
 	functional/zvol/zvol_misc/zvol_misc_zil.ksh \
 	functional/zvol/zvol_stress/cleanup.ksh \
 	functional/zvol/zvol_stress/setup.ksh \
 	functional/zvol/zvol_stress/zvol_stress.ksh \
 	functional/zvol/zvol_swap/cleanup.ksh \
 	functional/zvol/zvol_swap/setup.ksh \
 	functional/zvol/zvol_swap/zvol_swap_001_pos.ksh \
 	functional/zvol/zvol_swap/zvol_swap_002_pos.ksh \
 	functional/zvol/zvol_swap/zvol_swap_003_pos.ksh \
 	functional/zvol/zvol_swap/zvol_swap_004_pos.ksh \
 	functional/zvol/zvol_swap/zvol_swap_005_pos.ksh \
 	functional/zvol/zvol_swap/zvol_swap_006_pos.ksh \
 	functional/idmap_mount/cleanup.ksh \
 	functional/idmap_mount/setup.ksh \
 	functional/idmap_mount/idmap_mount_001.ksh \
 	functional/idmap_mount/idmap_mount_002.ksh \
 	functional/idmap_mount/idmap_mount_003.ksh \
 	functional/idmap_mount/idmap_mount_004.ksh \
 	functional/idmap_mount/idmap_mount_005.ksh
diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/json/json_sanity.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/json/json_sanity.ksh
index e598dd57181e..d092a3b0e828 100755
--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/json/json_sanity.ksh
+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/json/json_sanity.ksh
@@ -1,57 +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 https://opensource.org/licenses/CDDL-1.0.
 # See the License for the specific language governing permissions
 # and limitations under the License.
 #
 # When distributing Covered Code, include this CDDL HEADER in each
 # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 # If applicable, add the following below this CDDL HEADER, with the
 # fields enclosed by brackets "[]" replaced with your own identifying
 # information: Portions Copyright [yyyy] [name of copyright owner]
 #
 # CDDL HEADER END
 
 # Copyright (c) 2024 by Lawrence Livermore National Security, LLC.
 
 . $STF_SUITE/include/libtest.shlib
 
 #
 # DESCRIPTION:
 # Basic sanity check for valid JSON from zfs & zpool commands.
 #
 # STRATEGY:
 # 1. Run different zfs/zpool -j commands and check for valid JSON
 
+#
+# -j and --json mean the same thing. Each command will be run twice, replacing
+# JSONFLAG with the flag under test.
 list=(
-    "zpool status -j -g --json-int --json-flat-vdevs --json-pool-key-guid"
-    "zpool status -p -j -g --json-int --json-flat-vdevs --json-pool-key-guid"
-    "zpool status -j -c upath"
-    "zpool status -j"
-    "zpool status -j testpool1"
-    "zpool list -j"
-    "zpool list -j -g"
-    "zpool list -j -o fragmentation"
-    "zpool get -j size"
-    "zpool get -j all"
-    "zpool version -j"
-    "zfs list -j"
-    "zfs list -j testpool1"
-    "zfs get -j all"
-    "zfs get -j available"
-    "zfs mount -j"
-    "zfs version -j"
+    "zpool status JSONFLAG -g --json-int --json-flat-vdevs --json-pool-key-guid"
+    "zpool status -p JSONFLAG -g --json-int --json-flat-vdevs --json-pool-key-guid"
+    "zpool status JSONFLAG -c upath"
+    "zpool status JSONFLAG"
+    "zpool status JSONFLAG testpool1"
+    "zpool list JSONFLAG"
+    "zpool list JSONFLAG -g"
+    "zpool list JSONFLAG -o fragmentation"
+    "zpool get JSONFLAG size"
+    "zpool get JSONFLAG all"
+    "zpool version JSONFLAG"
+    "zfs list JSONFLAG"
+    "zfs list JSONFLAG testpool1"
+    "zfs get JSONFLAG all"
+    "zfs get JSONFLAG available"
+    "zfs mount JSONFLAG"
+    "zfs version JSONFLAG"
 )
 
-for cmd in "${list[@]}" ; do
-    log_must eval "$cmd | jq > /dev/null" 
-done
+function run_json_tests
+{
+	typeset flag=$1
+	for cmd in "${list[@]}" ; do
+	    cmd=${cmd//JSONFLAG/$flag}
+	    log_must eval "$cmd | jq > /dev/null"
+	done
+}
+
+log_must run_json_tests -j
+log_must run_json_tests --json
 
 log_pass "zpool and zfs commands outputted valid JSON"
diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_import/zpool_import_parallel_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_import/zpool_import_parallel_pos.ksh
index 71b2437a37ec..57a7412e37cc 100755
--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_import/zpool_import_parallel_pos.ksh
+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_import/zpool_import_parallel_pos.ksh
@@ -1,137 +1,137 @@
 #!/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 https://opensource.org/licenses/CDDL-1.0.
 # See the License for the specific language governing permissions
 # and limitations under the License.
 #
 # When distributing Covered Code, include this CDDL HEADER in each
 # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 # If applicable, add the following below this CDDL HEADER, with the
 # fields enclosed by brackets "[]" replaced with your own identifying
 # information: Portions Copyright [yyyy] [name of copyright owner]
 #
 # CDDL HEADER END
 #
 
 #
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
 
 #
 # Copyright (c) 2023 Klara, Inc.
 #
 
 . $STF_SUITE/include/libtest.shlib
 . $STF_SUITE/tests/functional/cli_root/zpool_import/zpool_import.cfg
 . $STF_SUITE/tests/functional/cli_root/zpool_import/zpool_import.kshlib
 
 # test uses 8 vdevs
 export MAX_NUM=8
 
 #
 # DESCRIPTION:
 # 	Verify that pool imports can occur in parallel
 #
 # STRATEGY:
 #	1. Create 8 pools
 #	2. Generate some ZIL records
 #	3. Export the pools
 #	4. Import half of the pools synchronously to baseline sequential cost
 #	5. Import the other half asynchronously to demonstrate parallel savings
 #	6. Export 4 pools
 #	7. Test zpool import -a
 #
 
 verify_runnable "global"
 
 #
 # override the minimum sized vdevs
 #
 VDEVSIZE=$((512 * 1024 * 1024))
 increase_device_sizes $VDEVSIZE
 
 POOLNAME="import_pool"
 
 function cleanup
 {
 	zinject -c all
 	log_must set_tunable64 KEEP_LOG_SPACEMAPS_AT_EXPORT 0
 	log_must set_tunable64 METASLAB_DEBUG_LOAD 0
 
 	for i in {0..$(($MAX_NUM - 1))}; do
 		destroy_pool $POOLNAME-$i
 	done
 	# reset the devices
 	increase_device_sizes 0
 	increase_device_sizes $FILE_SIZE
 }
 
 log_assert "Pool imports can occur in parallel"
 
 log_onexit cleanup
 
 log_must set_tunable64 KEEP_LOG_SPACEMAPS_AT_EXPORT 1
 log_must set_tunable64 METASLAB_DEBUG_LOAD 1
 
 
 #
 # create some exported pools with import delay injectors
 #
 for i in {0..$(($MAX_NUM - 1))}; do
 	log_must zpool create $POOLNAME-$i $DEVICE_DIR/${DEVICE_FILE}$i
 	log_must zpool export $POOLNAME-$i
 	log_must zinject -P import -s 12 $POOLNAME-$i
 done
 wait
 
 #
 # import half of the pools synchronously
 #
 SECONDS=0
 for i in {0..3}; do
 	log_must zpool import -d $DEVICE_DIR -f $POOLNAME-$i
 done
 sequential_time=$SECONDS
 log_note "sequentially imported 4 pools in $sequential_time seconds"
 
 #
 # import half of the pools in parallel
 #
 SECONDS=0
 for i in {4..7}; do
 	log_must zpool import -d $DEVICE_DIR -f $POOLNAME-$i &
 done
 wait
 parallel_time=$SECONDS
 log_note "asyncronously imported 4 pools in $parallel_time seconds"
 
-log_must test $parallel_time -lt $(($sequential_time / 3))
+log_must test $parallel_time -lt $(($sequential_time / 2))
 
 #
 # export pools with import delay injectors
 #
 for i in {4..7}; do
 	log_must zpool export $POOLNAME-$i
 	log_must zinject -P import -s 12 $POOLNAME-$i
 done
 wait
 
 #
 # now test zpool import -a
 #
 SECONDS=0
 log_must zpool import -a -d $DEVICE_DIR -f
 parallel_time=$SECONDS
 log_note "asyncronously imported 4 pools in $parallel_time seconds"
 
-log_must test $parallel_time -lt $(($sequential_time / 3))
+log_must test $parallel_time -lt $(($sequential_time / 2))
 
 log_pass "Pool imports occur in parallel"
diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/dedup/dedup_quota.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/dedup/dedup_quota.ksh
index 326152b510a9..b1657648b5a1 100755
--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/dedup/dedup_quota.ksh
+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/dedup/dedup_quota.ksh
@@ -1,235 +1,235 @@
 #!/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 https://opensource.org/licenses/CDDL-1.0.
 # See the License for the specific language governing permissions
 # and limitations under the License.
 #
 # When distributing Covered Code, include this CDDL HEADER in each
 # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 # If applicable, add the following below this CDDL HEADER, with the
 # fields enclosed by brackets "[]" replaced with your own identifying
 # information: Portions Copyright [yyyy] [name of copyright owner]
 #
 # CDDL HEADER END
 #
 
 #
 # Copyright (c) 2023, Klara Inc.
 #
 
 # DESCRIPTION:
 #	Verify that new entries are not added to the DDT when dedup_table_quota has
 #	been exceeded.
 #
 # STRATEGY:
 #	1. Create a pool with dedup=on
 #	2. Set threshold for on-disk DDT via dedup_table_quota
 #	3. Verify the threshold is exceeded after zpool sync
 #	4. Verify no new entries are added after subsequent sync's
 #	5. Remove all but one entry from DDT
 #	6. Verify new entries are added to DDT
 #
 
 . $STF_SUITE/include/libtest.shlib
 . $STF_SUITE/tests/functional/events/events_common.kshlib
 
 verify_runnable "both"
 
 log_assert "DDT quota is enforced"
 
 MOUNTDIR="$TEST_BASE_DIR/dedup_mount"
 FILEPATH="$MOUNTDIR/dedup_file"
 VDEV_GENERAL="$TEST_BASE_DIR/vdevfile.general.$$"
 VDEV_DEDUP="$TEST_BASE_DIR/vdevfile.dedup.$$"
 POOL="dedup_pool"
 
 save_tunable TXG_TIMEOUT
 
 # we set the dedup log txg interval to 1, to get a log flush every txg,
 # effectively disabling the log. without this it's hard to predict when and
 # where things appear on-disk
 log_must save_tunable DEDUP_LOG_TXG_MAX
 log_must set_tunable32 DEDUP_LOG_TXG_MAX 1
 
 function cleanup
 {
 	if poolexists $POOL ; then
 		destroy_pool $POOL
 	fi
 	log_must rm -fd $VDEV_GENERAL $VDEV_DEDUP $MOUNTDIR
 	log_must restore_tunable TXG_TIMEOUT
 	log_must restore_tunable DEDUP_LOG_TXG_MAX
 }
 
 
 function do_clean
 {
 	log_must destroy_pool $POOL
 	log_must rm -fd $VDEV_GENERAL $VDEV_DEDUP $MOUNTDIR
 }
 
 function do_setup
 {
 	log_must truncate -s 5G $VDEV_GENERAL
 	# Use 'xattr=sa' to prevent selinux xattrs influencing our accounting
 	log_must zpool create -o ashift=12 -f -O xattr=sa -m $MOUNTDIR $POOL $VDEV_GENERAL
 	log_must zfs set dedup=on $POOL
 	log_must set_tunable32 TXG_TIMEOUT 600
 }
 
 function dedup_table_size
 {
 	get_pool_prop dedup_table_size $POOL
 }
 
 function dedup_table_quota
 {
 	get_pool_prop dedup_table_quota $POOL
 }
 
 function ddt_entries
 {
 	typeset -i entries=$(zpool status -D $POOL | \
 		grep "dedup: DDT entries" | awk '{print $4}')
 
 	echo ${entries}
 }
 
 function ddt_add_entry
 {
 	count=$1
 	offset=$2
 	expand=$3
 
 	if [ -z "$offset" ]; then
 		offset=1
 	fi
 
 	for i in {$offset..$count}; do
 		echo "$i" > $MOUNTDIR/dedup-$i.txt
 	done
 	log_must sync_pool $POOL
 
 	log_note range $offset - $(( count + offset - 1 ))
 	log_note ddt_add_entry got $(ddt_entries)
 }
 
 # Create 6000 entries over three syncs
 function ddt_nolimit
 {
 	do_setup
 
 	log_note base ddt entries is $(ddt_entries)
 
 	ddt_add_entry 1
 	ddt_add_entry 100
 	ddt_add_entry 101 5000
 	ddt_add_entry 5001 6000
 
 	log_must test $(ddt_entries) -eq 6000
 
 	do_clean
 }
 
 function ddt_limit
 {
 	do_setup
 
 	log_note base ddt entries is $(ddt_entries)
 
 	log_must zpool set dedup_table_quota=32768 $POOL
 	ddt_add_entry 100
 
 	# it's possible to exceed dedup_table_quota over a single transaction,
 	# ensure that the threshold has been exceeded
 	cursize=$(dedup_table_size)
 	log_must test $cursize -gt $(dedup_table_quota)
 
 	# count the entries we have
 	log_must test $(ddt_entries) -ge 100
 
 	# attempt to add new entries
 	ddt_add_entry 101 200
 	log_must test $(ddt_entries) -eq 100
 	log_must test $cursize -eq $(dedup_table_size)
 
 	# remove all but one entry
 	for i in {2..100}; do
 		rm $MOUNTDIR/dedup-$i.txt
 	done
 	log_must sync_pool $POOL
 
 	log_must test $(ddt_entries) -eq 1
 	log_must test $cursize -gt $(dedup_table_size)
 	cursize=$(dedup_table_size)
 
 	log_must zpool set dedup_table_quota=none $POOL
 
 	# create more entries
 	zpool status -D $POOL
 	ddt_add_entry 101 200
 	log_must sync_pool $POOL
 
 	log_must test $(ddt_entries) -eq 101
 	log_must test $cursize -lt $(dedup_table_size)
 
 	do_clean
 }
 
 function ddt_dedup_vdev_limit
 {
 	do_setup
 
 	# add a dedicated dedup/special VDEV and enable an automatic quota
 	if (( RANDOM % 2 == 0 )) ; then
 		class="special"
 	else
 		class="dedup"
 	fi
 	log_must truncate -s 200M $VDEV_DEDUP
 	log_must zpool add $POOL $class $VDEV_DEDUP
 	log_must zpool set dedup_table_quota=auto $POOL
 
 	log_must zfs set recordsize=1K $POOL
 	log_must zfs set compression=zstd $POOL
 
 	# Generate a working set to fill up the dedup/special allocation class
 	log_must fio --directory=$MOUNTDIR --name=dedup-filler-1 \
 		--rw=read --bs=1m --numjobs=2 --iodepth=8 \
 		--size=512M --end_fsync=1 --ioengine=posixaio --runtime=1 \
 		--group_reporting --fallocate=none --output-format=terse \
 		--dedupe_percentage=0
 	log_must sync_pool $POOL
 
 	zpool status -D $POOL
 	zpool list -v $POOL
 	echo DDT size $(dedup_table_size), with $(ddt_entries) entries
 
 	#
 	# With no DDT quota in place, the above workload will produce over
 	# 800,000 entries by using space in the normal class. With a quota, it
 	# should be well under 500,000. However, logged entries are hard to
 	# account for because they can appear on both logs, and can also
 	# represent an eventual removal. This isn't easily visible from
 	# outside, and even internally can result in going slightly over quota.
 	# For here, we just set the entry count a little higher than what we
 	# expect to allow for some instability.
 	#
-	log_must test $(ddt_entries) -le 600000
+	log_must test $(ddt_entries) -le 650000
 
 	do_clean
 }
 
 log_onexit cleanup
 
 ddt_limit
 ddt_nolimit
 ddt_dedup_vdev_limit
 
 log_pass "DDT quota is enforced"
diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/direct/dio.kshlib b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/direct/dio.kshlib
index 3a70cf293967..5b3f893e1ce1 100644
--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/direct/dio.kshlib
+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/direct/dio.kshlib
@@ -1,331 +1,333 @@
 #
 # 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) 2021 by Lawrence Livermore National Security, LLC.
 #
 
 . $STF_SUITE/include/libtest.shlib
 . $STF_SUITE/tests/functional/direct/dio.cfg
 
 function dio_cleanup
 {
 	if poolexists $TESTPOOL1; then
 		destroy_pool $TESTPOOL1
 	fi
 
 	rm -f $DIO_VDEVS
 }
 
 #
 # Generate an IO workload using fio and then verify the resulting data.
 #
 function dio_and_verify # mode file-size block-size directory ioengine extra-args
 {
 	typeset mode=$1
 	typeset size=$2
 	typeset bs=$3
 	typeset mntpnt=$4
 	typeset ioengine=$5
 	typeset extra_args=$6
 
 	# Invoke an fio workload via Direct I/O and verify with Direct I/O.
 	log_must fio --directory=$mntpnt --name=direct-$mode \
 	    --rw=$mode --size=$size --bs=$bs --direct=1 --numjobs=1 \
 	    --verify=sha1 --ioengine=$ioengine --fallocate=none \
 	    --group_reporting --minimal --do_verify=1 $extra_args
 
 	# Now just read back the file without Direct I/O into the ARC as an
 	# additional verfication step.
 	log_must fio --directory=$mntpnt --name=direct-$mode \
 	    --rw=read --size=$size --bs=$bs --direct=0 --numjobs=1 \
 		--ioengine=$ioengine --group_reporting --minimal
 
 	log_must rm -f "$mntpnt/direct-*"
 }
 
 #
 # Get zpool status -d checksum verify failures
 #
 function get_zpool_status_chksum_verify_failures # pool_name vdev_type
 {
 	typeset pool=$1
 	typeset vdev_type=$2
 
 	if [[ "$vdev_type" == "stripe" ]]; then
 		val=$(zpool status -dp $pool | \
 		    awk '{s+=$6} END {print s}' )
 	elif [[ "$vdev_type" == "mirror" || "$vdev_type" == "raidz" ||
 	    "$vdev_type" == "draid" ]]; then 
 		val=$(zpool status -dp $pool | \
 		    awk -v d="$vdev_type" '$0 ~ d {print $6}' )
 	else
 		log_fail "Unsupported VDEV type in \
 		   get_zpool_status_chksum_verify_failures(): $vdev_type"
 	fi
 	echo "$val"
 }
 
 #
 # Get ZED dio_verify events
 #
 function get_zed_dio_verify_events # pool
 {
 	typeset pool=$1
+	typeset op=$2
 
-	val=$(zpool events $pool | grep -c dio_verify)
+	val=$(zpool events $pool | grep -c "dio_verify_${op}")
 
 	echo "$val"
 }
 
 #
 # Checking for checksum verify write failures with:
 # zpool status -d
 # zpool events
 # After getting that counts will clear the out the ZPool errors and events
 #
-function check_dio_write_chksum_verify_failures # pool vdev_type expect_errors
+function check_dio_chksum_verify_failures # pool vdev_type op expect_errors
 {
 	typeset pool=$1
 	typeset vdev_type=$2
 	typeset expect_errors=$3
+	typeset op=$4
 	typeset note_str="expecting none"
 
 	if [[ $expect_errors -ne 0 ]]; then
 		note_str="expecting some"
 	fi
 
 	log_note "Checking for Direct I/O write checksum verify errors \
-	    $note_str on ZPool: $pool"
+	    $note_str on ZPool: $pool with $vdev_type"
 
 	status_failures=$(get_zpool_status_chksum_verify_failures $pool $vdev_type)
-	zed_dio_verify_events=$(get_zed_dio_verify_events $pool)
+	zed_dio_verify_events=$(get_zed_dio_verify_events $pool $op)
 
 	if [[ $expect_errors -ne 0 ]]; then
 		if [[ $status_failures -eq 0 ||
 		    $zed_dio_verify_events -eq 0 ]]; then
 			zpool status -dp $pool
 			zpool events $pool
 			log_fail "Checksum verifies in zpool status -d  \
 			    $status_failures. ZED dio_verify events \
 			    $zed_dio_verify_events. Neither should be 0."
 		fi
 	else
 		if [[ $status_failures -ne 0 ||
 		    $zed_dio_verify_events -ne 0 ]]; then
 			zpool status -dp $pool
 			zpool events $pool
 			log_fail "Checksum verifies in zpool status -d  \
 			    $status_failures. ZED dio_verify events \
 			    $zed_dio_verify_events. Both should be zero."
 		fi
 	fi
 
 	log_must zpool clear $pool
 	log_must zpool events -c
 
 }
 
 #
 # Get the value of a counter from
 # Linux: /proc/spl/kstat/zfs/$pool/iostats file.
 # FreeBSD: kstat.zfs.$pool.msic.iostats.$stat
 #
 function get_iostats_stat # pool stat
 {
 	typeset pool=$1
 	typeset stat=$2
 
 	if is_linux; then
 		iostats_file=/proc/spl/kstat/zfs/$pool/iostats
 		val=$(grep -m1 "$stat" $iostats_file | awk '{ print $3 }')
 	else
 		val=$(sysctl -n kstat.zfs.$pool.misc.iostats.$stat)
 	fi
 	if [[ -z "$val" ]]; then
 		log_fail "Unable to read $stat counter"
 	fi
 
 	echo "$val"
 }
 
 #
 # Evict any buffered blocks by overwritting them using an O_DIRECT request.
 #
 function evict_blocks
 {
 	typeset pool=$1
 	typeset file=$2
 	typeset size=$3
 
 	log_must stride_dd -i /dev/urandom -o $file -b $size -c 1 -D
 }
 
 #
 # Perform FIO Direct I/O writes to a file with the given arguments.
 # Then verify thae minimum expected number of blocks were written as
 # Direct I/O.
 #
 function verify_dio_write_count #pool bs size mnpnt
 {
 	typeset pool=$1
 	typeset bs=$2
 	typeset size=$3
 	typeset mntpnt=$4
 	typeset dio_wr_expected=$(((size / bs) -1))
 
 	log_note "Checking for $dio_wr_expected Direct I/O writes"
 
 	prev_dio_wr=$(get_iostats_stat $pool direct_write_count)
 	dio_and_verify write $size $bs $mntpnt "sync"
 	curr_dio_wr=$(get_iostats_stat $pool direct_write_count)
 	dio_wr_actual=$((curr_dio_wr - prev_dio_wr))
 
 	if [[ $dio_wr_actual -lt $dio_wr_expected ]]; then
 		if is_linux; then
 			cat /proc/spl/kstat/zfs/$pool/iostats
 		else
 			sysctl kstat.zfs.$pool.misc.iostats
 		fi
 		log_fail "Direct writes $dio_wr_actual of $dio_wr_expected"
 	fi
 }
 
 #
 # Perform a stride_dd write command to the file with the given arguments.
 # Then verify the minimum expected number of blocks were written as either
 # buffered IO (by the ARC), or Direct I/O to the application (dd).
 #
 function check_write # pool file bs count seek flags buf_wr dio_wr
 {
 	typeset pool=$1
 	typeset file=$2
 	typeset bs=$3
 	typeset count=$4
 	typeset seek=$5
 	typeset flags=$6
 	typeset buf_wr_expect=$7
 	typeset dio_wr_expect=$8
 
 	log_note "Checking $count * $bs write(s) at offset $seek, $flags"
 
 	prev_buf_wr=$(get_iostats_stat $pool arc_write_count)
 	prev_dio_wr=$(get_iostats_stat $pool direct_write_count)
 
 	log_must stride_dd -i /dev/urandom -o $file -b $bs -c $count \
 	    -k $seek $flags
 
 	curr_buf_wr=$(get_iostats_stat $pool arc_write_count)
 	buf_wr_actual=$((curr_buf_wr - prev_buf_wr))
 
 	curr_dio_wr=$(get_iostats_stat $pool direct_write_count)
 	dio_wr_actual=$((curr_dio_wr - prev_dio_wr))
 
 	if [[ $buf_wr_actual -lt $buf_wr_expect ]]; then
 		if is_linux; then
 			cat /proc/spl/kstat/zfs/$pool/iostats
 		else
 			sysctl kstat.zfs.$pool.misc.iostats
 		fi
 		log_fail "Buffered writes $buf_wr_actual of $buf_wr_expect"
 	fi
 
 	if [[ $dio_wr_actual -lt $dio_wr_expect ]]; then
 		if is_linux; then
 			cat /proc/spl/kstat/zfs/$pool/iostats
 		else
 			sysctl kstat.zfs.$pool.misc.iostats
 		fi
 		log_fail "Direct writes $dio_wr_actual of $dio_wr_expect"
 	fi
 }
 
 #
 # Perform a stride_dd read command to the file with the given arguments.
 # Then verify the minimum expected number of blocks were read as either
 # buffered IO (by the ARC), or Direct I/O to the application (dd).
 #
 function check_read # pool file bs count skip flags buf_rd dio_rd
 {
 	typeset pool=$1
 	typeset file=$2
 	typeset bs=$3
 	typeset count=$4
 	typeset skip=$5
 	typeset flags=$6
 	typeset buf_rd_expect=$7
 	typeset dio_rd_expect=$8
 
 	log_note "Checking $count * $bs read(s) at offset $skip, $flags"
 
 	prev_buf_rd=$(get_iostats_stat $pool arc_read_count)
 	prev_dio_rd=$(get_iostats_stat $pool direct_read_count)
 
 	log_must stride_dd -i $file -o /dev/null -b $bs -c $count \
 	    -p $skip $flags
 
 	curr_buf_rd=$(get_iostats_stat $pool arc_read_count)
 	buf_rd_actual=$((curr_buf_rd - prev_buf_rd))
 
 	curr_dio_rd=$(get_iostats_stat $pool direct_read_count)
 	dio_rd_actual=$((curr_dio_rd - prev_dio_rd))
 
 	if [[ $buf_rd_actual -lt $buf_rd_expect ]]; then
 		if is_linux; then
 			cat /proc/spl/kstat/zfs/$pool/iostats
 		else
 			sysctl kstat.zfs.$pool.misc.iostats
 		fi
 		log_fail "Buffered reads $buf_rd_actual of $buf_rd_expect"
 	fi
 
 	if [[ $dio_rd_actual -lt $dio_rd_expect ]]; then
 		if is_linux; then
 			cat /proc/spl/kstat/zfs/$pool/iostats
 		else
 			sysctl kstat.zfs.$pool.misc.iostats
 		fi
 		log_fail "Direct reads $dio_rd_actual of $dio_rd_expect"
 	fi
 }
 
 function get_file_size
 {
 	typeset filename="$1"
 
 	if is_linux; then
 		filesize=$(stat -c %s $filename)
 	else
 		filesize=$(stat -s $filename | awk '{print $8}' | grep -o '[0-9]\+')
 	fi
 
 	echo $filesize
 }
 
 function do_truncate_reduce
 {
 	typeset filename=$1
 	typeset size=$2
 
 	filesize=$(get_file_size $filename)
 	eval "echo original filesize: $filesize"
 	if is_linux; then
 		truncate $filename -s $((filesize - size))
 	else
 		truncate -s -$size $filename
 	fi
 	filesize=$(get_file_size $filename)
 	eval "echo new filesize after truncate: $filesize"
 }
diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/direct/dio_read_verify.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/direct/dio_read_verify.ksh
new file mode 100755
index 000000000000..456d429b1d99
--- /dev/null
+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/direct/dio_read_verify.ksh
@@ -0,0 +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 https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2024 by Triad National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# 	Verify checksum verify works for Direct I/O reads.
+#
+# STRATEGY:
+#	1. Create a zpool from each vdev type.
+#	2. Start a Direct I/O read workload while manipulating the user buffer
+#	   contents.
+#	3. Verify there are Direct I/O read verify failures using
+#	   zpool status -d and checking for zevents. We also make sure there
+#	   are reported no data errors.
+#
+
+verify_runnable "global"
+
+log_assert "Verify checksum verify works for Direct I/O reads."
+
+log_onexit dio_cleanup
+
+NUMBLOCKS=300
+BS=$((128 * 1024)) # 128k
+
+log_must  truncate -s $MINVDEVSIZE $DIO_VDEVS
+
+# We will verify that there are no checksum errors for every Direct I/O read
+# while manipulating the buffer contents while the I/O is still in flight and
+# also that Direct I/O checksum verify failures and dio_verify_rd zevents are
+# reported.
+
+
+for type in "" "mirror" "raidz" "draid"; do
+	typeset vdev_type=$type
+	if [[ "${vdev_type}" == "" ]]; then
+		vdev_type="stripe"
+	fi
+
+	log_note "Verifying every Direct I/O read verify with VDEV type \
+	    ${vdev_type}"
+
+	create_pool $TESTPOOL1 $type $DIO_VDEVS
+	log_must eval "zfs create -o recordsize=128k -o compression=off  \
+	    $TESTPOOL1/$TESTFS1"
+
+	mntpnt=$(get_prop mountpoint $TESTPOOL1/$TESTFS1)
+	prev_dio_rd=$(get_iostats_stat $TESTPOOL1 direct_read_count)
+	prev_arc_rd=$(get_iostats_stat $TESTPOOL1 arc_read_count)
+
+	# Create the file before trying to manipulate the contents
+	log_must stride_dd -o "$mntpnt/direct-write.iso" -i /dev/urandom \
+	    -b $BS -c $NUMBLOCKS -D
+	# Manipulate the buffer contents will reading the file with Direct I/O
+	log_must manipulate_user_buffer -f "$mntpnt/direct-write.iso" \
+	    -n $NUMBLOCKS -b $BS -r
+
+	# Getting new Direct I/O and ARC Write counts.
+	curr_dio_rd=$(get_iostats_stat $TESTPOOL1 direct_read_count)
+	curr_arc_rd=$(get_iostats_stat $TESTPOOL1 arc_read_count)
+	total_dio_rd=$((curr_dio_rd - prev_dio_rd))
+	total_arc_rd=$((curr_arc_rd - prev_arc_rd))
+
+	log_note "Making sure there are no checksum errors with the ZPool"
+	log_must check_pool_status $TESTPOOL "errors" "No known data errors"
+
+	log_note "Making sure we have Direct I/O and ARC reads logged"
+	if [[ $total_dio_rd -lt 1 ]]; then
+		log_fail "No Direct I/O reads $total_dio_rd"
+	fi
+	if [[ $total_arc_rd -lt 1 ]]; then
+		log_fail "No ARC reads $total_arc_rd"
+	fi
+
+	log_note "Making sure we have Direct I/O write checksum verifies with ZPool"
+	check_dio_chksum_verify_failures "$TESTPOOL1" "$vdev_type" 1 "rd"
+	destroy_pool $TESTPOOL1
+done
+
+log_pass "Verified checksum verify works for Direct I/O reads." 
diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/direct/dio_write_stable_pages.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/direct/dio_write_stable_pages.ksh
index efc9ee639184..ccdabc678a68 100755
--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/direct/dio_write_stable_pages.ksh
+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/direct/dio_write_stable_pages.ksh
@@ -1,103 +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 https://opensource.org/licenses/CDDL-1.0.
 # See the License for the specific language governing permissions
 # and limitations under the License.
 #
 # When distributing Covered Code, include this CDDL HEADER in each
 # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 # If applicable, add the following below this CDDL HEADER, with the
 # fields enclosed by brackets "[]" replaced with your own identifying
 # information: Portions Copyright [yyyy] [name of copyright owner]
 #
 # CDDL HEADER END
 #
 
 #
 # Copyright (c) 2022 by Triad National Security, LLC.
 #
 
 . $STF_SUITE/include/libtest.shlib
 . $STF_SUITE/tests/functional/direct/dio.cfg
 . $STF_SUITE/tests/functional/direct/dio.kshlib
 
 #
 # DESCRIPTION:
 # 	Verify stable pages work for O_DIRECT writes.
 #
 # STRATEGY:
 #	1. Start a Direct I/O write workload while manipulating the user
 #	   buffer.
 #	2. Verify we can Read the contents of the file using buffered reads.
 #	3. Verify there is no checksum errors reported from zpool status.
 #	4. Repeat steps 1 and 2 for 3 iterations.
 #	5. Repeat 1-3 but with compression disabled.
 #
 
 verify_runnable "global"
 
 function cleanup
 {
 	log_must rm -f "$mntpnt/direct-write.iso"
-	check_dio_write_chksum_verify_failures $TESTPOOL "raidz" 0
+	check_dio_chksum_verify_failures $TESTPOOL "raidz" 0 "wr"
 }
 
 log_assert "Verify stable pages work for Direct I/O writes."
 
 if is_linux; then
 	log_unsupported "Linux does not support stable pages for O_DIRECT \
 	     writes"
 fi
 
 log_onexit cleanup
 
 ITERATIONS=3
 NUMBLOCKS=300
 BS=$((128 * 1024)) #128k
 mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
 log_must zfs set recordsize=128k $TESTPOOL/$TESTFS
 
 for compress in "on" "off";
 do
 	log_must zfs set compression=$compress $TESTPOOL/$TESTFS
 
 	for i in $(seq 1 $ITERATIONS); do
 		log_note "Verifying stable pages for Direct I/O writes \
 		    iteration $i of $ITERATIONS"
 
 		prev_dio_wr=$(get_iostats_stat $TESTPOOL direct_write_count)
 
 		# Manipulate the user's buffer while running O_DIRECT write
 		# workload with the buffer.
-		log_must manipulate_user_buffer -o "$mntpnt/direct-write.iso" \
-		    -n $NUMBLOCKS -b $BS 
+		log_must manipulate_user_buffer -f "$mntpnt/direct-write.iso" \
+		    -n $NUMBLOCKS -b $BS -w 
 
 		# Reading back the contents of the file
 		log_must stride_dd -i $mntpnt/direct-write.iso -o /dev/null \
 		    -b $BS -c $NUMBLOCKS
 
 		curr_dio_wr=$(get_iostats_stat $TESTPOOL direct_write_count)
 		total_dio_wr=$((curr_dio_wr - prev_dio_wr))
 
 		log_note "Making sure we have Direct I/O writes logged"
 		if [[ $total_dio_wr -lt 1 ]]; then
 			log_fail "No Direct I/O writes $total_dio_wr"
 		fi
 
 		# Making sure there are no data errors for the zpool
 		log_note "Making sure there are no checksum errors with the ZPool"
 		log_must check_pool_status $TESTPOOL "errors" \
 		    "No known data errors"
 
 		log_must rm -f "$mntpnt/direct-write.iso"
 	done
 done
 
 log_pass "Verified stable pages work for Direct I/O writes."
diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/direct/dio_write_verify.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/direct/dio_write_verify.ksh
index 536459a35e6c..4eb9efe95ef1 100755
--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/direct/dio_write_verify.ksh
+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/direct/dio_write_verify.ksh
@@ -1,196 +1,196 @@
 #!/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 https://opensource.org/licenses/CDDL-1.0.
 # See the License for the specific language governing permissions
 # and limitations under the License.
 #
 # When distributing Covered Code, include this CDDL HEADER in each
 # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 # If applicable, add the following below this CDDL HEADER, with the
 # fields enclosed by brackets "[]" replaced with your own identifying
 # information: Portions Copyright [yyyy] [name of copyright owner]
 #
 # CDDL HEADER END
 #
 
 #
 # Copyright (c) 2022 by Triad National Security, LLC.
 #
 
 . $STF_SUITE/include/libtest.shlib
 . $STF_SUITE/tests/functional/direct/dio.cfg
 . $STF_SUITE/tests/functional/direct/dio.kshlib
 
 #
 # DESCRIPTION:
 # 	Verify checksum verify works for Direct I/O writes.
 #
 # STRATEGY:
 #	1. Set the module parameter zfs_vdev_direct_write_verify to 0.
 #	2. Check that manipulating the user buffer while Direct I/O writes are
 #	   taking place does not cause any panics with compression turned on.
 #	3. Start a Direct I/O write workload while manipulating the user buffer
 #	   without compression.
 #	4. Verify there are Direct I/O write verify failures using
 #	   zpool status -d and checking for zevents. We also make sure there
 #	   are reported data errors when reading the file back.
 #	5. Repeat steps 3 and 4 for 3 iterations.
 #	6. Set zfs_vdev_direct_write_verify set to 1 and repeat 3.
 #	7. Verify there are Direct I/O write verify failures using
 #	   zpool status -d and checking for zevents. We also make sure there
 #	   there are no reported data errors when reading the file back because
 #	   with us checking every Direct I/O write and on checksum validation
 #	   failure those writes will not be committed to a VDEV.
 #
 
 verify_runnable "global"
 
 function cleanup
 {
 	# Clearing out DIO counts for Zpool
 	log_must zpool clear $TESTPOOL
 	# Clearing out dio_verify from event logs
 	log_must zpool events -c
 	log_must set_tunable32 VDEV_DIRECT_WR_VERIFY $DIO_WR_VERIFY_TUNABLE
 }
 
 log_assert "Verify checksum verify works for Direct I/O writes."
 
 if is_freebsd; then
 	log_unsupported "FreeBSD is capable of stable pages for O_DIRECT writes"
 fi
 
 log_onexit cleanup
 
 ITERATIONS=3
 NUMBLOCKS=300
 BS=$((128 * 1024)) # 128k
 mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
 typeset DIO_WR_VERIFY_TUNABLE=$(get_tunable VDEV_DIRECT_WR_VERIFY)
 
 # Get a list of vdevs in our pool
 set -A array $(get_disklist_fullpath $TESTPOOL)
 
 # Get the first vdev
 firstvdev=${array[0]}
 
 log_must zfs set recordsize=128k $TESTPOOL/$TESTFS
 log_must set_tunable32 VDEV_DIRECT_WR_VERIFY 0
 
 # First we will verify there are no panics while manipulating the contents of
 # the user buffer during Direct I/O writes with compression. The contents
 # will always be copied out of the ABD and there should never be any ABD ASSERT
 # failures
 log_note "Verifying no panics for Direct I/O writes with compression"
 log_must zfs set compression=on $TESTPOOL/$TESTFS
 prev_dio_wr=$(get_iostats_stat $TESTPOOL direct_write_count)
-log_must manipulate_user_buffer -o "$mntpnt/direct-write.iso" -n $NUMBLOCKS \
-    -b $BS
+log_must manipulate_user_buffer -f "$mntpnt/direct-write.iso" -n $NUMBLOCKS \
+    -b $BS -w
 curr_dio_wr=$(get_iostats_stat $TESTPOOL direct_write_count)
 total_dio_wr=$((curr_dio_wr - prev_dio_wr))
 
 log_note "Making sure we have Direct I/O writes logged"
 if [[ $total_dio_wr -lt 1 ]]; then
 	log_fail "No Direct I/O writes $total_dio_wr"
 fi
 
 # Clearing out DIO counts for Zpool
 log_must zpool clear $TESTPOOL
 # Clearing out dio_verify from event logs
 log_must zpool events -c
 log_must rm -f "$mntpnt/direct-write.iso"
 
 # Next we will verify there are checksum errors for Direct I/O writes while
 # manipulating the contents of the user pages.
 log_must zfs set compression=off $TESTPOOL/$TESTFS
 
 for i in $(seq 1 $ITERATIONS); do
 	log_note "Verifying Direct I/O write checksums iteration \
 	    $i of $ITERATIONS with zfs_vdev_direct_write_verify=0"
 
 	prev_dio_wr=$(get_iostats_stat $TESTPOOL direct_write_count)
-	log_must manipulate_user_buffer -o "$mntpnt/direct-write.iso" \
-	    -n $NUMBLOCKS -b $BS
+	log_must manipulate_user_buffer -f "$mntpnt/direct-write.iso" \
+	    -n $NUMBLOCKS -b $BS -w
 
 	# Reading file back to verify checksum errors
 	filesize=$(get_file_size "$mntpnt/direct-write.iso")
 	num_blocks=$((filesize / BS))
 	log_mustnot stride_dd -i "$mntpnt/direct-write.iso" -o /dev/null -b $BS \
 	    -c $num_blocks
 
 	# Getting new Direct I/O and ARC write counts.
 	curr_dio_wr=$(get_iostats_stat $TESTPOOL direct_write_count)
 	total_dio_wr=$((curr_dio_wr - prev_dio_wr))
 
 	# Verifying there are checksum errors
 	log_note "Making sure there are checksum errors for the ZPool"
 	cksum=$(zpool status -P -v $TESTPOOL | awk -v v="$firstvdev" '$0 ~ v \
 	    {print $5}')
 	if  [[ $cksum -eq 0 ]]; then
 		zpool status -P -v $TESTPOOL
 		log_fail "No checksum failures for ZPool $TESTPOOL"
 	fi
 	
 	log_note "Making sure we have Direct I/O writes logged"
 	if [[ $total_dio_wr -lt 1 ]]; then
 		log_fail "No Direct I/O writes $total_dio_wr"
 	fi
 	log_note "Making sure we have no Direct I/O write checksum verifies \
 	    with ZPool"
-	check_dio_write_chksum_verify_failures $TESTPOOL "raidz" 0
+	check_dio_chksum_verify_failures $TESTPOOL "raidz" 0 "wr"
 
 	log_must rm -f "$mntpnt/direct-write.iso"
 done
 
 log_must zpool status -v $TESTPOOL
 log_must zpool sync $TESTPOOL
 
 
 
 # Finally we will verfiy that with checking every Direct I/O write we have no
 # errors at all.
 # Create the file before trying to manipulate the contents
 log_must file_write -o create -f "$mntpnt/direct-write.iso" -b $BS \
     -c $NUMBLOCKS -w
 log_must set_tunable32 VDEV_DIRECT_WR_VERIFY 1
 
 for i in $(seq 1 $ITERATIONS); do
 	log_note "Verifying every Direct I/O write checksums iteration $i of \
 	    $ITERATIONS with zfs_vdev_direct_write_verify=1"
 
 	prev_dio_wr=$(get_iostats_stat $TESTPOOL direct_write_count)
-	log_must manipulate_user_buffer -o "$mntpnt/direct-write.iso" \
-	    -n $NUMBLOCKS -b $BS -e
+	log_must manipulate_user_buffer -f "$mntpnt/direct-write.iso" \
+	    -n $NUMBLOCKS -b $BS -e -w
 
 	# Reading file back to verify there no are checksum errors
 	filesize=$(get_file_size "$mntpnt/direct-write.iso")
 	num_blocks=$((filesize / BS))
 	log_must stride_dd -i "$mntpnt/direct-write.iso" -o /dev/null -b $BS \
 	    -c $num_blocks
 
-	# Getting new Direct I/O and ARC Write counts.
+	# Getting new Direct I/O write counts.
 	curr_dio_wr=$(get_iostats_stat $TESTPOOL direct_write_count)
 	total_dio_wr=$((curr_dio_wr - prev_dio_wr))
 
 	log_note "Making sure there are no checksum errors with the ZPool"
 	log_must check_pool_status $TESTPOOL "errors" "No known data errors"
 
 	log_note "Making sure we have Direct I/O writes logged"
 	if [[ $total_dio_wr -lt 1 ]]; then
 		log_fail "No Direct I/O writes $total_dio_wr"
 	fi
 
 	log_note "Making sure we have Direct I/O write checksum verifies with ZPool"
-	check_dio_write_chksum_verify_failures "$TESTPOOL" "raidz" 1
+	check_dio_chksum_verify_failures "$TESTPOOL" "raidz" 1 "wr"
 done
 
 log_must rm -f "$mntpnt/direct-write.iso"
 
 log_pass "Verified checksum verify works for Direct I/O writes." 
diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/replacement/resilver_restart_001.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/replacement/resilver_restart_001.ksh
index 629870adf9ea..101fa410bdb6 100755
--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/replacement/resilver_restart_001.ksh
+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/replacement/resilver_restart_001.ksh
@@ -1,196 +1,199 @@
 #!/bin/ksh -p
 
 #
 # CDDL HEADER START
 #
 # This file and its contents are supplied under the terms of the
 # Common Development and Distribution License ("CDDL"), version 1.0.
 # You may only use this file in accordance with the terms of version
 # 1.0 of the CDDL.
 #
 # A full copy of the text of the CDDL should have accompanied this
 # source.  A copy of the CDDL is also available via the Internet at
 # http://www.illumos.org/license/CDDL.
 #
 # CDDL HEADER END
 #
 
 #
 # Copyright (c) 2019, Datto Inc. All rights reserved.
 #
 
 . $STF_SUITE/include/libtest.shlib
 . $STF_SUITE/tests/functional/replacement/replacement.cfg
 
 #
 # DESCRIPTION:
 # Testing resilver restart logic both with and without the deferred resilver
 # feature enabled, verifying that resilver is not restarted when it is
 # unnecessary.
 #
 # STRATEGY:
 # 1. Create a pool
 # 2. Create four filesystems with the primary cache disable to force reads
 # 3. Write four files simultaneously, one to each filesystem
 # 4. Do with and without deferred resilvers enabled
 #    a. Replace a vdev with a spare & suspend resilver immediately
 #    b. Verify resilver starts properly
 #    c. Offline / online another vdev to introduce a new DTL range
 #    d. Verify resilver restart or defer
 #    e. Inject read errors on vdev that was offlined / onlned
 #    f. Verify that resilver did not restart
 #    g. Unsuspend resilver and wait for it to finish
 #    h. Verify that there are two resilvers and nothing is deferred
 #
 
 function cleanup
 {
 	log_must set_tunable32 RESILVER_MIN_TIME_MS $ORIG_RESILVER_MIN_TIME
 	log_must set_tunable32 SCAN_SUSPEND_PROGRESS \
 	    $ORIG_SCAN_SUSPEND_PROGRESS
+	log_must set_tunable32 RESILVER_DEFER_PERCENT \
+	    $ORIG_RESILVER_DEFER_PERCENT
 	log_must set_tunable32 ZEVENT_LEN_MAX $ORIG_ZFS_ZEVENT_LEN_MAX
 	log_must zinject -c all
 	destroy_pool $TESTPOOL1
 	rm -f ${VDEV_FILES[@]} $SPARE_VDEV_FILE
 }
 
 # count resilver events in zpool and number of deferred rsilvers on vdevs
 function verify_restarts # <msg> <cnt> <defer>
 {
 	msg=$1
 	cnt=$2
 	defer=$3
 
 	# check the number of resilver start in events log
 	RESILVERS=$(zpool events | grep -c sysevent.fs.zfs.resilver_start)
 	log_note "expected $cnt resilver start(s)$msg, found $RESILVERS"
 	[[ "$RESILVERS" -ne "$cnt" ]] &&
 	    log_fail "expected $cnt resilver start(s)$msg, found $RESILVERS"
 
 	[[ -z "$defer" ]] && return
 
 	# use zdb to find which vdevs have the resilver defer flag
 	VDEV_DEFERS=$(zdb -C $TESTPOOL1 | awk '
 	    /children/ { gsub(/[^0-9]/, ""); child = $0 }
 	    /com\.datto:resilver_defer$/ { print child }
 	')
 
 	if [[ "$defer" == "-" ]]
 	then
 		[[ -n $VDEV_DEFERS ]] &&
 		    log_fail "didn't expect any vdevs to have resilver deferred"
 		return
 	fi
 
 	[[ $VDEV_DEFERS -eq $defer ]] ||
 	    log_fail "resilver deferred set on unexpected vdev: $VDEV_DEFERS"
 }
 
 log_assert "Check for unnecessary resilver restarts"
 
 ORIG_RESILVER_MIN_TIME=$(get_tunable RESILVER_MIN_TIME_MS)
 ORIG_SCAN_SUSPEND_PROGRESS=$(get_tunable SCAN_SUSPEND_PROGRESS)
+ORIG_RESILVER_DEFER_PERCENT=$(get_tunable RESILVER_DEFER_PERCENT)
 ORIG_ZFS_ZEVENT_LEN_MAX=$(get_tunable ZEVENT_LEN_MAX)
 
 set -A RESTARTS -- '1' '2' '2' '2'
 set -A VDEVS -- '' '' '' ''
 set -A DEFER_RESTARTS -- '1' '1' '1' '2'
 set -A DEFER_VDEVS -- '-' '2' '2' '-'
 set -A EARLY_RESTART_DEFER_RESTARTS -- '1' '2' '2' '2'
 set -A EARLY_RESTART_DEFER_VDEVS -- '' '' '' ''
 
 VDEV_REPLACE="${VDEV_FILES[1]} $SPARE_VDEV_FILE"
 
 log_onexit cleanup
 
 # ensure that enough events will be saved
 log_must set_tunable32 ZEVENT_LEN_MAX 512
 
 log_must truncate -s $VDEV_FILE_SIZE ${VDEV_FILES[@]} $SPARE_VDEV_FILE
 
 log_must zpool create -f -o feature@resilver_defer=disabled $TESTPOOL1 \
     raidz ${VDEV_FILES[@]}
 
 # create 4 filesystems
 for fs in fs{0..3}
 do
 	log_must zfs create -o primarycache=none -o recordsize=1k $TESTPOOL1/$fs
 done
 
 # simultaneously write 16M to each of them
 set -A DATAPATHS /$TESTPOOL1/fs{0..3}/dat.0
 log_note "Writing data files"
 for path in ${DATAPATHS[@]}
 do
 	dd if=/dev/urandom of=$path bs=1M count=16 > /dev/null 2>&1 &
 done
 wait
 
 # test without and with deferred resilve feature enabled
 for test in "without" "with" "with_early_restart"
 do
 	log_note "Testing $test deferred resilvers"
 
 	if [[ $test == "with" ]]
 	then
 		log_must zpool set feature@resilver_defer=enabled $TESTPOOL1
 		RESTARTS=( "${DEFER_RESTARTS[@]}" )
 		VDEVS=( "${DEFER_VDEVS[@]}" )
 		VDEV_REPLACE="$SPARE_VDEV_FILE ${VDEV_FILES[1]}"
 		log_must set_tunable32 RESILVER_DEFER_PERCENT 0
 	elif [[ $test == "with_early_restart" ]]
 	then
 		RESTARTS=( "${EARLY_RESTART_DEFER_RESTARTS[@]}" )
 		VDEVS=( "${EARLY_RESTART_DEFER_VDEVS[@]}" )
 		VDEV_REPLACE="${VDEV_FILES[1]} $SPARE_VDEV_FILE"
 		log_must set_tunable32 RESILVER_DEFER_PERCENT 100
 	fi
 
 	# clear the events
 	log_must zpool events -c
 
 	# limit scanning time
 	log_must set_tunable32 RESILVER_MIN_TIME_MS 50
 
 	# initiate a resilver and suspend the scan as soon as possible
 	log_must zpool replace $TESTPOOL1 $VDEV_REPLACE
 	log_must set_tunable32 SCAN_SUSPEND_PROGRESS 1
 
 	# there should only be 1 resilver start
 	verify_restarts '' "${RESTARTS[0]}" "${VDEVS[0]}"
 
 	# offline then online a vdev to introduce a new DTL range after current
 	# scan, which should restart (or defer) the resilver
 	log_must zpool offline $TESTPOOL1 ${VDEV_FILES[2]}
 	sync_pool $TESTPOOL1
 	log_must zpool online $TESTPOOL1 ${VDEV_FILES[2]}
 	sync_pool $TESTPOOL1
 
 	# there should now be 2 resilver starts w/o defer, 1 with defer
 	verify_restarts ' after offline/online' "${RESTARTS[1]}" "${VDEVS[1]}"
 
 	# inject read io errors on vdev and verify resilver does not restart
 	log_must zinject -a -d ${VDEV_FILES[2]} -e io -T read -f 0.25 $TESTPOOL1
 	log_must cp ${DATAPATHS[1]} /dev/null
 	log_must zinject -c all
 
 	# there should still be 2 resilver starts w/o defer, 1 with defer
 	verify_restarts ' after zinject' "${RESTARTS[2]}" "${VDEVS[2]}"
 
 	# unsuspend resilver
 	log_must set_tunable32 SCAN_SUSPEND_PROGRESS 0
 	log_must set_tunable32 RESILVER_MIN_TIME_MS 3000
 
 	# wait for resilver to finish
 	log_must zpool wait -t resilver $TESTPOOL1
 	log_must is_pool_resilvered $TESTPOOL1
 
 	# wait for a few txg's to see if a resilver happens
 	sync_pool $TESTPOOL1
 	sync_pool $TESTPOOL1
 
 	# there should now be 2 resilver starts
 	verify_restarts ' after resilver' "${RESTARTS[3]}" "${VDEVS[3]}"
 done
 
 log_pass "Resilver did not restart unnecessarily"
diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_misc/zvol_misc_snapdev.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/zvol/zvol_misc/zvol_misc_snapdev.ksh
index 1fc2d2780b1c..af780b628ce4 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,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 https://opensource.org/licenses/CDDL-1.0.
 # See the License for the specific language governing permissions
 # and limitations under the License.
 #
 # When distributing Covered Code, include this CDDL HEADER in each
 # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 # If applicable, add the following below this CDDL HEADER, with the
 # fields enclosed by brackets "[]" replaced with your own identifying
 # information: Portions Copyright [yyyy] [name of copyright owner]
 #
 # CDDL HEADER END
 #
 
 #
 # Copyright 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 && destroy_dataset $VOLFS -r
 	datasetexists $ZVOL && destroy_dataset $ZVOL -r
 	log_must zfs inherit snapdev $TESTPOOL
 	block_device_wait
 	is_linux && 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_must zfs destroy $SNAP
+
+# 4. Verify "rename" is correctly reflected when "snapdev=visible"
+# 4.1 First create a snapshot and verify the device is present
+log_must zfs snapshot $SNAP
+log_must zfs set snapdev=visible $ZVOL
+blockdev_exists $SNAPDEV
+# 4.2 rename the snapshot and verify the devices are updated
+log_must zfs rename $SNAP $SNAP-new
+blockdev_missing $SNAPDEV
+blockdev_exists $SNAPDEV-new
+# 4.3 cleanup
+log_must zfs destroy $SNAP-new
 
 log_pass "ZFS volume property 'snapdev' works as expected"
diff --git a/sys/contrib/openzfs/udev/vdev_id b/sys/contrib/openzfs/udev/vdev_id
index 7b5aab141997..5897fea3ed66 100755
--- a/sys/contrib/openzfs/udev/vdev_id
+++ b/sys/contrib/openzfs/udev/vdev_id
@@ -1,792 +1,804 @@
 #!/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=""
+ZPAD=1
 
 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}"
+	printf "%0${ZPAD}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 -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/^.*://')
 		;;
+	"bay_lun")
+		# Like 'bay' but with the LUN number appened. Added for SAS 
+		# multi-actuator HDDs, where one physical drive has multiple
+		# LUNs, thus multiple logical drives share the same bay number
+		i=$((i + 2))
+		d=$(eval echo '$'{$i})
+		LUN="-lun$(echo "$d" | sed -e 's/^.*://')"
+		SLOT=$(cat "$end_device_dir/bay_identifier" 2>/dev/null)
+		;;
 	"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}"
+		echo "${CHAN}"-"${JBOD}"-"${SLOT}${LUN}${PART}"
 	else
 		CHAN=$(map_channel "$PCI_ID" "$PORT")
 		SLOT=$(map_slot "$SLOT" "$CHAN")
 
 		if [ -z "$CHAN" ] ; then
 			return
 		fi
-		echo "${CHAN}${SLOT}${PART}"
+		echo "${CHAN}${SLOT}${LUN}${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="${DEVPATH%/*}"
 	ENC="${ENC%/*}"
 	ENC="${ENC##*/}"
 	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="$(readlink -m "/sys/$PORT_DIR/../..")"
 	PCI_ID_LONG="${PCI_ID_LONG##*/}"
 
 	# Strip down the PCI address from 0000:05:00.0 to 05:00.0
 	PCI_ID="${PCI_ID_LONG#[0-9]*:}"
 
 	# 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\$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 ${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
 
+ZPAD=$(awk '($1 == "zpad_slot") {print $2; exit}' "$CONFIG")
+
 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/modules/zfs/zfs_config.h b/sys/modules/zfs/zfs_config.h
index 5dc43281242f..91bb885be72f 100644
--- a/sys/modules/zfs/zfs_config.h
+++ b/sys/modules/zfs/zfs_config.h
@@ -1,840 +1,831 @@
 /*
  */
 
 /* 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 */
 
 /* __assign_str() has one arg */
 /* #undef HAVE_1ARG_ASSIGN_STR */
 
 /* lookup_bdev() wants 1 arg */
 /* #undef HAVE_1ARG_LOOKUP_BDEV */
 
 /* kernel has access_ok with 'type' parameter */
 /* #undef HAVE_ACCESS_OK_TYPE */
 
 /* add_disk() returns int */
 /* #undef HAVE_ADD_DISK_RET */
 
 /* Define if host toolchain supports AES */
 #define HAVE_AES 1
 
 /* Define if you have [rt] */
 #define HAVE_AIO_H 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
 
 /* backtrace() is available */
 /* #undef HAVE_BACKTRACE */
 
 /* bdevname() is available */
 /* #undef HAVE_BDEVNAME */
 
 /* bdev_check_media_change() exists */
 /* #undef HAVE_BDEV_CHECK_MEDIA_CHANGE */
 
 /* bdev_file_open_by_path() exists */
 /* #undef HAVE_BDEV_FILE_OPEN_BY_PATH */
 
 /* bdev_*_io_acct() available */
 /* #undef HAVE_BDEV_IO_ACCT_63 */
 
 /* bdev_*_io_acct() available */
 /* #undef HAVE_BDEV_IO_ACCT_OLD */
 
 /* bdev_kobj() exists */
 /* #undef HAVE_BDEV_KOBJ */
 
 /* bdev_max_discard_sectors() is available */
 /* #undef HAVE_BDEV_MAX_DISCARD_SECTORS */
 
 /* bdev_max_secure_erase_sectors() is available */
 /* #undef HAVE_BDEV_MAX_SECURE_ERASE_SECTORS */
 
 /* bdev_nr_bytes() is available */
 /* #undef HAVE_BDEV_NR_BYTES */
 
 /* bdev_open_by_path() exists */
 /* #undef HAVE_BDEV_OPEN_BY_PATH */
 
 /* bdev_release() exists */
 /* #undef HAVE_BDEV_RELEASE */
 
 /* block_device_operations->submit_bio() returns void */
 /* #undef HAVE_BDEV_SUBMIT_BIO_RETURNS_VOID */
 
 /* bdev_whole() is available */
 /* #undef HAVE_BDEV_WHOLE */
 
 /* bio_alloc() takes 4 arguments */
 /* #undef HAVE_BIO_ALLOC_4ARG */
 
 /* bio->bi_bdev->bd_disk exists */
 /* #undef HAVE_BIO_BDEV_DISK */
 
 /* bio_*_io_acct() available */
 /* #undef HAVE_BIO_IO_ACCT */
 
 /* bio_max_segs() is implemented */
 /* #undef HAVE_BIO_MAX_SEGS */
 
 /* 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() exists and takes 4 args */
 /* #undef HAVE_BLKDEV_GET_BY_PATH_4ARG */
 
 /* blkdev_get_by_path() handles ERESTARTSYS */
 /* #undef HAVE_BLKDEV_GET_ERESTARTSYS */
 
 /* __blkdev_issue_discard(flags) is available */
 /* #undef HAVE_BLKDEV_ISSUE_DISCARD_ASYNC_FLAGS */
 
 /* __blkdev_issue_discard() is available */
 /* #undef HAVE_BLKDEV_ISSUE_DISCARD_ASYNC_NOFLAGS */
 
 /* blkdev_issue_discard(flags) is available */
 /* #undef HAVE_BLKDEV_ISSUE_DISCARD_FLAGS */
 
 /* blkdev_issue_discard() is available */
 /* #undef HAVE_BLKDEV_ISSUE_DISCARD_NOFLAGS */
 
 /* blkdev_issue_secure_erase() is available */
 /* #undef HAVE_BLKDEV_ISSUE_SECURE_ERASE */
 
 /* blkdev_put() exists */
 /* #undef HAVE_BLKDEV_PUT */
 
 /* blkdev_put() accepts void* as arg 2 */
 /* #undef HAVE_BLKDEV_PUT_HOLDER */
 
 /* struct queue_limits has a features field */
 /* #undef HAVE_BLKDEV_QUEUE_LIMITS_FEATURES */
 
 /* 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_disk() exists and takes 2 args */
 /* #undef HAVE_BLK_ALLOC_DISK_2ARG */
 
 /* 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_cleanup_disk() exists */
 /* #undef HAVE_BLK_CLEANUP_DISK */
 
 /* blk_mode_t is defined */
 /* #undef HAVE_BLK_MODE_T */
 
 /* block multiqueue hardware context is cached in struct request */
 /* #undef HAVE_BLK_MQ_RQ_HCTX */
 
 /* blk queue backing_dev_info is dynamic */
 /* #undef HAVE_BLK_QUEUE_BDI_DYNAMIC */
 
 /* blk_queue_discard() is available */
 /* #undef HAVE_BLK_QUEUE_DISCARD */
 
 /* backing_dev_info is available through queue gendisk */
 /* #undef HAVE_BLK_QUEUE_DISK_BDI */
 
 /* blk_queue_secure_erase() is available */
 /* #undef HAVE_BLK_QUEUE_SECURE_ERASE */
 
 /* blk_queue_update_readahead() exists */
 /* #undef HAVE_BLK_QUEUE_UPDATE_READAHEAD */
 
 /* BLK_STS_RESV_CONFLICT is defined */
 /* #undef HAVE_BLK_STS_RESV_CONFLICT */
 
 /* Define if release() in block_device_operations takes 1 arg */
 /* #undef HAVE_BLOCK_DEVICE_OPERATIONS_RELEASE_1ARG */
 
 /* Define if revalidate_disk() in block_device_operations */
 /* #undef HAVE_BLOCK_DEVICE_OPERATIONS_REVALIDATE_DISK */
 
 /* check_disk_change() exists */
 /* #undef HAVE_CHECK_DISK_CHANGE */
 
 /* copy_splice_read exists */
 /* #undef HAVE_COPY_SPLICE_READ */
 
 /* cpu_has_feature() is GPL-only */
 /* #undef HAVE_CPU_HAS_FEATURE_GPL_ONLY */
 
 /* Define if the GNU dcgettext() function is already present or preinstalled.
    */
 /* #undef HAVE_DCGETTEXT */
 
 /* DECLARE_EVENT_CLASS() is available */
 /* #undef HAVE_DECLARE_EVENT_CLASS */
 
 /* dequeue_signal() takes a task argument */
 /* #undef HAVE_DEQUEUE_SIGNAL_3ARG_TASK */
 
 /* dequeue_signal() takes 4 arguments */
 /* #undef HAVE_DEQUEUE_SIGNAL_4ARG */
 
 /* lookup_bdev() wants dev_t arg */
 /* #undef HAVE_DEVT_LOOKUP_BDEV */
 
 /* disk_check_media_change() exists */
 /* #undef HAVE_DISK_CHECK_MEDIA_CHANGE */
 
 /* 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
 
 /* Define to 1 if you have the 'execvpe' function. */
 #define HAVE_EXECVPE 1
 
 /* fault_in_iov_iter_readable() is available */
 /* #undef HAVE_FAULT_IN_IOV_ITER_READABLE */
 
 /* file->f_version exists */
 /* #undef HAVE_FILE_F_VERSION */
 
 /* flush_dcache_page() is GPL-only */
 /* #undef HAVE_FLUSH_DCACHE_PAGE_GPL_ONLY */
 
 /* Define if compiler supports -Wformat-overflow */
 /* #undef HAVE_FORMAT_OVERFLOW */
 
 /* fsync_bdev() is declared in include/blkdev.h */
 /* #undef HAVE_FSYNC_BDEV */
 
 /* yes */
 /* #undef HAVE_GENERIC_FADVISE */
 
 /* generic_fillattr requires struct mnt_idmap* */
 /* #undef HAVE_GENERIC_FILLATTR_IDMAP */
 
 /* generic_fillattr requires struct mnt_idmap* and u32 request_mask */
 /* #undef HAVE_GENERIC_FILLATTR_IDMAP_REQMASK */
 
 /* generic_fillattr requires struct user_namespace* */
 /* #undef HAVE_GENERIC_FILLATTR_USERNS */
 
 /* generic_*_io_acct() 4 arg available */
 /* #undef HAVE_GENERIC_IO_ACCT_4ARG */
 
 /* GENHD_FL_EXT_DEVT flag is available */
 /* #undef HAVE_GENHD_FL_EXT_DEVT */
 
 /* GENHD_FL_NO_PART flag is available */
 /* #undef HAVE_GENHD_FL_NO_PART */
 
 /* Define if the GNU gettext() function is already present or preinstalled. */
 /* #undef HAVE_GETTEXT */
 
 /* Define to 1 if you have the 'gettid' function. */
 /* #undef HAVE_GETTID */
 
 /* iops->get_acl() exists */
 /* #undef HAVE_GET_ACL */
 
 /* iops->get_acl() takes rcu */
 /* #undef HAVE_GET_ACL_RCU */
 
 /* has iops->get_inode_acl() */
 /* #undef HAVE_GET_INODE_ACL */
 
 /* iattr->ia_vfsuid and iattr->ia_vfsgid exist */
 /* #undef HAVE_IATTR_VFSID */
 
 /* Define if you have the iconv() function and it works. */
 #define HAVE_ICONV 1
 
 /* iops->getattr() takes struct mnt_idmap* */
 /* #undef HAVE_IDMAP_IOPS_GETATTR */
 
 /* iops->setattr() takes struct mnt_idmap* */
 /* #undef HAVE_IDMAP_IOPS_SETATTR */
 
 /* APIs for idmapped mount are present */
 /* #undef HAVE_IDMAP_MNT_API */
 
 /* mnt_idmap does not have user_namespace */
 /* #undef HAVE_IDMAP_NO_USERNS */
 
 /* Define if compiler supports -Wimplicit-fallthrough */
 /* #undef HAVE_IMPLICIT_FALLTHROUGH */
 
 /* Define if compiler supports -Winfinite-recursion */
 /* #undef HAVE_INFINITE_RECURSION */
 
 /* inode_get_atime() exists in linux/fs.h */
 /* #undef HAVE_INODE_GET_ATIME */
 
 /* inode_get_ctime() exists in linux/fs.h */
 /* #undef HAVE_INODE_GET_CTIME */
 
 /* inode_get_mtime() exists in linux/fs.h */
 /* #undef HAVE_INODE_GET_MTIME */
 
 /* inode_owner_or_capable() exists */
 /* #undef HAVE_INODE_OWNER_OR_CAPABLE */
 
 /* inode_owner_or_capable() takes mnt_idmap */
 /* #undef HAVE_INODE_OWNER_OR_CAPABLE_IDMAP */
 
 /* inode_owner_or_capable() takes user_ns */
 /* #undef HAVE_INODE_OWNER_OR_CAPABLE_USERNS */
 
 /* inode_set_atime_to_ts() exists in linux/fs.h */
 /* #undef HAVE_INODE_SET_ATIME_TO_TS */
 
 /* inode_set_ctime_to_ts() exists in linux/fs.h */
 /* #undef HAVE_INODE_SET_CTIME_TO_TS */
 
 /* inode_set_mtime_to_ts() exists in linux/fs.h */
 /* #undef HAVE_INODE_SET_MTIME_TO_TS */
 
 /* timestamp_truncate() exists */
 /* #undef HAVE_INODE_TIMESTAMP_TRUNCATE */
 
 /* Define to 1 if you have the <inttypes.h> header file. */
 #define HAVE_INTTYPES_H 1
 
 /* iops->create() takes struct mnt_idmap* */
 /* #undef HAVE_IOPS_CREATE_IDMAP */
 
 /* iops->create() takes struct user_namespace* */
 /* #undef HAVE_IOPS_CREATE_USERNS */
 
 /* iops->mkdir() takes struct mnt_idmap* */
 /* #undef HAVE_IOPS_MKDIR_IDMAP */
 
 /* iops->mkdir() takes struct user_namespace* */
 /* #undef HAVE_IOPS_MKDIR_USERNS */
 
 /* iops->mknod() takes struct mnt_idmap* */
 /* #undef HAVE_IOPS_MKNOD_IDMAP */
 
 /* iops->mknod() takes struct user_namespace* */
 /* #undef HAVE_IOPS_MKNOD_USERNS */
 
 /* iops->permission() takes struct mnt_idmap* */
 /* #undef HAVE_IOPS_PERMISSION_IDMAP */
 
 /* iops->permission() takes struct user_namespace* */
 /* #undef HAVE_IOPS_PERMISSION_USERNS */
 
 /* iops->rename() takes struct mnt_idmap* */
 /* #undef HAVE_IOPS_RENAME_IDMAP */
 
 /* iops->rename() takes struct user_namespace* */
 /* #undef HAVE_IOPS_RENAME_USERNS */
 
 /* iops->symlink() takes struct mnt_idmap* */
 /* #undef HAVE_IOPS_SYMLINK_IDMAP */
 
 /* iops->symlink() takes struct user_namespace* */
 /* #undef HAVE_IOPS_SYMLINK_USERNS */
 
 /* iov_iter_get_pages() is available */
 /* #undef HAVE_IOV_ITER_GET_PAGES */
 
 /* iov_iter_get_pages2() is available */
 /* #undef HAVE_IOV_ITER_GET_PAGES2 */
 
 /* iov_iter_type() is available */
 /* #undef HAVE_IOV_ITER_TYPE */
 
 /* Define to 1 if you have the 'issetugid' function. */
 #define HAVE_ISSETUGID 1
 
 /* iter_iov() is available */
 /* #undef HAVE_ITER_IOV */
 
 /* 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/internal.h */
 /* #undef HAVE_KERNEL_FPU_INTERNAL_HEADER */
 
 /* Define if compiler supports -Winfinite-recursion */
 /* #undef HAVE_KERNEL_INFINITE_RECURSION */
 
 /* kernel defines intptr_t */
 /* #undef HAVE_KERNEL_INTPTR_T */
 
 /* kernel has kernel_neon_* functions */
 /* #undef HAVE_KERNEL_NEON */
 
 /* kernel does stack verification */
 /* #undef HAVE_KERNEL_OBJTOOL */
 
 /* kernel has linux/objtool.h */
 /* #undef HAVE_KERNEL_OBJTOOL_HEADER */
 
 /* strlcpy() exists */
 /* #undef HAVE_KERNEL_STRLCPY */
 
 /* kernel has kmap_local_page */
 /* #undef HAVE_KMAP_LOCAL_PAGE */
 
 /* 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 [unwind] */
 /* #undef HAVE_LIBUNWIND */
 
 /* libunwind has unw_get_elf_filename */
 /* #undef HAVE_LIBUNWIND_ELF */
 
 /* Define if you have [uuid] */
 /* #undef HAVE_LIBUUID */
 
 /* building against unsupported kernel version */
 /* #undef HAVE_LINUX_EXPERIMENTAL */
 
 /* 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 */
 
 /* Define to 1 if you have the 'mlockall' function. */
 #define HAVE_MLOCKALL 1
 
 /* PG_error flag is available */
 /* #undef HAVE_MM_PAGE_FLAG_ERROR */
 
 /* page_mapping() is available */
 /* #undef HAVE_MM_PAGE_MAPPING */
 
 /* page_size() is available */
 /* #undef HAVE_MM_PAGE_SIZE */
 
 /* Define if host toolchain supports MOVBE */
 #define HAVE_MOVBE 1
 
 /* folio_wait_bit() exists */
 /* #undef HAVE_PAGEMAP_FOLIO_WAIT_BIT */
 
 /* part_to_dev() exists */
 /* #undef HAVE_PART_TO_DEV */
 
 /* iops->getattr() takes a path */
 /* #undef HAVE_PATH_IOPS_GETATTR */
 
 /* Define if host toolchain supports PCLMULQDQ */
 #define HAVE_PCLMULQDQ 1
 
 /* proc_handler ctl_table arg is const */
 /* #undef HAVE_PROC_HANDLER_CTL_TABLE_CONST */
 
 /* proc_ops structure exists */
 /* #undef HAVE_PROC_OPS_STRUCT */
 
 /* If available, contains the Python version number currently in use. */
 #define HAVE_PYTHON "3.7"
 
 /* qat is enabled and existed */
 /* #undef HAVE_QAT */
 
 /* struct reclaim_state has reclaimed */
 /* #undef HAVE_RECLAIM_STATE_RECLAIMED */
 
 /* register_shrinker is vararg */
 /* #undef HAVE_REGISTER_SHRINKER_VARARG */
 
 /* register_sysctl_sz exists */
 /* #undef HAVE_REGISTER_SYSCTL_SZ */
 
 /* register_sysctl_table exists */
 /* #undef HAVE_REGISTER_SYSCTL_TABLE */
 
 /* iops->rename() wants flags */
 /* #undef HAVE_RENAME_WANTS_FLAGS */
 
 /* revalidate_disk() is available */
 /* #undef HAVE_REVALIDATE_DISK */
 
 /* revalidate_disk_size() is available */
 /* #undef HAVE_REVALIDATE_DISK_SIZE */
 
 /* Define to 1 if you have the <security/pam_modules.h> header file. */
 #define HAVE_SECURITY_PAM_MODULES_H 1
 
 /* setattr_prepare() accepts mnt_idmap */
 /* #undef HAVE_SETATTR_PREPARE_IDMAP */
 
 /* 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() takes 4 args, arg1 is struct mnt_idmap * */
 /* #undef HAVE_SET_ACL_IDMAP_DENTRY */
 
 /* iops->set_acl() takes 4 args */
 /* #undef HAVE_SET_ACL_USERNS */
 
 /* iops->set_acl() takes 4 args, arg2 is struct dentry * */
 /* #undef HAVE_SET_ACL_USERNS_DENTRY_ARG2 */
 
 /* shrinker_register exists */
 /* #undef HAVE_SHRINKER_REGISTER */
 
 /* kernel_siginfo_t exists */
 /* #undef HAVE_SIGINFO */
 
 #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 <stdio.h> header file. */
 #define HAVE_STDIO_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 */
 
 /* have super_block s_shrink */
 /* #undef HAVE_SUPER_BLOCK_S_SHRINK */
 
 /* have super_block s_shrink pointer */
 /* #undef HAVE_SUPER_BLOCK_S_SHRINK_PTR */
 
 /* sync_blockdev() is declared in include/blkdev.h */
 /* #undef HAVE_SYNC_BLOCKDEV */
 
 /* struct kobj_type has default_groups */
 /* #undef HAVE_SYSFS_DEFAULT_GROUPS */
 
 /* 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() uses old dentry signature */
 /* #undef HAVE_TMPFILE_DENTRY */
 
 /* i_op->tmpfile() has mnt_idmap */
 /* #undef HAVE_TMPFILE_IDMAP */
 
 /* 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->setattr() takes struct user_namespace* */
 /* #undef HAVE_USERNS_IOPS_SETATTR */
 
 /* fops->clone_file_range() is available */
 /* #undef HAVE_VFS_CLONE_FILE_RANGE */
 
 /* fops->dedupe_file_range() is available */
 /* #undef HAVE_VFS_DEDUPE_FILE_RANGE */
 
 /* 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 */
 
 /* filemap_dirty_folio exists */
 /* #undef HAVE_VFS_FILEMAP_DIRTY_FOLIO */
 
 /* generic_copy_file_range() is available */
 /* #undef HAVE_VFS_GENERIC_COPY_FILE_RANGE */
 
 /* invalidate_folio exists */
 /* #undef HAVE_VFS_INVALIDATE_FOLIO */
 
 /* 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 */
-
 /* address_space_operations->readpages exists */
 /* #undef HAVE_VFS_READPAGES */
 
 /* read_folio exists */
 /* #undef HAVE_VFS_READ_FOLIO */
 
 /* release_folio exists */
 /* #undef HAVE_VFS_RELEASE_FOLIO */
 
 /* fops->remap_file_range() is available */
 /* #undef HAVE_VFS_REMAP_FILE_RANGE */
 
 /* __set_page_dirty_nobuffers exists */
 /* #undef HAVE_VFS_SET_PAGE_DIRTY_NOBUFFERS */
 
 /* splice_copy_file_range() is available */
 /* #undef HAVE_VFS_SPLICE_COPY_FILE_RANGE */
 
 /* __vmalloc page flags exists */
 /* #undef HAVE_VMALLOC_PAGE_KERNEL */
 
 /* int (*writepage_t)() takes struct folio* */
 /* #undef HAVE_WRITEPAGE_T_FOLIO */
 
 /* xattr_handler->get() wants dentry and inode and flags */
 /* #undef HAVE_XATTR_GET_DENTRY_INODE_FLAGS */
 
 /* xattr_handler->set() wants both dentry and inode */
 /* #undef HAVE_XATTR_SET_DENTRY_INODE */
 
 /* xattr_handler->set() takes mnt_idmap */
 /* #undef HAVE_XATTR_SET_IDMAP */
 
 /* xattr_handler->set() takes user_namespace */
 /* #undef HAVE_XATTR_SET_USERNS */
 
 /* Define if host toolchain supports XSAVE */
 #define HAVE_XSAVE 1
 
 /* Define if host toolchain supports XSAVEOPT */
 #define HAVE_XSAVEOPT 1
 
 /* Define if host toolchain supports XSAVES */
 #define HAVE_XSAVES 1
 
 /* ZERO_PAGE() is GPL-only */
 /* #undef HAVE_ZERO_PAGE_GPL_ONLY */
 
 /* Define if you have [z] */
 #define HAVE_ZLIB 1
 
 /* kernel exports FPU functions */
 /* #undef KERNEL_EXPORTS_X86_FPU */
 
 /* TBD: fetch(3) support */
 #if 0
 /* whether the chosen libfetch is to be loaded at run-time */
 #define LIBFETCH_DYNAMIC 1
 
 /* libfetch is fetch(3) */
 #define LIBFETCH_IS_FETCH 1
 
 /* libfetch is libcurl */
 #define LIBFETCH_IS_LIBCURL 0
 
 /* soname of chosen libfetch */
 #define LIBFETCH_SONAME "libfetch.so.6"
 #endif
 
 /* Define to the sub-directory where libtool stores uninstalled libraries. */
 #define LT_OBJDIR ".libs/"
 
 /* make_request_fn() return type */
 /* #undef MAKE_REQUEST_FN_RET */
 
 /* using complete_and_exit() instead */
 /* #undef SPL_KTHREAD_COMPLETE_AND_EXIT */
 
 /* 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
 
 /* pde_data() is PDE_DATA() */
 /* #undef SPL_PDE_DATA */
 
 /* Define to 1 if all of the C89 standard headers exist (not just the ones
    required in a freestanding environment). This macro is provided for
    backward compatibility; new code need not use it. */
 #define SYSTEM_FREEBSD 1
 
 /* True if ZFS is to be compiled for a Linux system */
 /* #undef SYSTEM_LINUX */
 
 /* Version number of package */
 /* #undef ZFS_DEBUG */
 
 /* /dev/zfs minor */
 /* #undef ZFS_DEVICE_MINOR */
 
 /* Define the project alias string. */
-#define ZFS_META_ALIAS "zfs-2.3.0-rc1-FreeBSD_g3a9fca901"
+#define ZFS_META_ALIAS "zfs-2.3.99-31-FreeBSD_gb2f6de7b5"
 
 /* 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 "6.11"
 
 /* Define the minimum compatible kernel version. */
 #define ZFS_META_KVER_MIN "4.18"
 
 /* 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 "rc1-FreeBSD_g3a9fca901"
+#define ZFS_META_RELEASE "31-FreeBSD_gb2f6de7b5"
 
 /* Define the project version. */
-#define ZFS_META_VERSION "2.3.0"
+#define ZFS_META_VERSION "2.3.99"
 
 /* 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 3a1480d8dc66..e090ccb924f2 100644
--- a/sys/modules/zfs/zfs_gitrev.h
+++ b/sys/modules/zfs/zfs_gitrev.h
@@ -1 +1 @@
-#define	ZFS_META_GITREV "zfs-2.3.0-rc1-0-g3a9fca901"
+#define	ZFS_META_GITREV "zfs-2.3.99-31-gb2f6de7b5"