Tag 2.0.0

Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
Verify zfs module loaded before starting services
2026-05-23 19:04:45 +03:00 · 2020-11-30 10:13:14 -08:00 · 2020-11-30 09:44:08 -08:00 · 2020-11-30 09:44:02 -08:00 · 2020-11-30 09:43:09 -08:00 · 2020-11-25 09:18:29 -08:00
1354 changed files with 46014 additions and 72185 deletions
@@ -25,16 +25,14 @@ Type | Version/Name
 --- | ---
 Distribution Name	|
 Distribution Version	|
-Kernel Version	|
+Linux Kernel	|
 Architecture	|
-OpenZFS Version	|
+ZFS Version	|
+SPL Version	|
 <!--
-Command to find OpenZFS version:
-zfs version
-
-Commands to find kernel version:
-uname -r		# Linux
-freebsd-version -r	# FreeBSD
+Commands to find ZFS/SPL versions:
+modinfo zfs | grep -iw version
+modinfo spl | grep -iw version
 -->

 ### Describe the problem you're observing
@@ -1,8 +1,5 @@
 blank_issues_enabled: false
 contact_links:
-  - name: OpenZFS Questions
-    url: https://github.com/openzfs/zfs/discussions/new
-    about: Ask the community for help
  - name: OpenZFS Community Support Mailing list (Linux)
    url: https://zfsonlinux.topicbox.com/groups/zfs-discuss
    about: Get community support for OpenZFS on Linux
@@ -10,5 +7,5 @@ contact_links:
    url: https://lists.freebsd.org/mailman/listinfo/freebsd-fs
    about: Get community support for OpenZFS on FreeBSD
  - name: OpenZFS on IRC
-    url: https://web.libera.chat/#openzfs
+    url: https://webchat.freenode.net/#openzfs
    about: Use IRC to get community support for OpenZFS
@@ -0,0 +1,37 @@
+---
+name: Code Question
+about: Ask a question about the code
+title: ''
+labels: 'Type: Question'
+assignees: ''
+
+---
+
+<!--
+Thank you for taking an interest in the OpenZFS codebase.
+
+Please be aware that most questions are preferably asked in the mailing list first.
+This form is primarily meant for asking questions about the code itself.
+
+Please also check our issue tracker before opening a new question.
+Filling out the following template will help other contributors better understand your question.
+-->
+
+### Ask your question!
+
+<!--
+Please provide a clear and concise question.
+-->
+
+### Which portion of the codebase does your question involve?
+
+<!--
+Optional: Please describe what portion of the codebase your issue involved.
+Example: "Testsuite", "Buildbots", "CLI", a code snippet etc.
+-->
+
+### Additional context
+
+<!--
+Any additional information you want to add?
+-->
@@ -28,15 +28,14 @@ https://openzfs.github.io/openzfs-docs/Developer%20Resources/Buildbot%20Options.
 - [ ] Performance enhancement (non-breaking change which improves efficiency)
 - [ ] Code cleanup (non-breaking change which makes code smaller or more readable)
 - [ ] Breaking change (fix or feature that would cause existing functionality to change)
- [ ] Library ABI change (libzfs, libzfs\_core, libnvpair, libuutil and libzfsbootenv)
 - [ ] Documentation (a change to man pages or other documentation)

 ### Checklist:
 <!--- Go over all the following points, and put an `x` in all the boxes that apply. -->
 <!--- If you're unsure about any of these, don't hesitate to ask. We're here to help! -->
- [ ] My code follows the OpenZFS [code style requirements](https://github.com/openzfs/zfs/blob/master/.github/CONTRIBUTING.md#coding-conventions).
+- [ ] My code follows the ZFS on Linux [code style requirements](https://github.com/zfsonlinux/zfs/blob/master/.github/CONTRIBUTING.md#coding-conventions).
 - [ ] I have updated the documentation accordingly.
- [ ] I have read the [**contributing** document](https://github.com/openzfs/zfs/blob/master/.github/CONTRIBUTING.md).
- [ ] I have added [tests](https://github.com/openzfs/zfs/tree/master/tests) to cover my changes.
+- [ ] I have read the [**contributing** document](https://github.com/zfsonlinux/zfs/blob/master/.github/CONTRIBUTING.md).
+- [ ] I have added [tests](https://github.com/zfsonlinux/zfs/tree/master/tests) to cover my changes.
 - [ ] I have run the ZFS Test Suite with this change applied.
- [ ] All commit messages are properly formatted and contain [`Signed-off-by`](https://github.com/openzfs/zfs/blob/master/.github/CONTRIBUTING.md#signed-off-by).
+- [ ] All commit messages are properly formatted and contain [`Signed-off-by`](https://github.com/zfsonlinux/zfs/blob/master/.github/CONTRIBUTING.md#signed-off-by).
@@ -1,13 +0,0 @@
-# Configuration for probot-no-response - https://github.com/probot/no-response
-
-# Number of days of inactivity before an Issue is closed for lack of response
-daysUntilClose: 31
-# Label requiring a response
-responseRequiredLabel: "Status: Feedback requested"
-# Comment to post when closing an Issue for lack of response. Set to `false` to disable
-closeComment: >
-  This issue has been automatically closed because there has been no response
-  to our request for more information from the original author. With only the
-  information that is currently in the issue, we don't have enough information
-  to take action. Please reach out if you have or find the answers we need so
-  that we can investigate further.
@@ -7,14 +7,7 @@ only: issues
 # Issues with these labels will never be considered stale
 exemptLabels:
  - "Type: Feature"
-  - "Bot: Not Stale"
-  - "Status: Work in Progress"
-# Set to true to ignore issues in a project (defaults to false)
-exemptProjects: true
-# Set to true to ignore issues in a milestone (defaults to false)
-exemptMilestones: true
-# Set to true to ignore issues with an assignee (defaults to false)
-exemptAssignees: true
+  - "Type: Understood"
 # Label to use when marking an issue as stale
 staleLabel: "Status: Stale"
 # Comment to post when marking an issue as stale. Set to `false` to disable
@@ -22,5 +15,3 @@ markComment: >
  This issue has been automatically marked as "stale" because it has not had
  any activity for a while. It will be closed in 90 days if no further activity occurs. 
  Thank you for your contributions.
-# Limit the number of actions per hour, from 1-30. Default is 30
-limitPerRun: 6
@@ -2,11 +2,11 @@ name: checkstyle

 on:
  push:
-  pull_request:
+  pull_request_target:

 jobs:
  checkstyle:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
      with:
@@ -18,13 +18,12 @@ jobs:
        sudo apt-get install --yes -qq zlib1g-dev uuid-dev libattr1-dev libblkid-dev libselinux-dev libudev-dev libssl-dev python-dev python-setuptools python-cffi python3 python3-dev python3-setuptools python3-cffi
        # packages for tests
        sudo apt-get install --yes -qq parted lsscsi ksh attr acl nfs-kernel-server fio
-        sudo apt-get install --yes -qq mandoc cppcheck pax-utils devscripts
+        sudo apt-get install --yes -qq mandoc cppcheck pax-utils abigail-tools # devscripts - enable then bashisms fixed
        sudo -E pip --quiet install flake8
    - name: Prepare
      run: |
        sh ./autogen.sh
        ./configure
-        make -j$(nproc)
    - name: Checkstyle
      run: |
        make checkstyle
@@ -32,19 +31,6 @@ jobs:
      run: |
        make lint
    - name: CheckABI
-      id: CheckABI
      run: |
-        sudo docker run -v $(pwd):/source ghcr.io/openzfs/libabigail make checkabi
-    - name: StoreABI
-      if: failure() && steps.CheckABI.outcome == 'failure'
-      run: |
-        sudo docker run -v $(pwd):/source ghcr.io/openzfs/libabigail make storeabi
-    - name: Prepare artifacts
-      if: failure() && steps.CheckABI.outcome == 'failure'
-      run: |
-        find -name *.abi | tar -cf abi_files.tar -T -
-    - uses: actions/upload-artifact@v2
-      if: failure() && steps.CheckABI.outcome == 'failure'
-      with:
-        name: New ABI files (use only if you're sure about interface changes)
-        path: abi_files.tar
+        make -j$(nproc)
+        make checkabi
@@ -1,83 +0,0 @@
-name: zfs-tests-functional
-
-on:
-  push:
-  pull_request:
-
-jobs:
-  tests-functional-ubuntu:
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [18.04, 20.04]
-    runs-on: ubuntu-${{ matrix.os }}
-    steps:
-    - uses: actions/checkout@v2
-      with:
-        ref: ${{ github.event.pull_request.head.sha }}
-    - name: Install dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get install --yes -qq build-essential autoconf libtool gdb lcov \
-          git alien fakeroot wget curl bc fio acl \
-          sysstat mdadm lsscsi parted gdebi attr dbench watchdog ksh \
-          nfs-kernel-server samba rng-tools xz-utils \
-          zlib1g-dev uuid-dev libblkid-dev libselinux-dev \
-          xfslibs-dev libattr1-dev libacl1-dev libudev-dev libdevmapper-dev \
-          libssl-dev libffi-dev libaio-dev libelf-dev libmount-dev \
-          libpam0g-dev pamtester python-dev python-setuptools python-cffi \
-          python3 python3-dev python3-setuptools python3-cffi python3-packaging \
-          libcurl4-openssl-dev
-    - name: Autogen.sh
-      run: |
-        sh autogen.sh
-    - name: Configure
-      run: |
-        ./configure --enable-debug --enable-debuginfo
-    - name: Make
-      run: |
-        make --no-print-directory -s pkg-utils pkg-kmod
-    - name: Install
-      run: |
-        sudo dpkg -i *.deb
-        # Update order of directories to search for modules, otherwise
-        #   Ubuntu will load kernel-shipped ones.
-        sudo sed -i.bak 's/updates/extra updates/' /etc/depmod.d/ubuntu.conf
-        sudo depmod
-        sudo modprobe zfs
-        # Workaround for cloud-init bug
-        # see https://github.com/openzfs/zfs/issues/12644
-        FILE=/lib/udev/rules.d/10-cloud-init-hook-hotplug.rules
-        if [ -r "${FILE}" ]; then
-          HASH=$(md5sum "${FILE}" | awk '{ print $1 }')
-          if [ "${HASH}" = "121ff0ef1936cd2ef65aec0458a35772" ]; then
-            # Just shove a zd* exclusion right above the hotplug hook...
-            sudo sed -i -e s/'LABEL="cloudinit_hook"'/'KERNEL=="zd*", GOTO="cloudinit_end"\n&'/ "${FILE}"
-            sudo udevadm control --reload-rules
-          fi
-        fi
-        # Workaround to provide additional free space for testing.
-        #   https://github.com/actions/virtual-environments/issues/2840
-        sudo rm -rf /usr/share/dotnet
-        sudo rm -rf /opt/ghc
-        sudo rm -rf "/usr/local/share/boost"
-        sudo rm -rf "$AGENT_TOOLSDIRECTORY"
-    - name: Tests
-      run: |
-        /usr/share/zfs/zfs-tests.sh -vR -s 3G
-      timeout-minutes: 330
-    - name: Prepare artifacts
-      if: failure()
-      run: |
-        RESULTS_PATH=$(readlink -f /var/tmp/test_results/current)
-        sudo dmesg > $RESULTS_PATH/dmesg
-        sudo cp /var/log/syslog $RESULTS_PATH/
-        sudo chmod +r $RESULTS_PATH/*
-        # Replace ':' in dir names, actions/upload-artifact doesn't support it
-        for f in $(find /var/tmp/test_results -name '*:*'); do mv "$f" "${f//:/__}"; done
-    - uses: actions/upload-artifact@v2
-      if: failure()
-      with:
-        name: Test logs Ubuntu-${{ matrix.os }}
-        path: /var/tmp/test_results/20*/
-        if-no-files-found: ignore
@@ -1,79 +0,0 @@
-name: zfs-tests-sanity
-
-on:
-  push:
-  pull_request:
-
-jobs:
-  tests:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-      with:
-        ref: ${{ github.event.pull_request.head.sha }}
-    - name: Install dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get install --yes -qq build-essential autoconf libtool gdb lcov \
-          git alien fakeroot wget curl bc fio acl \
-          sysstat mdadm lsscsi parted gdebi attr dbench watchdog ksh \
-          nfs-kernel-server samba rng-tools xz-utils \
-          zlib1g-dev uuid-dev libblkid-dev libselinux-dev \
-          xfslibs-dev libattr1-dev libacl1-dev libudev-dev libdevmapper-dev \
-          libssl-dev libffi-dev libaio-dev libelf-dev libmount-dev \
-          libpam0g-dev pamtester python-dev python-setuptools python-cffi \
-          python3 python3-dev python3-setuptools python3-cffi python3-packaging \
-          libcurl4-openssl-dev
-    - name: Autogen.sh
-      run: |
-        sh autogen.sh
-    - name: Configure
-      run: |
-        ./configure --enable-debug --enable-debuginfo
-    - name: Make
-      run: |
-        make --no-print-directory -s pkg-utils pkg-kmod
-    - name: Install
-      run: |
-        sudo dpkg -i *.deb
-        # Update order of directories to search for modules, otherwise
-        #   Ubuntu will load kernel-shipped ones.
-        sudo sed -i.bak 's/updates/extra updates/' /etc/depmod.d/ubuntu.conf
-        sudo depmod
-        sudo modprobe zfs
-        # Workaround for cloud-init bug
-        # see https://github.com/openzfs/zfs/issues/12644
-        FILE=/lib/udev/rules.d/10-cloud-init-hook-hotplug.rules
-        if [ -r "${FILE}" ]; then
-          HASH=$(md5sum "${FILE}" | awk '{ print $1 }')
-          if [ "${HASH}" = "121ff0ef1936cd2ef65aec0458a35772" ]; then
-            # Just shove a zd* exclusion right above the hotplug hook...
-            sudo sed -i -e s/'LABEL="cloudinit_hook"'/'KERNEL=="zd*", GOTO="cloudinit_end"\n&'/ "${FILE}"
-            sudo udevadm control --reload-rules
-          fi
-        fi
-        # Workaround to provide additional free space for testing.
-        #   https://github.com/actions/virtual-environments/issues/2840
-        sudo rm -rf /usr/share/dotnet
-        sudo rm -rf /opt/ghc
-        sudo rm -rf "/usr/local/share/boost"
-        sudo rm -rf "$AGENT_TOOLSDIRECTORY"
-    - name: Tests
-      run: |
-        /usr/share/zfs/zfs-tests.sh -vR -s 3G -r sanity
-      timeout-minutes: 330
-    - name: Prepare artifacts
-      if: failure()
-      run: |
-        RESULTS_PATH=$(readlink -f /var/tmp/test_results/current)
-        sudo dmesg > $RESULTS_PATH/dmesg
-        sudo cp /var/log/syslog $RESULTS_PATH/
-        sudo chmod +r $RESULTS_PATH/*
-        # Replace ':' in dir names, actions/upload-artifact doesn't support it
-        for f in $(find /var/tmp/test_results -name '*:*'); do mv "$f" "${f//:/__}"; done
-    - uses: actions/upload-artifact@v2
-      if: failure()
-      with:
-        name: Test logs
-        path: /var/tmp/test_results/20*/
-        if-no-files-found: ignore
@@ -1,67 +0,0 @@
-name: zloop
-
-on:
-  push:
-  pull_request:
-
-jobs:
-  tests:
-    runs-on: ubuntu-latest
-    env:
-      TEST_DIR: /var/tmp/zloop
-    steps:
-    - uses: actions/checkout@v2
-      with:
-        ref: ${{ github.event.pull_request.head.sha }}
-    - name: Install dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get install --yes -qq build-essential autoconf libtool gdb \
-          git alien fakeroot \
-          zlib1g-dev uuid-dev libblkid-dev libselinux-dev \
-          xfslibs-dev libattr1-dev libacl1-dev libudev-dev libdevmapper-dev \
-          libssl-dev libffi-dev libaio-dev libelf-dev libmount-dev \
-          libpam0g-dev \
-          python-dev python-setuptools python-cffi python-packaging \
-          python3 python3-dev python3-setuptools python3-cffi python3-packaging
-    - name: Autogen.sh
-      run: |
-        sh autogen.sh
-    - name: Configure
-      run: |
-        ./configure --enable-debug --enable-debuginfo
-    - name: Make
-      run: |
-        make --no-print-directory -s pkg-utils pkg-kmod
-    - name: Install
-      run: |
-        sudo dpkg -i *.deb
-        # Update order of directories to search for modules, otherwise
-        #   Ubuntu will load kernel-shipped ones.
-        sudo sed -i.bak 's/updates/extra updates/' /etc/depmod.d/ubuntu.conf
-        sudo depmod
-        sudo modprobe zfs
-    - name: Tests
-      run: |
-        sudo mkdir -p $TEST_DIR
-        # run for 20 minutes to have a total runner time of 30 minutes
-        sudo /usr/share/zfs/zloop.sh -t 1200 -l -m1 -- -T 120 -P 60
-    - name: Prepare artifacts
-      if: failure()
-      run: |
-        sudo chmod +r -R $TEST_DIR/
-    - uses: actions/upload-artifact@v2
-      if: failure()
-      with:
-        name: Logs
-        path: |
-          /var/tmp/zloop/*/
-          !/var/tmp/zloop/*/vdev/
-        if-no-files-found: ignore
-    - uses: actions/upload-artifact@v2
-      if: failure()
-      with:
-        name: Pool files
-        path: |
-          /var/tmp/zloop/*/vdev/
-        if-no-files-found: ignore
@@ -1,3 +1,3 @@
 [submodule "scripts/zfs-images"]
 	path = scripts/zfs-images
-	url = https://github.com/openzfs/zfs-images
+	url = https://github.com/zfsonlinux/zfs-images
@@ -1,10 +1,10 @@
 Meta:          1
 Name:          zfs
 Branch:        1.0
-Version:       2.1.6
+Version:       2.0.0
 Release:       1
 Release-Tags:  relext
 License:       CDDL
 Author:        OpenZFS
-Linux-Maximum: 5.19
+Linux-Maximum: 5.9
 Linux-Minimum: 3.10
@@ -1,5 +1,3 @@
-include $(top_srcdir)/config/Shellcheck.am
-
 ACLOCAL_AMFLAGS = -I config

 SUBDIRS = include
@@ -8,7 +6,7 @@ SUBDIRS += rpm
 endif

 if CONFIG_USER
-SUBDIRS += man scripts lib tests cmd etc contrib
+SUBDIRS += etc man scripts lib tests cmd contrib
 if BUILD_LINUX
 SUBDIRS += udev
 endif
@@ -27,9 +25,10 @@ endif

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

 # Include all the extra licensing information for modules
@@ -103,7 +102,7 @@ endif
 endif

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

 PHONY += checkstyle
 checkstyle: codecheck commitcheck
@@ -114,47 +113,70 @@ commitcheck:
 		${top_srcdir}/scripts/commitcheck.sh; \
 	fi

-if HAVE_PARALLEL
-cstyle_line = -print0 | parallel -X0 ${top_srcdir}/scripts/cstyle.pl -cpP {}
-else
-cstyle_line = -exec ${top_srcdir}/scripts/cstyle.pl -cpP {} +
-endif
 PHONY += cstyle
 cstyle:
 	@find ${top_srcdir} -name build -prune \
 		-o -type f -name '*.[hc]' \
 		! -name 'zfs_config.*' ! -name '*.mod.c' \
 		! -name 'opt_global.h' ! -name '*_if*.h' \
-		! -name 'zstd_compat_wrapper.h' \
 		! -path './module/zstd/lib/*' \
-		$(cstyle_line)
+		-exec ${top_srcdir}/scripts/cstyle.pl -cpP {} \+

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

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

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

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

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

 if BUILD_LINUX
 stat_fmt = -c '%A %n'
@@ -179,20 +201,16 @@ vcscheck:
 		awk '{c++; print} END {if(c>0) exit 1}' ; \
 	fi

-PHONY += zstdcheck
-zstdcheck:
-	@$(MAKE) -C module/zstd checksymbols
-
 PHONY += lint
 lint: cppcheck paxcheck

-CPPCHECKDIRS = cmd lib module
 PHONY += cppcheck
-cppcheck: $(CPPCHECKDIRS)
-	@if test -n "$(CPPCHECK)"; then \
-		set -e ; for dir in $(CPPCHECKDIRS) ; do \
-			$(MAKE) -C $$dir cppcheck ; \
-		done \
+cppcheck:
+	@if type cppcheck > /dev/null 2>&1; then \
+		cppcheck --quiet --force --error-exitcode=2 --inline-suppr \
+			--suppressions-list=${top_srcdir}/cppcheck-suppressions.txt \
+			-UHAVE_SSE2 -UHAVE_AVX512F -UHAVE_UIO_ZEROCOPY \
+			${top_srcdir}; \
 	else \
 		echo "skipping cppcheck because cppcheck is not installed"; \
 	fi
@@ -12,7 +12,7 @@ This repository contains the code for running OpenZFS on Linux and FreeBSD.
  * [Documentation](https://openzfs.github.io/openzfs-docs/) - for using and developing this repo
  * [ZoL Site](https://zfsonlinux.org) - Linux release info & links
  * [Mailing lists](https://openzfs.github.io/openzfs-docs/Project%20and%20Community/Mailing%20Lists.html)
-  * [OpenZFS site](https://openzfs.org/) - for conference videos and info on other platforms (illumos, OSX, Windows, etc)
+  * [OpenZFS site](http://open-zfs.org/) - for conference videos and info on other platforms (illumos, OSX, Windows, etc)

 # Installation

@@ -32,4 +32,4 @@ For more details see the NOTICE, LICENSE and COPYRIGHT files; `UCRL-CODE-235197`

 # Supported Kernels
  * The `META` file contains the officially recognized supported Linux kernel versions.
-  * Supported FreeBSD versions are any supported branches and releases starting from 12.2-RELEASE.
+  * Supported FreeBSD versions are 12-STABLE and 13-CURRENT.
@@ -1,37 +0,0 @@
-OpenZFS uses the MAJOR.MINOR.PATCH versioning scheme described here:
-
-  * MAJOR - Incremented at the discretion of the OpenZFS developers to indicate
-    a particularly noteworthy feature or change. An increase in MAJOR number
-    does not indicate any incompatible on-disk format change. The ability
-    to import a ZFS pool is controlled by the feature flags enabled on the
-    pool and the feature flags supported by the installed OpenZFS version.
-    Increasing the MAJOR version is expected to be an infrequent occurrence.
-
-  * MINOR - Incremented to indicate new functionality such as a new feature
-    flag, pool/dataset property, zfs/zpool sub-command, new user/kernel
-    interface, etc. MINOR releases may introduce incompatible changes to the
-    user space library APIs (libzfs.so). Existing user/kernel interfaces are
-    considered to be stable to maximize compatibility between OpenZFS releases.
-    Additions to the user/kernel interface are backwards compatible.
-
-  * PATCH - Incremented when applying documentation updates, important bug
-    fixes, minor performance improvements, and kernel compatibility patches.
-    The user space library APIs and user/kernel interface are considered to
-    be stable. PATCH releases for a MAJOR.MINOR are published as needed.
-
-Two release branches are maintained for OpenZFS, they are:
-
-  * OpenZFS LTS - A designated MAJOR.MINOR release with periodic PATCH
-    releases that incorporate important changes backported from newer OpenZFS
-    releases. This branch is intended for use in environments using an
-    LTS, enterprise, or similarly managed kernel (RHEL, Ubuntu LTS, Debian).
-    Minor changes to support these distribution kernels will be applied as
-    needed. New kernel versions released after the OpenZFS LTS release are
-    not supported. LTS releases will receive patches for at least 2 years.
-    The current LTS release is OpenZFS 2.1.
-
-  * OpenZFS current - Tracks the newest MAJOR.MINOR release. This branch
-    includes support for the latest OpenZFS features and recently releases
-    kernels.  When a new MINOR release is tagged the previous MINOR release
-    will no longer be maintained (unless it is an LTS release). New MINOR
-    releases are planned to occur roughly annually.
@@ -1,14 +1,5 @@
-include $(top_srcdir)/config/Shellcheck.am
-
-SUBDIRS  = zfs zpool zdb zhack zinject zstream ztest
+SUBDIRS  = zfs zpool zdb zhack zinject zstream zstreamdump ztest
 SUBDIRS += fsck_zfs vdev_id raidz_test zfs_ids_to_path
-SUBDIRS += zpool_influxdb
-
-CPPCHECKDIRS  = zfs zpool zdb zhack zinject zstream ztest
-CPPCHECKDIRS += raidz_test zfs_ids_to_path zpool_influxdb
-
-# TODO: #12084: SHELLCHECKDIRS = fsck_zfs vdev_id zpool
-SHELLCHECKDIRS = fsck_zfs zpool

 if USING_PYTHON
 SUBDIRS += arcstat arc_summary dbufstat
@@ -16,12 +7,4 @@ endif

 if BUILD_LINUX
 SUBDIRS += mount_zfs zed zgenhostid zvol_id zvol_wait
-CPPCHECKDIRS += mount_zfs zed zgenhostid zvol_id
-SHELLCHECKDIRS += zed
 endif
-
-PHONY = cppcheck
-cppcheck: $(CPPCHECKDIRS)
-	set -e ; for dir in $(CPPCHECKDIRS) ; do \
-		$(MAKE) -C $$dir cppcheck ; \
-	done
@@ -59,20 +59,14 @@ if sys.platform.startswith('freebsd'):
    # Requires py27-sysctl on FreeBSD
    import sysctl

-    def is_value(ctl):
-        return ctl.type != sysctl.CTLTYPE_NODE
-
    def load_kstats(namespace):
        """Collect information on a specific subsystem of the ARC"""

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

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

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

@@ -102,6 +96,18 @@ show_tunable_descriptions = False
 alternate_tunable_layout = False


+def handle_Exception(ex_cls, ex, tb):
+    if ex is IOError:
+        if ex.errno == errno.EPIPE:
+            sys.exit()
+
+    if ex is KeyboardInterrupt:
+        sys.exit()
+
+
+sys.excepthook = handle_Exception
+
+
 def get_Kstat():
    """Collect information on the ZFS subsystem from the /proc virtual
    file system. The name "kstat" is a holdover from the Solaris utility
@@ -213,30 +219,12 @@ def get_arc_summary(Kstat):
    deleted = Kstat["kstat.zfs.misc.arcstats.deleted"]
    mutex_miss = Kstat["kstat.zfs.misc.arcstats.mutex_miss"]
    evict_skip = Kstat["kstat.zfs.misc.arcstats.evict_skip"]
-    evict_l2_cached = Kstat["kstat.zfs.misc.arcstats.evict_l2_cached"]
-    evict_l2_eligible = Kstat["kstat.zfs.misc.arcstats.evict_l2_eligible"]
-    evict_l2_eligible_mfu = Kstat["kstat.zfs.misc.arcstats.evict_l2_eligible_mfu"]
-    evict_l2_eligible_mru = Kstat["kstat.zfs.misc.arcstats.evict_l2_eligible_mru"]
-    evict_l2_ineligible = Kstat["kstat.zfs.misc.arcstats.evict_l2_ineligible"]
-    evict_l2_skip = Kstat["kstat.zfs.misc.arcstats.evict_l2_skip"]

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

    # ARC Sizing
    arc_size = Kstat["kstat.zfs.misc.arcstats.size"]
@@ -352,26 +340,8 @@ def _arc_summary(Kstat):
    sys.stdout.write("\tDeleted:\t\t\t\t%s\n" % arc['arc_misc']['deleted'])
    sys.stdout.write("\tMutex Misses:\t\t\t\t%s\n" %
                     arc['arc_misc']['mutex_miss'])
-    sys.stdout.write("\tEviction Skips:\t\t\t\t%s\n" %
+    sys.stdout.write("\tEvict Skips:\t\t\t\t%s\n" %
                     arc['arc_misc']['evict_skips'])
-    sys.stdout.write("\tEviction Skips Due to L2 Writes:\t%s\n" %
-                     arc['arc_misc']['evict_l2_skip'])
-    sys.stdout.write("\tL2 Cached Evictions:\t\t\t%s\n" %
-                     arc['arc_misc']['evict_l2_cached'])
-    sys.stdout.write("\tL2 Eligible Evictions:\t\t\t%s\n" %
-                     arc['arc_misc']['evict_l2_eligible'])
-    sys.stdout.write("\tL2 Eligible MFU Evictions:\t%s\t%s\n" % (
-                     arc['arc_misc']['evict_l2_eligible_mfu']['per'],
-                     arc['arc_misc']['evict_l2_eligible_mfu']['num'],
-                     )
-    )
-    sys.stdout.write("\tL2 Eligible MRU Evictions:\t%s\t%s\n" % (
-                     arc['arc_misc']['evict_l2_eligible_mru']['per'],
-                     arc['arc_misc']['evict_l2_eligible_mru']['num'],
-                     )
-    )
-    sys.stdout.write("\tL2 Ineligible Evictions:\t\t%s\n" %
-                     arc['arc_misc']['evict_l2_ineligible'])
    sys.stdout.write("\n")

    # ARC Sizing
@@ -707,11 +677,6 @@ def get_l2arc_summary(Kstat):
    l2_writes_done = Kstat["kstat.zfs.misc.arcstats.l2_writes_done"]
    l2_writes_error = Kstat["kstat.zfs.misc.arcstats.l2_writes_error"]
    l2_writes_sent = Kstat["kstat.zfs.misc.arcstats.l2_writes_sent"]
-    l2_mfu_asize = Kstat["kstat.zfs.misc.arcstats.l2_mfu_asize"]
-    l2_mru_asize = Kstat["kstat.zfs.misc.arcstats.l2_mru_asize"]
-    l2_prefetch_asize = Kstat["kstat.zfs.misc.arcstats.l2_prefetch_asize"]
-    l2_bufc_data_asize = Kstat["kstat.zfs.misc.arcstats.l2_bufc_data_asize"]
-    l2_bufc_metadata_asize = Kstat["kstat.zfs.misc.arcstats.l2_bufc_metadata_asize"]

    l2_access_total = (l2_hits + l2_misses)
    output['l2_health_count'] = (l2_writes_error + l2_cksum_bad + l2_io_error)
@@ -734,7 +699,7 @@ def get_l2arc_summary(Kstat):
        output["io_errors"] = fHits(l2_io_error)

        output["l2_arc_size"] = {}
-        output["l2_arc_size"]["adaptive"] = fBytes(l2_size)
+        output["l2_arc_size"]["adative"] = fBytes(l2_size)
        output["l2_arc_size"]["actual"] = {
            'per': fPerc(l2_asize, l2_size),
            'num': fBytes(l2_asize)
@@ -743,26 +708,6 @@ def get_l2arc_summary(Kstat):
            'per': fPerc(l2_hdr_size, l2_size),
            'num': fBytes(l2_hdr_size),
        }
-        output["l2_arc_size"]["mfu_asize"] = {
-            'per': fPerc(l2_mfu_asize, l2_asize),
-            'num': fBytes(l2_mfu_asize),
-        }
-        output["l2_arc_size"]["mru_asize"] = {
-            'per': fPerc(l2_mru_asize, l2_asize),
-            'num': fBytes(l2_mru_asize),
-        }
-        output["l2_arc_size"]["prefetch_asize"] = {
-            'per': fPerc(l2_prefetch_asize, l2_asize),
-            'num': fBytes(l2_prefetch_asize),
-        }
-        output["l2_arc_size"]["bufc_data_asize"] = {
-            'per': fPerc(l2_bufc_data_asize, l2_asize),
-            'num': fBytes(l2_bufc_data_asize),
-        }
-        output["l2_arc_size"]["bufc_metadata_asize"] = {
-            'per': fPerc(l2_bufc_metadata_asize, l2_asize),
-            'num': fBytes(l2_bufc_metadata_asize),
-        }

        output["l2_arc_evicts"] = {}
        output["l2_arc_evicts"]['lock_retries'] = fHits(l2_evict_lock_retry)
@@ -827,7 +772,7 @@ def _l2arc_summary(Kstat):
        sys.stdout.write("\n")

        sys.stdout.write("L2 ARC Size: (Adaptive)\t\t\t\t%s\n" %
-                         arc["l2_arc_size"]["adaptive"])
+                         arc["l2_arc_size"]["adative"])
        sys.stdout.write("\tCompressed:\t\t\t%s\t%s\n" % (
            arc["l2_arc_size"]["actual"]["per"],
            arc["l2_arc_size"]["actual"]["num"],
@@ -838,36 +783,11 @@ def _l2arc_summary(Kstat):
            arc["l2_arc_size"]["head_size"]["num"],
            )
        )
-        sys.stdout.write("\tMFU Alloc. Size:\t\t%s\t%s\n" % (
-            arc["l2_arc_size"]["mfu_asize"]["per"],
-            arc["l2_arc_size"]["mfu_asize"]["num"],
-            )
-        )
-        sys.stdout.write("\tMRU Alloc. Size:\t\t%s\t%s\n" % (
-            arc["l2_arc_size"]["mru_asize"]["per"],
-            arc["l2_arc_size"]["mru_asize"]["num"],
-            )
-        )
-        sys.stdout.write("\tPrefetch Alloc. Size:\t\t%s\t%s\n" % (
-            arc["l2_arc_size"]["prefetch_asize"]["per"],
-            arc["l2_arc_size"]["prefetch_asize"]["num"],
-            )
-        )
-        sys.stdout.write("\tData (buf content) Alloc. Size:\t%s\t%s\n" % (
-            arc["l2_arc_size"]["bufc_data_asize"]["per"],
-            arc["l2_arc_size"]["bufc_data_asize"]["num"],
-            )
-        )
-        sys.stdout.write("\tMetadata (buf content) Size:\t%s\t%s\n" % (
-            arc["l2_arc_size"]["bufc_metadata_asize"]["per"],
-            arc["l2_arc_size"]["bufc_metadata_asize"]["num"],
-            )
-        )
        sys.stdout.write("\n")

        if arc["l2_arc_evicts"]['lock_retries'] != '0' or \
           arc["l2_arc_evicts"]["reading"] != '0':
-            sys.stdout.write("L2 ARC Evictions:\n")
+            sys.stdout.write("L2 ARC Evicts:\n")
            sys.stdout.write("\tLock Retries:\t\t\t\t%s\n" %
                             arc["l2_arc_evicts"]['lock_retries'])
            sys.stdout.write("\tUpon Reading:\t\t\t\t%s\n" %
@@ -1125,55 +1045,48 @@ def main():
    global alternate_tunable_layout

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


 if __name__ == '__main__':
@@ -42,13 +42,6 @@ import os
 import subprocess
 import sys
 import time
-import errno
-
-# We can't use env -S portably, and we need python3 -u to handle pipes in
-# the shell abruptly closing the way we want to, so...
-import io
-if isinstance(sys.__stderr__.buffer, io.BufferedWriter):
-    os.execv(sys.executable, [sys.executable, "-u"] + sys.argv)

 DESCRIPTION = 'Print ARC and other statistics for OpenZFS'
 INDENT = ' '*8
@@ -65,6 +58,7 @@ SECTION_PATHS = {'arc': 'arcstats',
                 'dmu': 'dmu_tx',
                 'l2arc': 'arcstats',  # L2ARC stuff lives in arcstats
                 'vdev': 'vdev_cache_stats',
+                 'xuio': 'xuio_stats',
                 'zfetch': 'zfetchstats',
                 'zil': 'zil'}

@@ -92,24 +86,16 @@ if sys.platform.startswith('freebsd'):

    VDEV_CACHE_SIZE = 'vdev.cache_size'

-    def is_value(ctl):
-        return ctl.type != sysctl.CTLTYPE_NODE
-
-    def namefmt(ctl, base='vfs.zfs.'):
-        # base is removed from the name
-        cut = len(base)
-        return ctl.name[cut:]
-
    def load_kstats(section):
        base = 'kstat.zfs.misc.{section}.'.format(section=section)
-        fmt = lambda kstat: '{name} : {value}'.format(name=namefmt(kstat, base),
+        # base is removed from the name
+        fmt = lambda kstat: '{name} : {value}'.format(name=kstat.name[len(base):],
                                                      value=kstat.value)
-        kstats = sysctl.filter(base)
-        return [fmt(kstat) for kstat in kstats if is_value(kstat)]
+        return [fmt(kstat) for kstat in sysctl.filter(base)]

    def get_params(base):
-        ctls = sysctl.filter(base)
-        return {namefmt(ctl): str(ctl.value) for ctl in ctls if is_value(ctl)}
+        cut = 8 # = len('vfs.zfs.')
+        return {ctl.name[cut:]: str(ctl.value) for ctl in sysctl.filter(base)}

    def get_tunable_params():
        return get_params('vfs.zfs')
@@ -126,8 +112,25 @@ if sys.platform.startswith('freebsd'):
        return '{} version {}'.format(name, version)

    def get_descriptions(_request):
-        ctls = sysctl.filter('vfs.zfs')
-        return {namefmt(ctl): ctl.description for ctl in ctls if is_value(ctl)}
+        # py-sysctl doesn't give descriptions, so we have to shell out.
+        command = ['sysctl', '-d', 'vfs.zfs']
+
+        # The recommended way to do this is with subprocess.run(). However,
+        # some installed versions of Python are < 3.5, so we offer them
+        # the option of doing it the old way (for now)
+        if 'run' in dir(subprocess):
+            info = subprocess.run(command, stdout=subprocess.PIPE,
+                                  universal_newlines=True)
+            lines = info.stdout.split('\n')
+        else:
+            info = subprocess.check_output(command, universal_newlines=True)
+            lines = info.split('\n')
+
+        def fmt(line):
+            name, desc = line.split(':', 1)
+            return (name.strip(), desc.strip())
+
+        return dict([fmt(line) for line in lines if len(line) > 0])


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

    def get_descriptions(request):
        """Get the descriptions of the Solaris Porting Layer (SPL) or the
@@ -228,29 +241,6 @@ elif sys.platform.startswith('linux'):

        return descs

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

 def cleanup_line(single_line):
    """Format a raw line of data from /proc and isolate the name value
@@ -407,12 +397,8 @@ def format_raw_line(name, value):
    if ARGS.alt:
        result = '{0}{1}={2}'.format(INDENT, name, value)
    else:
-        # Right-align the value within the line length if it fits,
-        # otherwise just separate it from the name by a single space.
-        fit = LINE_LENGTH - len(INDENT) - len(name)
-        overflow = len(value) + 1
-        w = max(fit, overflow)
-        result = '{0}{1}{2:>{w}}'.format(INDENT, name, value, w=w)
+        spc = LINE_LENGTH-(len(INDENT)+len(value))
+        result = '{0}{1:<{spc}}{2}'.format(INDENT, name, value, spc=spc)

    return result

@@ -612,20 +598,6 @@ def section_arc(kstats_dict):
    prt_i1('Deleted:', f_hits(arc_stats['deleted']))
    prt_i1('Mutex misses:', f_hits(arc_stats['mutex_miss']))
    prt_i1('Eviction skips:', f_hits(arc_stats['evict_skip']))
-    prt_i1('Eviction skips due to L2 writes:',
-           f_hits(arc_stats['evict_l2_skip']))
-    prt_i1('L2 cached evictions:', f_bytes(arc_stats['evict_l2_cached']))
-    prt_i1('L2 eligible evictions:', f_bytes(arc_stats['evict_l2_eligible']))
-    prt_i2('L2 eligible MFU evictions:',
-           f_perc(arc_stats['evict_l2_eligible_mfu'],
-           arc_stats['evict_l2_eligible']),
-           f_bytes(arc_stats['evict_l2_eligible_mfu']))
-    prt_i2('L2 eligible MRU evictions:',
-           f_perc(arc_stats['evict_l2_eligible_mru'],
-           arc_stats['evict_l2_eligible']),
-           f_bytes(arc_stats['evict_l2_eligible_mru']))
-    prt_i1('L2 ineligible evictions:',
-           f_bytes(arc_stats['evict_l2_ineligible']))
    print()


@@ -764,21 +736,6 @@ def section_l2arc(kstats_dict):
    prt_i2('Header size:',
           f_perc(arc_stats['l2_hdr_size'], arc_stats['l2_size']),
           f_bytes(arc_stats['l2_hdr_size']))
-    prt_i2('MFU allocated size:',
-           f_perc(arc_stats['l2_mfu_asize'], arc_stats['l2_asize']),
-           f_bytes(arc_stats['l2_mfu_asize']))
-    prt_i2('MRU allocated size:',
-           f_perc(arc_stats['l2_mru_asize'], arc_stats['l2_asize']),
-           f_bytes(arc_stats['l2_mru_asize']))
-    prt_i2('Prefetch allocated size:',
-           f_perc(arc_stats['l2_prefetch_asize'], arc_stats['l2_asize']),
-           f_bytes(arc_stats['l2_prefetch_asize']))
-    prt_i2('Data (buffer content) allocated size:',
-           f_perc(arc_stats['l2_bufc_data_asize'], arc_stats['l2_asize']),
-           f_bytes(arc_stats['l2_bufc_data_asize']))
-    prt_i2('Metadata (buffer content) allocated size:',
-           f_perc(arc_stats['l2_bufc_metadata_asize'], arc_stats['l2_asize']),
-           f_bytes(arc_stats['l2_bufc_metadata_asize']))

    print()
    prt_1('L2ARC breakdown:', f_hits(l2_access_total))
@@ -88,12 +88,6 @@ cols = {
    "mfug":       [4, 1000, "MFU ghost list hits per second"],
    "mrug":       [4, 1000, "MRU ghost list hits per second"],
    "eskip":      [5, 1000, "evict_skip per second"],
-    "el2skip":    [7, 1000, "evict skip, due to l2 writes, per second"],
-    "el2cach":    [7, 1024, "Size of L2 cached evictions per second"],
-    "el2el":      [5, 1024, "Size of L2 eligible evictions per second"],
-    "el2mfu":     [6, 1024, "Size of L2 eligible MFU evictions per second"],
-    "el2mru":     [6, 1024, "Size of L2 eligible MRU evictions per second"],
-    "el2inel":    [7, 1024, "Size of L2 ineligible evictions per second"],
    "mtxmis":     [6, 1000, "mutex_miss per second"],
    "dread":      [5, 1000, "Demand accesses per second"],
    "pread":      [5, 1000, "Prefetch accesses per second"],
@@ -102,16 +96,6 @@ cols = {
    "l2read":     [6, 1000, "Total L2ARC accesses per second"],
    "l2hit%":     [6, 100, "L2ARC access hit percentage"],
    "l2miss%":    [7, 100, "L2ARC access miss percentage"],
-    "l2pref":     [6, 1024, "L2ARC prefetch allocated size"],
-    "l2mfu":      [5, 1024, "L2ARC MFU allocated size"],
-    "l2mru":      [5, 1024, "L2ARC MRU allocated size"],
-    "l2data":     [6, 1024, "L2ARC data allocated size"],
-    "l2meta":     [6, 1024, "L2ARC metadata allocated size"],
-    "l2pref%":    [7, 100, "L2ARC prefetch percentage"],
-    "l2mfu%":     [6, 100, "L2ARC MFU percentage"],
-    "l2mru%":     [6, 100, "L2ARC MRU percentage"],
-    "l2data%":    [7, 100, "L2ARC data percentage"],
-    "l2meta%":    [7, 100, "L2ARC metadata percentage"],
    "l2asize":    [7, 1024, "Actual (compressed) size of the L2ARC"],
    "l2size":     [6, 1024, "Size of the L2ARC"],
    "l2bytes":    [7, 1024, "Bytes read per second from the L2ARC"],
@@ -144,14 +128,13 @@ pretty_print = True


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

    def kstat_update():
        global kstat

-        k = [ctl for ctl in sysctl.filter('kstat.zfs.misc.arcstats')
-             if ctl.type != sysctl.CTLTYPE_NODE]
+        k = sysctl.filter('kstat.zfs.misc.arcstats')

        if not k:
            sys.exit(1)
@@ -271,7 +254,7 @@ def print_values():
    if pretty_print:
        fmt = lambda col: prettynum(cols[col][0], cols[col][1], v[col])
    else:
-        fmt = lambda col: str(v[col])
+        fmt = lambda col: v[col]

    sys.stdout.write(sep.join(fmt(col) for col in hdr))
    sys.stdout.write("\n")
@@ -479,12 +462,6 @@ def calculate():
    v["mrug"] = d["mru_ghost_hits"] / sint
    v["mfug"] = d["mfu_ghost_hits"] / sint
    v["eskip"] = d["evict_skip"] / sint
-    v["el2skip"] = d["evict_l2_skip"] / sint
-    v["el2cach"] = d["evict_l2_cached"] / sint
-    v["el2el"] = d["evict_l2_eligible"] / sint
-    v["el2mfu"] = d["evict_l2_eligible_mfu"] / sint
-    v["el2mru"] = d["evict_l2_eligible_mru"] / sint
-    v["el2inel"] = d["evict_l2_ineligible"] / sint
    v["mtxmis"] = d["mutex_miss"] / sint

    if l2exist:
@@ -498,17 +475,6 @@ def calculate():
        v["l2size"] = cur["l2_size"]
        v["l2bytes"] = d["l2_read_bytes"] / sint

-        v["l2pref"] = cur["l2_prefetch_asize"]
-        v["l2mfu"] = cur["l2_mfu_asize"]
-        v["l2mru"] = cur["l2_mru_asize"]
-        v["l2data"] = cur["l2_bufc_data_asize"]
-        v["l2meta"] = cur["l2_bufc_metadata_asize"]
-        v["l2pref%"] = 100 * v["l2pref"] / v["l2asize"]
-        v["l2mfu%"] = 100 * v["l2mfu"] / v["l2asize"]
-        v["l2mru%"] = 100 * v["l2mru"] / v["l2asize"]
-        v["l2data%"] = 100 * v["l2data"] / v["l2asize"]
-        v["l2meta%"] = 100 * v["l2meta"] / v["l2asize"]
-
    v["grow"] = 0 if cur["arc_no_grow"] else 1
    v["need"] = cur["arc_need_free"]
    v["free"] = cur["memory_free_bytes"]
@@ -131,7 +131,7 @@ elif sys.platform.startswith("linux"):
 def print_incompat_helper(incompat):
    cnt = 0
    for key in sorted(incompat):
-        if cnt == 0:
+        if cnt is 0:
            sys.stderr.write("\t")
        elif cnt > 8:
            sys.stderr.write(",\n\t")
@@ -662,7 +662,7 @@ def main():
    if not ifile:
        ifile = default_ifile()

-    if ifile != "-":
+    if ifile is not "-":
        try:
            tmp = open(ifile, "r")
            sys.stdin = tmp
@@ -1 +0,0 @@
-/fsck.zfs
@@ -1,6 +1 @@
-include $(top_srcdir)/config/Substfiles.am
-include $(top_srcdir)/config/Shellcheck.am
-
 dist_sbin_SCRIPTS = fsck.zfs
-
-SUBSTFILES += $(dist_sbin_SCRIPTS)
@@ -0,0 +1,9 @@
+#!/bin/sh
+#
+# fsck.zfs: A fsck helper to accommodate distributions that expect
+# to be able to execute a fsck on all filesystem types.  Currently
+# this script does nothing but it could be extended to act as a
+# compatibility wrapper for 'zpool scrub'.
+#
+
+exit 0
@@ -1,44 +0,0 @@
-#!/bin/sh
-#
-# fsck.zfs: A fsck helper to accommodate distributions that expect
-# to be able to execute a fsck on all filesystem types.
-#
-# This script simply bubbles up some already-known-about errors,
-# see fsck.zfs(8)
-#
-
-if [ "$#" = "0" ]; then
-	echo "Usage: $0 [options] dataset…" >&2
-	exit 16
-fi
-
-ret=0
-for dataset in "$@"; do
-	case "$dataset" in
-		-*)
-			continue
-			;;
-		*)
-			;;
-	esac
-
-	pool="${dataset%%/*}"
-
-	case "$(@sbindir@/zpool list -Ho health "$pool")" in
-		DEGRADED)
-			ret=$(( ret | 4 ))
-			;;
-		FAULTED)
-			awk '!/^([[:space:]]*#.*)?$/ && $1 == "'"$dataset"'" && $3 == "zfs" {exit 1}' /etc/fstab || \
-				ret=$(( ret | 8 ))
-			;;
-		"")
-			# Pool not found, error printed by zpool(8)
-			ret=$(( ret | 8 ))
-			;;
-		*)
-			;;
-	esac
-done
-
-exit "$ret"
@@ -18,5 +18,3 @@ mount_zfs_LDADD = \
 	$(abs_top_builddir)/lib/libnvpair/libnvpair.la

 mount_zfs_LDADD += $(LTLIBINTL)
-
-include $(top_srcdir)/config/CppCheck.am
@@ -43,45 +43,53 @@
 libzfs_handle_t *g_zfs;

 /*
- * Opportunistically convert a target string into a pool name. If the
- * string does not represent a block device with a valid zfs label
- * then it is passed through without modification.
+ * Return the pool/dataset to mount given the name passed to mount.  This
+ * is expected to be of the form pool/dataset, however may also refer to
+ * a block device if that device contains a valid zfs label.
 */
 static void
 parse_dataset(const char *target, char **dataset)
 {
 	/*
-	 * Prior to util-linux 2.36.2, if a file or directory in the
-	 * current working directory was named 'dataset' then mount(8)
-	 * would prepend the current working directory to the dataset.
-	 * Check for it and strip the prepended path when it is added.
+	 * We expect a pool/dataset to be provided, however if we're
+	 * given a device which is a member of a zpool we attempt to
+	 * extract the pool name stored in the label.  Given the pool
+	 * name we can mount the root dataset.
+	 */
+	int fd = open(target, O_RDONLY);
+	if (fd >= 0) {
+		nvlist_t *config = NULL;
+		if (zpool_read_label(fd, &config, NULL) != 0)
+			config = NULL;
+		if (close(fd))
+			perror("close");
+
+		if (config) {
+			char *name = NULL;
+			if (!nvlist_lookup_string(config,
+			    ZPOOL_CONFIG_POOL_NAME, &name))
+				(void) strlcpy(*dataset, name, PATH_MAX);
+			nvlist_free(config);
+			if (name)
+				return;
+		}
+	}
+
+	/*
+	 * If a file or directory in your current working directory is
+	 * named 'dataset' then mount(8) will prepend your current working
+	 * directory to the dataset.  There is no way to prevent this
+	 * behavior so we simply check for it and strip the prepended
+	 * patch when it is added.
 	 */
 	char cwd[PATH_MAX];
-	if (getcwd(cwd, PATH_MAX) == NULL) {
-		perror("getcwd");
-		return;
+	if (getcwd(cwd, PATH_MAX) != NULL) {
+		int len = strlen(cwd);
+		/* Do not add one when cwd already ends in a trailing '/' */
+		if (strncmp(cwd, target, len) == 0)
+			target += len + (cwd[len-1] != '/');
 	}
-	int len = strlen(cwd);
-	if (strncmp(cwd, target, len) == 0)
-		target += len;
-
-	/* Assume pool/dataset is more likely */
 	strlcpy(*dataset, target, PATH_MAX);
-
-	int fd = open(target, O_RDONLY | O_CLOEXEC);
-	if (fd < 0)
-		return;
-
-	nvlist_t *cfg = NULL;
-	if (zpool_read_label(fd, &cfg, NULL) == 0) {
-		char *nm = NULL;
-		if (!nvlist_lookup_string(cfg, ZPOOL_CONFIG_POOL_NAME, &nm))
-			strlcpy(*dataset, nm, PATH_MAX);
-		nvlist_free(cfg);
-	}
-
-	if (close(fd))
-		perror("close");
 }

 /*
@@ -125,8 +133,8 @@ mtab_update(char *dataset, char *mntpoint, char *type, char *mntopts)
 	if (!fp) {
 		(void) fprintf(stderr, gettext(
 		    "filesystem '%s' was mounted, but /etc/mtab "
-		    "could not be opened due to error: %s\n"),
-		    dataset, strerror(errno));
+		    "could not be opened due to error %d\n"),
+		    dataset, errno);
 		return (MOUNT_FILEIO);
 	}

@@ -134,8 +142,8 @@ mtab_update(char *dataset, char *mntpoint, char *type, char *mntopts)
 	if (error) {
 		(void) fprintf(stderr, gettext(
 		    "filesystem '%s' was mounted, but /etc/mtab "
-		    "could not be updated due to error: %s\n"),
-		    dataset, strerror(errno));
+		    "could not be updated due to error %d\n"),
+		    dataset, errno);
 		return (MOUNT_FILEIO);
 	}

@@ -185,11 +193,10 @@ main(int argc, char **argv)
 			break;
 		case 'h':
 		case '?':
-			if (optopt)
-				(void) fprintf(stderr,
-				    gettext("Invalid option '%c'\n"), optopt);
+			(void) fprintf(stderr, gettext("Invalid option '%c'\n"),
+			    optopt);
 			(void) fprintf(stderr, gettext("Usage: mount.zfs "
-			    "[-sfnvh] [-o options] <dataset> <mountpoint>\n"));
+			    "[-sfnv] [-o options] <dataset> <mountpoint>\n"));
 			return (MOUNT_USAGE);
 		}
 	}
@@ -216,8 +223,8 @@ main(int argc, char **argv)
 	/* canonicalize the mount point */
 	if (realpath(argv[1], mntpoint) == NULL) {
 		(void) fprintf(stderr, gettext("filesystem '%s' cannot be "
-		    "mounted at '%s' due to canonicalization error: %s\n"),
-		    dataset, argv[1], strerror(errno));
+		    "mounted at '%s' due to canonicalization error %d.\n"),
+		    dataset, argv[1], errno);
 		return (MOUNT_SYSERR);
 	}

@@ -246,6 +253,13 @@ main(int argc, char **argv)
 		}
 	}

+	if (verbose)
+		(void) fprintf(stdout, gettext("mount.zfs:\n"
+		    "  dataset:    \"%s\"\n  mountpoint: \"%s\"\n"
+		    "  mountflags: 0x%lx\n  zfsflags:   0x%lx\n"
+		    "  mountopts:  \"%s\"\n  mtabopts:   \"%s\"\n"),
+		    dataset, mntpoint, mntflags, zfsflags, mntopts, mtabopt);
+
 	if (mntflags & MS_REMOUNT) {
 		nomtab = 1;
 		remount = 1;
@@ -268,10 +282,7 @@ main(int argc, char **argv)
 		return (MOUNT_USAGE);
 	}

-	if (!zfsutil || sloppy ||
-	    libzfs_envvar_is_set("ZFS_MOUNT_HELPER")) {
-		zfs_adjust_mount_options(zhp, mntpoint, mntopts, mtabopt);
-	}
+	zfs_adjust_mount_options(zhp, mntpoint, mntopts, mtabopt);

 	/* treat all snapshots as legacy mount points */
 	if (zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT)
@@ -289,11 +300,12 @@ main(int argc, char **argv)
 	if (zfs_version == 0) {
 		fprintf(stderr, gettext("unable to fetch "
 		    "ZFS version for filesystem '%s'\n"), dataset);
-		zfs_close(zhp);
-		libzfs_fini(g_zfs);
 		return (MOUNT_SYSERR);
 	}

+	zfs_close(zhp);
+	libzfs_fini(g_zfs);
+
 	/*
 	 * Legacy mount points may only be mounted using 'mount', never using
 	 * 'zfs mount'.  However, since 'zfs mount' actually invokes 'mount'
@@ -311,8 +323,6 @@ main(int argc, char **argv)
 		    "Use 'zfs set mountpoint=%s' or 'mount -t zfs %s %s'.\n"
 		    "See zfs(8) for more information.\n"),
 		    dataset, mntpoint, dataset, mntpoint);
-		zfs_close(zhp);
-		libzfs_fini(g_zfs);
 		return (MOUNT_USAGE);
 	}

@@ -323,38 +333,14 @@ main(int argc, char **argv)
 		    "Use 'zfs set mountpoint=%s' or 'zfs mount %s'.\n"
 		    "See zfs(8) for more information.\n"),
 		    dataset, "legacy", dataset);
-		zfs_close(zhp);
-		libzfs_fini(g_zfs);
 		return (MOUNT_USAGE);
 	}

-	if (verbose)
-		(void) fprintf(stdout, gettext("mount.zfs:\n"
-		    "  dataset:    \"%s\"\n  mountpoint: \"%s\"\n"
-		    "  mountflags: 0x%lx\n  zfsflags:   0x%lx\n"
-		    "  mountopts:  \"%s\"\n  mtabopts:   \"%s\"\n"),
-		    dataset, mntpoint, mntflags, zfsflags, mntopts, mtabopt);
-
 	if (!fake) {
-		if (zfsutil && !sloppy &&
-		    !libzfs_envvar_is_set("ZFS_MOUNT_HELPER")) {
-			error = zfs_mount_at(zhp, mntopts, mntflags, mntpoint);
-			if (error) {
-				(void) fprintf(stderr, "zfs_mount_at() failed: "
-				    "%s", libzfs_error_description(g_zfs));
-				zfs_close(zhp);
-				libzfs_fini(g_zfs);
-				return (MOUNT_SYSERR);
-			}
-		} else {
-			error = mount(dataset, mntpoint, MNTTYPE_ZFS,
-			    mntflags, mntopts);
-		}
+		error = mount(dataset, mntpoint, MNTTYPE_ZFS,
+		    mntflags, mntopts);
 	}

-	zfs_close(zhp);
-	libzfs_fini(g_zfs);
-
 	if (error) {
 		switch (errno) {
 		case ENOENT:
@@ -389,7 +375,7 @@ main(int argc, char **argv)
 				    "mount the filesystem again.\n"), dataset);
 				return (MOUNT_SYSERR);
 			}
-			fallthrough;
+			/* fallthru */
 #endif
 		default:
 			(void) fprintf(stderr, gettext("filesystem "
@@ -18,5 +18,3 @@ raidz_test_LDADD = \
 	$(abs_top_builddir)/lib/libzfs_core/libzfs_core.la

 raidz_test_LDADD += -lm
-
-include $(top_srcdir)/config/CppCheck.am
@@ -31,6 +31,8 @@
 #include <sys/vdev_raidz_impl.h>
 #include <stdio.h>

+#include <sys/time.h>
+
 #include "raidz_test.h"

 #define	GEN_BENCH_MEMORY	(((uint64_t)1ULL)<<32)
@@ -81,17 +83,8 @@ run_gen_bench_impl(const char *impl)
 			/* create suitable raidz_map */
 			ncols = rto_opts.rto_dcols + fn + 1;
 			zio_bench.io_size = 1ULL << ds;
-
-			if (rto_opts.rto_expand) {
-				rm_bench = vdev_raidz_map_alloc_expanded(
-				    zio_bench.io_abd,
-				    zio_bench.io_size, zio_bench.io_offset,
-				    rto_opts.rto_ashift, ncols+1, ncols,
-				    fn+1, rto_opts.rto_expand_offset);
-			} else {
-				rm_bench = vdev_raidz_map_alloc(&zio_bench,
-				    BENCH_ASHIFT, ncols, fn+1);
-			}
+			rm_bench = vdev_raidz_map_alloc(&zio_bench,
+			    BENCH_ASHIFT, ncols, fn+1);

 			/* estimate iteration count */
 			iter_cnt = GEN_BENCH_MEMORY;
@@ -170,16 +163,8 @@ run_rec_bench_impl(const char *impl)
 			    (1ULL << BENCH_ASHIFT))
 				continue;

-			if (rto_opts.rto_expand) {
-				rm_bench = vdev_raidz_map_alloc_expanded(
-				    zio_bench.io_abd,
-				    zio_bench.io_size, zio_bench.io_offset,
-				    BENCH_ASHIFT, ncols+1, ncols,
-				    PARITY_PQR, rto_opts.rto_expand_offset);
-			} else {
-				rm_bench = vdev_raidz_map_alloc(&zio_bench,
-				    BENCH_ASHIFT, ncols, PARITY_PQR);
-			}
+			rm_bench = vdev_raidz_map_alloc(&zio_bench,
+			    BENCH_ASHIFT, ncols, PARITY_PQR);

 			/* estimate iteration count */
 			iter_cnt = (REC_BENCH_MEMORY);
@@ -77,20 +77,16 @@ static void print_opts(raidz_test_opts_t *opts, boolean_t force)
 		(void) fprintf(stdout, DBLSEP "Running with options:\n"
 		    "  (-a) zio ashift                   : %zu\n"
 		    "  (-o) zio offset                   : 1 << %zu\n"
-		    "  (-e) expanded map                 : %s\n"
-		    "  (-r) reflow offset                : %llx\n"
 		    "  (-d) number of raidz data columns : %zu\n"
 		    "  (-s) size of DATA                 : 1 << %zu\n"
 		    "  (-S) sweep parameters             : %s \n"
 		    "  (-v) verbose                      : %s \n\n",
-		    opts->rto_ashift,				/* -a */
-		    ilog2(opts->rto_offset),			/* -o */
-		    opts->rto_expand ? "yes" : "no",		/* -e */
-		    (u_longlong_t)opts->rto_expand_offset,	/* -r */
-		    opts->rto_dcols,				/* -d */
-		    ilog2(opts->rto_dsize),			/* -s */
-		    opts->rto_sweep ? "yes" : "no",		/* -S */
-		    verbose);					/* -v */
+		    opts->rto_ashift,			/* -a */
+		    ilog2(opts->rto_offset),		/* -o */
+		    opts->rto_dcols,			/* -d */
+		    ilog2(opts->rto_dsize),		/* -s */
+		    opts->rto_sweep ? "yes" : "no",	/* -S */
+		    verbose);				/* -v */
 	}
 }

@@ -108,8 +104,6 @@ static void usage(boolean_t requested)
 	    "\t[-S parameter sweep (default: %s)]\n"
 	    "\t[-t timeout for parameter sweep test]\n"
 	    "\t[-B benchmark all raidz implementations]\n"
-	    "\t[-e use expanded raidz map (default: %s)]\n"
-	    "\t[-r expanded raidz map reflow offset (default: %llx)]\n"
 	    "\t[-v increase verbosity (default: %zu)]\n"
 	    "\t[-h (print help)]\n"
 	    "\t[-T test the test, see if failure would be detected]\n"
@@ -120,8 +114,6 @@ static void usage(boolean_t requested)
 	    o->rto_dcols,				/* -d */
 	    ilog2(o->rto_dsize),			/* -s */
 	    rto_opts.rto_sweep ? "yes" : "no",		/* -S */
-	    rto_opts.rto_expand ? "yes" : "no",		/* -e */
-	    (u_longlong_t)o->rto_expand_offset,		/* -r */
 	    o->rto_v);					/* -d */

 	exit(requested ? 0 : 1);
@@ -136,7 +128,7 @@ static void process_options(int argc, char **argv)

 	bcopy(&rto_opts_defaults, o, sizeof (*o));

-	while ((opt = getopt(argc, argv, "TDBSvha:er:o:d:s:t:")) != -1) {
+	while ((opt = getopt(argc, argv, "TDBSvha:o:d:s:t:")) != -1) {
 		value = 0;

 		switch (opt) {
@@ -144,12 +136,6 @@ static void process_options(int argc, char **argv)
 			value = strtoull(optarg, NULL, 0);
 			o->rto_ashift = MIN(13, MAX(9, value));
 			break;
-		case 'e':
-			o->rto_expand = 1;
-			break;
-		case 'r':
-			o->rto_expand_offset = strtoull(optarg, NULL, 0);
-			break;
 		case 'o':
 			value = strtoull(optarg, NULL, 0);
 			o->rto_offset = ((1ULL << MIN(12, value)) >> 9) << 9;
@@ -193,34 +179,25 @@ static void process_options(int argc, char **argv)
 	}
 }

-#define	DATA_COL(rr, i) ((rr)->rr_col[rr->rr_firstdatacol + (i)].rc_abd)
-#define	DATA_COL_SIZE(rr, i) ((rr)->rr_col[rr->rr_firstdatacol + (i)].rc_size)
+#define	DATA_COL(rm, i) ((rm)->rm_col[raidz_parity(rm) + (i)].rc_abd)
+#define	DATA_COL_SIZE(rm, i) ((rm)->rm_col[raidz_parity(rm) + (i)].rc_size)

-#define	CODE_COL(rr, i) ((rr)->rr_col[(i)].rc_abd)
-#define	CODE_COL_SIZE(rr, i) ((rr)->rr_col[(i)].rc_size)
+#define	CODE_COL(rm, i) ((rm)->rm_col[(i)].rc_abd)
+#define	CODE_COL_SIZE(rm, i) ((rm)->rm_col[(i)].rc_size)

 static int
 cmp_code(raidz_test_opts_t *opts, const raidz_map_t *rm, const int parity)
 {
-	int r, i, ret = 0;
+	int i, ret = 0;

 	VERIFY(parity >= 1 && parity <= 3);

-	for (r = 0; r < rm->rm_nrows; r++) {
-		raidz_row_t * const rr = rm->rm_row[r];
-		raidz_row_t * const rrg = opts->rm_golden->rm_row[r];
-		for (i = 0; i < parity; i++) {
-			if (CODE_COL_SIZE(rrg, i) == 0) {
-				VERIFY0(CODE_COL_SIZE(rr, i));
-				continue;
-			}
-
-			if (abd_cmp(CODE_COL(rr, i),
-			    CODE_COL(rrg, i)) != 0) {
-				ret++;
-				LOG_OPT(D_DEBUG, opts,
-				    "\nParity block [%d] different!\n", i);
-			}
+	for (i = 0; i < parity; i++) {
+		if (abd_cmp(CODE_COL(rm, i), CODE_COL(opts->rm_golden, i))
+		    != 0) {
+			ret++;
+			LOG_OPT(D_DEBUG, opts,
+			    "\nParity block [%d] different!\n", i);
 		}
 	}
 	return (ret);
@@ -229,26 +206,16 @@ cmp_code(raidz_test_opts_t *opts, const raidz_map_t *rm, const int parity)
 static int
 cmp_data(raidz_test_opts_t *opts, raidz_map_t *rm)
 {
-	int r, i, dcols, ret = 0;
+	int i, ret = 0;
+	int dcols = opts->rm_golden->rm_cols - raidz_parity(opts->rm_golden);

-	for (r = 0; r < rm->rm_nrows; r++) {
-		raidz_row_t *rr = rm->rm_row[r];
-		raidz_row_t *rrg = opts->rm_golden->rm_row[r];
-		dcols = opts->rm_golden->rm_row[0]->rr_cols -
-		    raidz_parity(opts->rm_golden);
-		for (i = 0; i < dcols; i++) {
-			if (DATA_COL_SIZE(rrg, i) == 0) {
-				VERIFY0(DATA_COL_SIZE(rr, i));
-				continue;
-			}
+	for (i = 0; i < dcols; i++) {
+		if (abd_cmp(DATA_COL(opts->rm_golden, i), DATA_COL(rm, i))
+		    != 0) {
+			ret++;

-			if (abd_cmp(DATA_COL(rrg, i),
-			    DATA_COL(rr, i)) != 0) {
-				ret++;
-
-				LOG_OPT(D_DEBUG, opts,
-				    "\nData block [%d] different!\n", i);
-			}
+			LOG_OPT(D_DEBUG, opts,
+			    "\nData block [%d] different!\n", i);
 		}
 	}
 	return (ret);
@@ -269,13 +236,12 @@ init_rand(void *data, size_t size, void *private)
 static void
 corrupt_colums(raidz_map_t *rm, const int *tgts, const int cnt)
 {
-	for (int r = 0; r < rm->rm_nrows; r++) {
-		raidz_row_t *rr = rm->rm_row[r];
-		for (int i = 0; i < cnt; i++) {
-			raidz_col_t *col = &rr->rr_col[tgts[i]];
-			abd_iterate_func(col->rc_abd, 0, col->rc_size,
-			    init_rand, NULL);
-		}
+	int i;
+	raidz_col_t *col;
+
+	for (i = 0; i < cnt; i++) {
+		col = &rm->rm_col[tgts[i]];
+		abd_iterate_func(col->rc_abd, 0, col->rc_size, init_rand, NULL);
 	}
 }

@@ -322,22 +288,10 @@ init_raidz_golden_map(raidz_test_opts_t *opts, const int parity)

 	VERIFY0(vdev_raidz_impl_set("original"));

-	if (opts->rto_expand) {
-		opts->rm_golden =
-		    vdev_raidz_map_alloc_expanded(opts->zio_golden->io_abd,
-		    opts->zio_golden->io_size, opts->zio_golden->io_offset,
-		    opts->rto_ashift, total_ncols+1, total_ncols,
-		    parity, opts->rto_expand_offset);
-		rm_test = vdev_raidz_map_alloc_expanded(zio_test->io_abd,
-		    zio_test->io_size, zio_test->io_offset,
-		    opts->rto_ashift, total_ncols+1, total_ncols,
-		    parity, opts->rto_expand_offset);
-	} else {
-		opts->rm_golden = vdev_raidz_map_alloc(opts->zio_golden,
-		    opts->rto_ashift, total_ncols, parity);
-		rm_test = vdev_raidz_map_alloc(zio_test,
-		    opts->rto_ashift, total_ncols, parity);
-	}
+	opts->rm_golden = vdev_raidz_map_alloc(opts->zio_golden,
+	    opts->rto_ashift, total_ncols, parity);
+	rm_test = vdev_raidz_map_alloc(zio_test,
+	    opts->rto_ashift, total_ncols, parity);

 	VERIFY(opts->zio_golden);
 	VERIFY(opts->rm_golden);
@@ -358,187 +312,6 @@ init_raidz_golden_map(raidz_test_opts_t *opts, const int parity)
 	return (err);
 }

-/*
- * If reflow is not in progress, reflow_offset should be UINT64_MAX.
- * For each row, if the row is entirely before reflow_offset, it will
- * come from the new location.  Otherwise this row will come from the
- * old location.  Therefore, rows that straddle the reflow_offset will
- * come from the old location.
- *
- * NOTE: Until raidz expansion is implemented this function is only
- * needed by raidz_test.c to the multi-row raid_map_t functionality.
- */
-raidz_map_t *
-vdev_raidz_map_alloc_expanded(abd_t *abd, uint64_t size, uint64_t offset,
-    uint64_t ashift, uint64_t physical_cols, uint64_t logical_cols,
-    uint64_t nparity, uint64_t reflow_offset)
-{
-	/* The zio's size in units of the vdev's minimum sector size. */
-	uint64_t s = size >> ashift;
-	uint64_t q, r, bc, devidx, asize = 0, tot;
-
-	/*
-	 * "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"
-	 */
-	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.
-	 */
-	r = s - q * (logical_cols - nparity);
-
-	/* The number of "big columns" - those which contain remainder data. */
-	bc = (r == 0 ? 0 : r + nparity);
-
-	/*
-	 * The total number of data and parity sectors associated with
-	 * this I/O.
-	 */
-	tot = s + nparity * (q + (r == 0 ? 0 : 1));
-
-	/* 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;
-
-	for (uint64_t row = 0; row < rows; row++) {
-		raidz_row_t *rr = kmem_alloc(offsetof(raidz_row_t,
-		    rr_col[cols]), KM_SLEEP);
-		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 any part of this
-		 * row has not been copied, then use the old location of
-		 * this row.
-		 */
-		int row_phys_cols = physical_cols;
-		if (b + (logical_cols - nparity) > reflow_offset >> ashift)
-			row_phys_cols--;
-
-		/* 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;
-
-		/*
-		 * We set cols to 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_cols = cols;
-		rr->rr_bigcols = bc;
-		rr->rr_missingdata = 0;
-		rr->rr_missingparity = 0;
-		rr->rr_firstdatacol = nparity;
-		rr->rr_abd_empty = NULL;
-		rr->rr_nempty = 0;
-
-		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;
-			}
-			rr->rr_col[c].rc_devidx = child_id;
-			rr->rr_col[c].rc_offset = child_offset;
-			rr->rr_col[c].rc_orig_data = NULL;
-			rr->rr_col[c].rc_error = 0;
-			rr->rr_col[c].rc_tried = 0;
-			rr->rr_col[c].rc_skipped = 0;
-			rr->rr_col[c].rc_need_orig_restore = B_FALSE;
-
-			uint64_t dc = c - rr->rr_firstdatacol;
-			if (c < rr->rr_firstdatacol) {
-				rr->rr_col[c].rc_size = 1ULL << ashift;
-				rr->rr_col[c].rc_abd =
-				    abd_alloc_linear(rr->rr_col[c].rc_size,
-				    B_TRUE);
-			} else if (row == rows - 1 && bc != 0 && c >= bc) {
-				/*
-				 * Past the end, this for parity generation.
-				 */
-				rr->rr_col[c].rc_size = 0;
-				rr->rr_col[c].rc_abd = NULL;
-			} else {
-				/*
-				 * "data column" (col excluding parity)
-				 * Add an ASCII art diagram here
-				 */
-				uint64_t off;
-
-				if (c < bc || r == 0) {
-					off = dc * rows + row;
-				} else {
-					off = r * rows +
-					    (dc - r) * (rows - 1) + row;
-				}
-				rr->rr_col[c].rc_size = 1ULL << ashift;
-				rr->rr_col[c].rc_abd = abd_get_offset_struct(
-				    &rr->rr_col[c].rc_abdstruct,
-				    abd, off << ashift, 1 << ashift);
-			}
-
-			asize += rr->rr_col[c].rc_size;
-		}
-		/*
-		 * If all data stored spans all columns, there's a danger that
-		 * parity will always be on the same device and, since parity
-		 * isn't read during normal operation, that 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.
-		 */
-		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);
-			devidx = rr->rr_col[0].rc_devidx;
-			uint64_t 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;
-		}
-
-	}
-	ASSERT3U(asize, ==, tot << ashift);
-
-	/* init RAIDZ parity ops */
-	rm->rm_ops = vdev_raidz_math_get_ops();
-
-	return (rm);
-}
-
 static raidz_map_t *
 init_raidz_map(raidz_test_opts_t *opts, zio_t **zio, const int parity)
 {
@@ -557,15 +330,8 @@ init_raidz_map(raidz_test_opts_t *opts, zio_t **zio, const int parity)
 	(*zio)->io_abd = raidz_alloc(alloc_dsize);
 	init_zio_abd(*zio);

-	if (opts->rto_expand) {
-		rm = vdev_raidz_map_alloc_expanded((*zio)->io_abd,
-		    (*zio)->io_size, (*zio)->io_offset,
-		    opts->rto_ashift, total_ncols+1, total_ncols,
-		    parity, opts->rto_expand_offset);
-	} else {
-		rm = vdev_raidz_map_alloc(*zio, opts->rto_ashift,
-		    total_ncols, parity);
-	}
+	rm = vdev_raidz_map_alloc(*zio, opts->rto_ashift,
+	    total_ncols, parity);
 	VERIFY(rm);

 	/* Make sure code columns are destroyed */
@@ -654,7 +420,7 @@ run_rec_check_impl(raidz_test_opts_t *opts, raidz_map_t *rm, const int fn)
 	if (fn < RAIDZ_REC_PQ) {
 		/* can reconstruct 1 failed data disk */
 		for (x0 = 0; x0 < opts->rto_dcols; x0++) {
-			if (x0 >= rm->rm_row[0]->rr_cols - raidz_parity(rm))
+			if (x0 >= rm->rm_cols - raidz_parity(rm))
 				continue;

 			/* Check if should stop */
@@ -679,11 +445,10 @@ run_rec_check_impl(raidz_test_opts_t *opts, raidz_map_t *rm, const int fn)
 	} else if (fn < RAIDZ_REC_PQR) {
 		/* can reconstruct 2 failed data disk */
 		for (x0 = 0; x0 < opts->rto_dcols; x0++) {
-			if (x0 >= rm->rm_row[0]->rr_cols - raidz_parity(rm))
+			if (x0 >= rm->rm_cols - raidz_parity(rm))
 				continue;
 			for (x1 = x0 + 1; x1 < opts->rto_dcols; x1++) {
-				if (x1 >= rm->rm_row[0]->rr_cols -
-				    raidz_parity(rm))
+				if (x1 >= rm->rm_cols - raidz_parity(rm))
 					continue;

 				/* Check if should stop */
@@ -710,15 +475,14 @@ run_rec_check_impl(raidz_test_opts_t *opts, raidz_map_t *rm, const int fn)
 	} else {
 		/* can reconstruct 3 failed data disk */
 		for (x0 = 0; x0 < opts->rto_dcols; x0++) {
-			if (x0 >= rm->rm_row[0]->rr_cols - raidz_parity(rm))
+			if (x0 >= rm->rm_cols - raidz_parity(rm))
 				continue;
 			for (x1 = x0 + 1; x1 < opts->rto_dcols; x1++) {
-				if (x1 >= rm->rm_row[0]->rr_cols -
-				    raidz_parity(rm))
+				if (x1 >= rm->rm_cols - raidz_parity(rm))
 					continue;
 				for (x2 = x1 + 1; x2 < opts->rto_dcols; x2++) {
-					if (x2 >= rm->rm_row[0]->rr_cols -
-					    raidz_parity(rm))
+					if (x2 >=
+					    rm->rm_cols - raidz_parity(rm))
 						continue;

 					/* Check if should stop */
@@ -936,8 +700,6 @@ run_sweep(void)
 		opts->rto_dcols = dcols_v[d];
 		opts->rto_offset = (1 << ashift_v[a]) * rand();
 		opts->rto_dsize = size_v[s];
-		opts->rto_expand = rto_opts.rto_expand;
-		opts->rto_expand_offset = rto_opts.rto_expand_offset;
 		opts->rto_v = 0; /* be quiet */

 		VERIFY3P(thread_create(NULL, 0, sweep_thread, (void *) opts,
@@ -970,7 +732,6 @@ exit:
 	return (sweep_state == SWEEP_ERROR ? SWEEP_ERROR : 0);
 }

-
 int
 main(int argc, char **argv)
 {
@@ -44,15 +44,13 @@ static const char *raidz_impl_names[] = {

 typedef struct raidz_test_opts {
 	size_t rto_ashift;
-	uint64_t rto_offset;
+	size_t rto_offset;
 	size_t rto_dcols;
 	size_t rto_dsize;
 	size_t rto_v;
 	size_t rto_sweep;
 	size_t rto_sweep_timeout;
 	size_t rto_benchmark;
-	size_t rto_expand;
-	uint64_t rto_expand_offset;
 	size_t rto_sanity;
 	size_t rto_gdb;

@@ -71,8 +69,6 @@ static const raidz_test_opts_t rto_opts_defaults = {
 	.rto_v = 0,
 	.rto_sweep = 0,
 	.rto_benchmark = 0,
-	.rto_expand = 0,
-	.rto_expand_offset = -1ULL,
 	.rto_sanity = 0,
 	.rto_gdb = 0,
 	.rto_should_stop = B_FALSE
@@ -117,7 +113,4 @@ void init_zio_abd(zio_t *zio);

 void run_raidz_benchmark(void);

-struct raidz_map *vdev_raidz_map_alloc_expanded(abd_t *, uint64_t, uint64_t,
-    uint64_t, uint64_t, uint64_t, uint64_t, uint64_t);
-
 #endif /* RAIDZ_TEST_H */
@@ -1,3 +1 @@
-include $(top_srcdir)/config/Shellcheck.am
-
 dist_udev_SCRIPTS = vdev_id
@@ -79,34 +79,6 @@
 # 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
 # #
@@ -120,10 +92,9 @@ PATH=/bin:/sbin:/usr/bin:/usr/sbin
 CONFIG=/etc/zfs/vdev_id.conf
 PHYS_PER_PORT=
 DEV=
+MULTIPATH=
 TOPOLOGY=
 BAY=
-ENCL_ID=""
-UNIQ_ENCL_ID=""

 usage() {
 	cat << EOF
@@ -136,25 +107,22 @@ Usage: vdev_id [-h]
  -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
+	exit 0
 }

 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)
+	MAPPED_SLOT=`awk "\\$1 == \"slot\" && \\$2 == ${LINUX_SLOT} && \
+			\\$4 ~ /^${CHANNEL}$|^$/ { print \\$3; exit }" $CONFIG`
 	if [ -z "$MAPPED_SLOT" ] ; then
 		MAPPED_SLOT=$LINUX_SLOT
 	fi
-	printf "%d" "${MAPPED_SLOT}"
+	printf "%d" ${MAPPED_SLOT}
 }

 map_channel() {
@@ -164,120 +132,40 @@ map_channel() {

 	case $TOPOLOGY in
 		"sas_switch")
-		MAPPED_CHAN=$(awk -v port="$PORT" \
-			'$1 == "channel" && $2 == port \
-			{ print $3; exit }' $CONFIG)
+		MAPPED_CHAN=`awk "\\$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)
+		MAPPED_CHAN=`awk "\\$1 == \"channel\" && \
+			\\$2 == \"${PCI_ID}\" && \\$3 == ${PORT} \
+			{ print \\$4; exit }" $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}"
+	printf "%s" ${MAPPED_CHAN}
 }

 sas_handler() {
 	if [ -z "$PHYS_PER_PORT" ] ; then
-		PHYS_PER_PORT=$(awk '$1 == "phys_per_port" \
-			{print $2; exit}' $CONFIG)
+		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
+	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)
+		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}')
+			DM_NAME=`ls -l --full-time /dev/mapper |
+				awk "/\/$DEV$/{print \\$9}"`
 		fi

 		# For raw disks udev exports DEVTYPE=partition when
@@ -287,50 +175,28 @@ sas_handler() {
 		# 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)}')
+			PART=`echo $DM_NAME | awk -Fp '/p/{print "-part"$2}'`
 		fi

 		# Strip off partition information.
-		DM_NAME=$(echo "$DM_NAME" | sed 's/p[0-9][0-9]*$//')
+		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)
-			}')
-
+		# 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
+	if echo $DEV | grep -q ^/devices/ ; then
 		sys_path=$DEV
 	else
-		sys_path=$(udevadm info -q path -p "/sys/block/$DEV" 2>/dev/null)
+		sys_path=`udevadm info -q path -p /sys/block/$DEV 2>/dev/null`
 	fi

 	# Use positional parameters as an ad-hoc array
@@ -340,104 +206,84 @@ sas_handler() {

 	# Get path up to /sys/.../hostX
 	i=1
-
-	while [ $i -le "$num_dirs" ] ; do
-		d=$(eval echo '$'{$i})
+	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))
+		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
+	if [ $i = $num_dirs ] ; then
 		return
 	fi

-	PCI_ID=$(eval echo '$'{$((i -1))} | awk -F: '{print $2":"$3}')
+	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)) ;;
+		"sas_switch") j=$(($i + 4)) ;;
+		"sas_direct") j=$(($i + 1)) ;;
 	esac

-	i=$((i + 1))
-
+	i=$(($i + 1))
 	while [ $i -le $j ] ; do
-		port_dir="$port_dir/$(eval echo '$'{$i})"
-		i=$((i + 1))
+		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}')
+	PHY=`ls -d $port_dir/phy* 2>/dev/null | head -1 | awk -F: '{print $NF}'`
 	if [ -z "$PHY" ] ; then
 		PHY=0
 	fi
-	PORT=$((PHY / PHYS_PER_PORT))
+	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})
+	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
+		if echo $d | grep -q '^end_device' ; then
 			end_device_dir="$end_device_dir/sas_device/$d"
 			break
 		fi
-		i=$((i + 1))
+		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
+		SLOT=`cat $end_device_dir/bay_identifier 2>/dev/null`
 		;;
 	"phy")
-		SLOT=$(cat "$end_device_dir/phy_identifier" 2>/dev/null)
+		SLOT=`cat $end_device_dir/phy_identifier 2>/dev/null`
 		;;
 	"port")
-		d=$(eval echo '$'{$i})
-		SLOT=$(echo "$d" | sed -e 's/^.*://')
+		d=$(eval echo \${$i})
+		SLOT=`echo $d | sed -e 's/^.*://'`
 		;;
 	"id")
-		i=$((i + 1))
-		d=$(eval echo '$'{$i})
-		SLOT=$(echo "$d" | sed -e 's/^.*://')
+		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/^.*://')
+		i=$(($i + 2))
+		d=$(eval echo \${$i})
+		SLOT=`echo $d | sed -e 's/^.*://'`
 		;;
 	"ses")
 		# look for this SAS path in all SCSI Enclosure Services
 		# (SES) enclosures
-		sas_address=$(cat "$end_device_dir/sas_address" 2>/dev/null)
-		enclosures=$(lsscsi -g | \
-			sed -n -e '/enclosu/s/^.* \([^ ][^ ]*\) *$/\1/p')
+		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" | \
+			set -- $(sg_ses -p aes $enclosure | \
 				awk "/device slot number:/{slot=\$12} \
 					/SAS address: $sas_address/\
 					{print slot}")
@@ -452,55 +298,42 @@ sas_handler() {
 		return
 	fi

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

 scsi_handler() {
 	if [ -z "$FIRST_BAY_NUMBER" ] ; then
-		FIRST_BAY_NUMBER=$(awk '$1 == "first_bay_number" \
-			{print $2; exit}' $CONFIG)
+		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)
+		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
+	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)
+		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}')
+			DM_NAME=`ls -l --full-time /dev/mapper |
+				awk "/\/$DEV$/{print \\$9}"`
 		fi

 		# For raw disks udev exports DEVTYPE=partition when
@@ -510,30 +343,28 @@ scsi_handler() {
 		# 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)}')
+			PART=`echo $DM_NAME | awk -Fp '/p/{print "-part"$2}'`
 		fi

 		# Strip off partition information.
-		DM_NAME=$(echo "$DM_NAME" | sed 's/p[0-9][0-9]*$//')
+		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}')
+		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
+	if echo $DEV | grep -q ^/devices/ ; then
 		sys_path=$DEV
 	else
-		sys_path=$(udevadm info -q path -p "/sys/block/$DEV" 2>/dev/null)
+		sys_path=`udevadm info -q path -p /sys/block/$DEV 2>/dev/null`
 	fi

 	# expect sys_path like this, for example:
@@ -546,47 +377,44 @@ scsi_handler() {

 	# Get path up to /sys/.../hostX
 	i=1
-
-	while [ $i -le "$num_dirs" ] ; do
-		d=$(eval echo '$'{$i})
+	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))
+		echo $d | grep -q -E '^host[0-9]+$' && break
+		i=$(($i + 1))
 	done

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

-	PCI_ID=$(eval echo '$'{$((i -1))} | awk -F: '{print $2":"$3}')
+	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))
+	j=$(($i + 2))

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

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

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

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

 # Figure out the name for the enclosure symlink
@@ -596,10 +424,8 @@ enclosure_handler () {
 	# 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
+	ENC=$(basename $(readlink -m "/sys/$DEVPATH/../.."))
+	if [ ! -d /sys/class/enclosure/$ENC ] ; then
 		# Not an enclosure, bail out
 		return
 	fi
@@ -607,26 +433,25 @@ enclosure_handler () {
 	# 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")
+	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]+')
+	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]+$")
+	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##*/}"
+	PCI_ID_LONG=$(basename $(readlink -m "/sys/$PORT_DIR/../.."))

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

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

 	echo "${NAME}"
 }
@@ -662,11 +487,9 @@ alias_handler () {
 	#          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 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)}')
+			DM_PART=`echo $DM_NAME | awk -Fp '/p/{print "-part"$2}'`
 		fi
 	fi

@@ -674,25 +497,21 @@ alias_handler () {
 	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]*$//')
+			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
+		for l in $link `basename $link` ; do
+			alias=`awk "\\$1 == \"alias\" && \\$3 == \"${l}\" \
+					{ print \\$2; exit }" $CONFIG`
+			if [ -n "$alias" ] ; then
+				echo ${alias}${DM_PART}
+				return
 			fi
 		done
 	done
 }

-# main
-while getopts 'c:d:eg:jmp:h' OPTION; do
+while getopts 'c:d:eg:mp:h' OPTION; do
 	case ${OPTION} in
 	c)
 		CONFIG=${OPTARG}
@@ -705,9 +524,7 @@ while getopts 'c:d:eg:jmp:h' OPTION; do
 	# 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")
-
+	ENCLOSURE_MODE=$(awk '{if ($1 == "enclosure_symlinks") print $2}' $CONFIG)
 	if [ "$ENCLOSURE_MODE" != "yes" ] ; then
 		exit 0
 	fi
@@ -718,9 +535,6 @@ while getopts 'c:d:eg:jmp:h' OPTION; do
 	p)
 		PHYS_PER_PORT=${OPTARG}
 		;;
-	j)
-		MULTIJBOD_MODE=yes
-		;;
 	m)
 		MULTIPATH_MODE=yes
 		;;
@@ -730,9 +544,8 @@ while getopts 'c:d:eg:jmp:h' OPTION; do
 	esac
 done

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

 if [ -z "$DEV" ] && [ -z "$ENCLOSURE_MODE" ] ; then
@@ -741,11 +554,11 @@ if [ -z "$DEV" ] && [ -z "$ENCLOSURE_MODE" ] ; then
 fi

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

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

 TOPOLOGY=${TOPOLOGY:-sas_direct}
@@ -758,7 +571,7 @@ if [ "$ENCLOSURE_MODE" = "yes" ] && [ "$TOPOLOGY" = "sas_direct" ] ; then
 	fi

 	# Just create the symlinks to the enclosure devices and then exit.
-	ENCLOSURE_PREFIX=$(awk '/enclosure_symlinks_prefix/{print $2}' "$CONFIG")
+	ENCLOSURE_PREFIX=$(awk '/enclosure_symlinks_prefix/{print $2}' $CONFIG)
 	if [ -z "$ENCLOSURE_PREFIX" ] ; then
 		ENCLOSURE_PREFIX="enc"
 	fi
@@ -768,16 +581,16 @@ if [ "$ENCLOSURE_MODE" = "yes" ] && [ "$TOPOLOGY" = "sas_direct" ] ; then
 fi

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

 if [ -z "$ID_VDEV" ] ; then
 	BAY=${BAY:-bay}
 	case $TOPOLOGY in
 		sas_direct|sas_switch)
-			ID_VDEV=$(sas_handler)
+			ID_VDEV=`sas_handler`
 			;;
 		scsi)
-			ID_VDEV=$(scsi_handler)
+			ID_VDEV=`scsi_handler`
 			;;
 		*)
 			echo "Error: unknown topology $TOPOLOGY"
@@ -14,5 +14,3 @@ zdb_LDADD = \
 	$(abs_top_builddir)/lib/libzpool/libzpool.la \
 	$(abs_top_builddir)/lib/libzfs_core/libzfs_core.la \
 	$(abs_top_builddir)/lib/libnvpair/libnvpair.la
-
-include $(top_srcdir)/config/CppCheck.am
@@ -31,7 +31,6 @@
 *
 * [1] Portions of this software were developed by Allan Jude
 *     under sponsorship from the FreeBSD Foundation.
- * Copyright (c) 2021 Allan Jude
 */

 #include <stdio.h>
@@ -110,9 +109,8 @@ extern int zfs_recover;
 extern unsigned long zfs_arc_meta_min, zfs_arc_meta_limit;
 extern int zfs_vdev_async_read_max_active;
 extern boolean_t spa_load_verify_dryrun;
-extern boolean_t spa_mode_readable_spacemaps;
 extern int zfs_reconstruct_indirect_combinations_max;
-extern uint_t zfs_btree_verify_intensity;
+extern int zfs_btree_verify_intensity;

 static const char cmdname[] = "zdb";
 uint8_t dump_opt[256];
@@ -163,6 +161,12 @@ static int dump_bpobj_cb(void *arg, const blkptr_t *bp, boolean_t free,
    dmu_tx_t *tx);

 typedef struct sublivelist_verify {
+	/* all ALLOC'd blkptr_t in one sub-livelist */
+	zfs_btree_t sv_all_allocs;
+
+	/* all FREE'd blkptr_t in one sub-livelist */
+	zfs_btree_t sv_all_frees;
+
 	/* FREE's that haven't yet matched to an ALLOC, in one sub-livelist */
 	zfs_btree_t sv_pair;

@@ -221,68 +225,29 @@ typedef struct sublivelist_verify_block {

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

-typedef struct sublivelist_verify_block_refcnt {
-	/* block pointer entry in livelist being verified */
-	blkptr_t svbr_blk;
-
-	/*
-	 * Refcount gets incremented to 1 when we encounter the first
-	 * FREE entry for the svfbr block pointer and a node for it
-	 * is created in our ZDB verification/tracking metadata.
-	 *
-	 * As we encounter more FREE entries we increment this counter
-	 * and similarly decrement it whenever we find the respective
-	 * ALLOC entries for this block.
-	 *
-	 * When the refcount gets to 0 it means that all the FREE and
-	 * ALLOC entries of this block have paired up and we no longer
-	 * need to track it in our verification logic (e.g. the node
-	 * containing this struct in our verification data structure
-	 * should be freed).
-	 *
-	 * [refer to sublivelist_verify_blkptr() for the actual code]
-	 */
-	uint32_t svbr_refcnt;
-} sublivelist_verify_block_refcnt_t;
-
-static int
-sublivelist_block_refcnt_compare(const void *larg, const void *rarg)
-{
-	const sublivelist_verify_block_refcnt_t *l = larg;
-	const sublivelist_verify_block_refcnt_t *r = rarg;
-	return (livelist_compare(&l->svbr_blk, &r->svbr_blk));
-}
-
 static int
 sublivelist_verify_blkptr(void *arg, const blkptr_t *bp, boolean_t free,
    dmu_tx_t *tx)
 {
 	ASSERT3P(tx, ==, NULL);
 	struct sublivelist_verify *sv = arg;
-	sublivelist_verify_block_refcnt_t current = {
-			.svbr_blk = *bp,
-
-			/*
-			 * Start with 1 in case this is the first free entry.
-			 * This field is not used for our B-Tree comparisons
-			 * anyway.
-			 */
-			.svbr_refcnt = 1,
-	};
-
+	char blkbuf[BP_SPRINTF_LEN];
 	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);
+		zfs_btree_add(&sv->sv_pair, bp);
+		/* Check if the FREE is a duplicate */
+		if (zfs_btree_find(&sv->sv_all_frees, bp, &where) != NULL) {
+			snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), bp,
+			    free);
+			(void) printf("\tERROR: Duplicate FREE: %s\n", blkbuf);
 		} else {
-			pair->svbr_refcnt++;
+			zfs_btree_add_idx(&sv->sv_all_frees, bp, &where);
 		}
 	} else {
-		if (pair == NULL) {
-			/* block that is currently marked as allocated */
+		/* Check if the ALLOC has been freed */
+		if (zfs_btree_find(&sv->sv_pair, bp, &where) != NULL) {
+			zfs_btree_remove_idx(&sv->sv_pair, &where);
+		} else {
 			for (int i = 0; i < SPA_DVAS_PER_BP; i++) {
 				if (DVA_IS_EMPTY(&bp->blk_dva[i]))
 					break;
@@ -297,16 +262,16 @@ sublivelist_verify_blkptr(void *arg, const blkptr_t *bp, boolean_t free,
 					    &svb, &where);
 				}
 			}
+		}
+		/* Check if the ALLOC is a duplicate */
+		if (zfs_btree_find(&sv->sv_all_allocs, bp, &where) != NULL) {
+			snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), bp,
+			    free);
+			(void) printf("\tERROR: Duplicate ALLOC: %s\n", blkbuf);
 		} else {
-			/* 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);
-			}
+			zfs_btree_add_idx(&sv->sv_all_allocs, bp, &where);
 		}
 	}
-
 	return (0);
 }

@@ -314,22 +279,32 @@ static int
 sublivelist_verify_func(void *args, dsl_deadlist_entry_t *dle)
 {
 	int err;
+	char blkbuf[BP_SPRINTF_LEN];
 	struct sublivelist_verify *sv = args;

-	zfs_btree_create(&sv->sv_pair, sublivelist_block_refcnt_compare,
-	    sizeof (sublivelist_verify_block_refcnt_t));
+	zfs_btree_create(&sv->sv_all_allocs, livelist_compare,
+	    sizeof (blkptr_t));
+
+	zfs_btree_create(&sv->sv_all_frees, livelist_compare,
+	    sizeof (blkptr_t));
+
+	zfs_btree_create(&sv->sv_pair, livelist_compare,
+	    sizeof (blkptr_t));

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

-	sublivelist_verify_block_refcnt_t *e;
+	zfs_btree_clear(&sv->sv_all_allocs);
+	zfs_btree_destroy(&sv->sv_all_allocs);
+
+	zfs_btree_clear(&sv->sv_all_frees);
+	zfs_btree_destroy(&sv->sv_all_frees);
+
+	blkptr_t *e;
 	zfs_btree_index_t *cookie = NULL;
 	while ((e = zfs_btree_destroy_nodes(&sv->sv_pair, &cookie)) != NULL) {
-		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);
+		snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), e, B_TRUE);
+		(void) printf("\tERROR: Unmatched FREE: %s\n", blkbuf);
 	}
 	zfs_btree_destroy(&sv->sv_pair);

@@ -638,14 +613,10 @@ mv_populate_livelist_allocs(metaslab_verify_t *mv, sublivelist_verify_t *sv)
 /*
 * [Livelist Check]
 * Iterate through all the sublivelists and:
- * - report leftover frees (**)
+ * - report leftover frees
+ * - report double ALLOCs/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
@@ -784,14 +755,13 @@ usage(void)
 	    "\t%s -m [-AFLPX] [-e [-V] [-p <path> ...]] [-t <txg>] "
 	    "[-U <cache>]\n\t\t<poolname> [<vdev> [<metaslab> ...]]\n"
 	    "\t%s -O <dataset> <path>\n"
-	    "\t%s -r <dataset> <path> <destination>\n"
 	    "\t%s -R [-A] [-e [-V] [-p <path> ...]] [-U <cache>]\n"
 	    "\t\t<poolname> <vdev>:<offset>:<size>[:<flags>]\n"
 	    "\t%s -E [-A] word0:word1:...:word15\n"
 	    "\t%s -S [-AP] [-e [-V] [-p <path> ...]] [-U <cache>] "
 	    "<poolname>\n\n",
 	    cmdname, cmdname, cmdname, cmdname, cmdname, cmdname, cmdname,
-	    cmdname, cmdname, cmdname, cmdname);
+	    cmdname, cmdname, cmdname);

 	(void) fprintf(stderr, "    Dataset name must include at least one "
 	    "separator character '/' or '@'\n");
@@ -830,7 +800,6 @@ usage(void)
 	(void) fprintf(stderr, "        -m metaslabs\n");
 	(void) fprintf(stderr, "        -M metaslab groups\n");
 	(void) fprintf(stderr, "        -O perform object lookups by path\n");
-	(void) fprintf(stderr, "        -r copy an object by path to file\n");
 	(void) fprintf(stderr, "        -R read and display block from a "
 	    "device\n");
 	(void) fprintf(stderr, "        -s report stats on zdb's I/O\n");
@@ -1673,11 +1642,7 @@ dump_metaslab(metaslab_t *msp)
 		    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);
-
+	ASSERT(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)) {
@@ -2219,8 +2184,7 @@ snprintf_zstd_header(spa_t *spa, char *blkbuf, size_t buflen,
 		(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));
+		    zstd_hdr.c_len, zstd_hdr.version, zstd_hdr.level);
 		return;
 	}

@@ -2244,8 +2208,7 @@ snprintf_zstd_header(spa_t *spa, char *blkbuf, size_t buflen,
 	(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));
+	    zstd_hdr.c_len, zstd_hdr.version, zstd_hdr.level);

 	abd_return_buf_copy(pabd, buf, BP_GET_LSIZE(bp));
 }
@@ -3125,18 +3088,13 @@ dump_znode_symlink(sa_handle_t *hdl)
 {
 	int sa_symlink_size = 0;
 	char linktarget[MAXPATHLEN];
+	linktarget[0] = '\0';
 	int error;

 	error = sa_size(hdl, sa_attr_table[ZPL_SYMLINK], &sa_symlink_size);
 	if (error || sa_symlink_size == 0) {
 		return;
 	}
-	if (sa_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);
@@ -4102,7 +4060,7 @@ 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;
+	int difference;

 	for (int i = 0; i < arraysize; i++) {
 		difference = TREE_CMP(l->cksum.zc_word[i], r->cksum.zc_word[i]);
@@ -4244,8 +4202,6 @@ dump_l2arc_log_entries(uint64_t log_entries,
 		    (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");
@@ -4528,7 +4484,7 @@ static char curpath[PATH_MAX];
 * for the last one.
 */
 static int
-dump_path_impl(objset_t *os, uint64_t obj, char *name, uint64_t *retobj)
+dump_path_impl(objset_t *os, uint64_t obj, char *name)
 {
 	int err;
 	boolean_t header = B_TRUE;
@@ -4578,15 +4534,10 @@ dump_path_impl(objset_t *os, uint64_t obj, char *name, uint64_t *retobj)
 	switch (doi.doi_type) {
 	case DMU_OT_DIRECTORY_CONTENTS:
 		if (s != NULL && *(s + 1) != '\0')
-			return (dump_path_impl(os, child_obj, s + 1, retobj));
-		fallthrough;
+			return (dump_path_impl(os, child_obj, s + 1));
+		/*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);
-		}
+		dump_object(os, child_obj, dump_opt['v'], &header, NULL, 0);
 		return (0);
 	default:
 		(void) fprintf(stderr, "object %llu has non-file/directory "
@@ -4601,7 +4552,7 @@ dump_path_impl(objset_t *os, uint64_t obj, char *name, uint64_t *retobj)
 * Dump the blocks for the object specified by path inside the dataset.
 */
 static int
-dump_path(char *ds, char *path, uint64_t *retobj)
+dump_path(char *ds, char *path)
 {
 	int err;
 	objset_t *os;
@@ -4621,89 +4572,12 @@ dump_path(char *ds, char *path, uint64_t *retobj)

 	(void) snprintf(curpath, sizeof (curpath), "dataset=%s path=/", ds);

-	err = dump_path_impl(os, root_obj, path, retobj);
+	err = dump_path_impl(os, root_obj, path);

 	close_objset(os, FTAG);
 	return (err);
 }

-static int
-zdb_copy_object(objset_t *os, uint64_t srcobj, char *destfile)
-{
-	int err = 0;
-	uint64_t size, readsize, oursize, offset;
-	ssize_t writesize;
-	sa_handle_t *hdl;
-
-	(void) printf("Copying object %" PRIu64 " to file %s\n", srcobj,
-	    destfile);
-
-	VERIFY3P(os, ==, sa_os);
-	if ((err = sa_handle_get(os, srcobj, NULL, SA_HDL_PRIVATE, &hdl))) {
-		(void) printf("Failed to get handle for SA znode\n");
-		return (err);
-	}
-	if ((err = sa_lookup(hdl, sa_attr_table[ZPL_SIZE], &size, 8))) {
-		(void) sa_handle_destroy(hdl);
-		return (err);
-	}
-	(void) sa_handle_destroy(hdl);
-
-	(void) printf("Object %" PRIu64 " is %" PRIu64 " bytes\n", srcobj,
-	    size);
-	if (size == 0) {
-		return (EINVAL);
-	}
-
-	int fd = open(destfile, O_WRONLY | O_CREAT | O_TRUNC, 0644);
-	/*
-	 * We cap the size at 1 mebibyte here to prevent
-	 * allocation failures and nigh-infinite printing if the
-	 * object is extremely large.
-	 */
-	oursize = MIN(size, 1 << 20);
-	offset = 0;
-	char *buf = kmem_alloc(oursize, KM_NOSLEEP);
-	if (buf == NULL) {
-		return (ENOMEM);
-	}
-
-	while (offset < size) {
-		readsize = MIN(size - offset, 1 << 20);
-		err = dmu_read(os, srcobj, offset, readsize, buf, 0);
-		if (err != 0) {
-			(void) printf("got error %u from dmu_read\n", err);
-			kmem_free(buf, oursize);
-			return (err);
-		}
-		if (dump_opt['v'] > 3) {
-			(void) printf("Read offset=%" PRIu64 " size=%" PRIu64
-			    " error=%d\n", offset, readsize, err);
-		}
-
-		writesize = write(fd, buf, readsize);
-		if (writesize < 0) {
-			err = errno;
-			break;
-		} else if (writesize != readsize) {
-			/* Incomplete write */
-			(void) fprintf(stderr, "Short write, only wrote %llu of"
-			    " %" PRIu64 " bytes, exiting...\n",
-			    (u_longlong_t)writesize, readsize);
-			break;
-		}
-
-		offset += readsize;
-	}
-
-	(void) close(fd);
-
-	if (buf != NULL)
-		kmem_free(buf, oursize);
-
-	return (err);
-}
-
 static int
 dump_label(const char *dev)
 {
@@ -5327,6 +5201,8 @@ zdb_blkptr_done(zio_t *zio)
 	zdb_cb_t *zcb = zio->io_private;
 	zbookmark_phys_t *zb = &zio->io_bookmark;

+	abd_free(zio->io_abd);
+
 	mutex_enter(&spa->spa_scrub_lock);
 	spa->spa_load_verify_bytes -= BP_GET_PSIZE(bp);
 	cv_broadcast(&spa->spa_scrub_io_cv);
@@ -5353,8 +5229,6 @@ zdb_blkptr_done(zio_t *zio)
 		    blkbuf);
 	}
 	mutex_exit(&spa->spa_scrub_lock);
-
-	abd_free(zio->io_abd);
 }

 static int
@@ -5964,11 +5838,9 @@ zdb_leak_init_prepare_indirect_vdevs(spa_t *spa, zdb_cb_t *zcb)
 		 * 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;
+		vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
 		uint64_t vim_idx = 0;
 		for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {

@@ -6004,7 +5876,6 @@ zdb_leak_init(spa_t *spa, zdb_cb_t *zcb)
 	 */
 	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 *),
@@ -6138,6 +6009,7 @@ zdb_leak_fini(spa_t *spa, zdb_cb_t *zcb)
 	vdev_t *rvd = spa->spa_root_vdev;
 	for (unsigned c = 0; c < rvd->vdev_children; c++) {
 		vdev_t *vd = rvd->vdev_child[c];
+		metaslab_group_t *mg __maybe_unused = vd->vdev_mg;

 		if (zcb->zcb_vd_obsolete_counts[c] != NULL) {
 			leaks |= zdb_check_for_obsolete_leaks(vd, zcb);
@@ -6145,9 +6017,7 @@ zdb_leak_fini(spa_t *spa, zdb_cb_t *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);
+			ASSERT3P(mg, ==, msp->ms_group);

 			/*
 			 * ms_allocatable has been overloaded
@@ -6354,8 +6224,6 @@ dump_block_stats(spa_t *spa)
 	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);

@@ -6403,7 +6271,6 @@ dump_block_stats(spa_t *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);
@@ -6449,7 +6316,7 @@ dump_block_stats(spa_t *spa)
 	(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) {
+	if (spa_special_class(spa)->mc_rotor != NULL) {
 		uint64_t alloc = metaslab_class_get_alloc(
 		    spa_special_class(spa));
 		uint64_t space = metaslab_class_get_space(
@@ -6460,7 +6327,7 @@ dump_block_stats(spa_t *spa)
 		    100.0 * alloc / space);
 	}

-	if (spa_dedup_class(spa)->mc_allocator[0].mca_rotor != NULL) {
+	if (spa_dedup_class(spa)->mc_rotor != NULL) {
 		uint64_t alloc = metaslab_class_get_alloc(
 		    spa_dedup_class(spa));
 		uint64_t space = metaslab_class_get_space(
@@ -6471,17 +6338,6 @@ dump_block_stats(spa_t *spa)
 		    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;
@@ -6900,7 +6756,6 @@ 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, '/');
@@ -6919,7 +6774,6 @@ import_checkpointed_state(char *target, nvlist_t *cfg, char **new_path)
 			    "spa_get_stats() failed with error %d\n",
 			    poolname, error);
 		}
-		freecfg = B_TRUE;
 	}

 	if (asprintf(&bogus_name, "%s%s", poolname, BOGUS_SUFFIX) == -1)
@@ -6929,8 +6783,6 @@ import_checkpointed_state(char *target, nvlist_t *cfg, char **new_path)
 	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);
@@ -7077,7 +6929,7 @@ verify_checkpoint_vdev_spacemaps(spa_t *checkpoint, spa_t *current)
 		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);
+			ASSERT3P(current_vd->vdev_checkpoint_sm, ==, NULL);
 		}
 	}

@@ -7159,6 +7011,7 @@ verify_checkpoint_blocks(spa_t *spa)

 	spa_t *checkpoint_spa;
 	char *checkpoint_pool;
+	nvlist_t *config = NULL;
 	int error = 0;

 	/*
@@ -7166,7 +7019,7 @@ verify_checkpoint_blocks(spa_t *spa)
 	 * name) so we can do verification on it against the current state
 	 * of the pool.
 	 */
-	checkpoint_pool = import_checkpointed_state(spa->spa_name, NULL,
+	checkpoint_pool = import_checkpointed_state(spa->spa_name, config,
 	    NULL);
 	ASSERT(strcmp(spa->spa_name, checkpoint_pool) != 0);

@@ -8272,23 +8125,6 @@ zdb_embedded_block(char *thing)
 	free(buf);
 }

-/* check for valid hex or decimal numeric string */
-static boolean_t
-zdb_numeric(char *str)
-{
-	int i = 0;
-
-	if (strlen(str) == 0)
-		return (B_FALSE);
-	if (strncmp(str, "0x", 2) == 0 || strncmp(str, "0X", 2) == 0)
-		i = 2;
-	for (; i < strlen(str); i++) {
-		if (!isxdigit(str[i]))
-			return (B_FALSE);
-	}
-	return (B_TRUE);
-}
-
 int
 main(int argc, char **argv)
 {
@@ -8305,7 +8141,6 @@ main(int argc, char **argv)
 	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;
@@ -8334,7 +8169,7 @@ main(int argc, char **argv)
 	zfs_btree_verify_intensity = 3;

 	while ((c = getopt(argc, argv,
-	    "AbcCdDeEFGhiI:klLmMNo:Op:PqrRsSt:uU:vVx:XYyZ")) != -1) {
+	    "AbcCdDeEFGhiI:klLmMo:Op:PqRsSt:uU:vVx:XYyZ")) != -1) {
 		switch (c) {
 		case 'b':
 		case 'c':
@@ -8348,9 +8183,7 @@ main(int argc, char **argv)
 		case 'l':
 		case 'm':
 		case 'M':
-		case 'N':
 		case 'O':
-		case 'r':
 		case 'R':
 		case 's':
 		case 'S':
@@ -8440,6 +8273,31 @@ main(int argc, char **argv)
 		(void) fprintf(stderr, "-p option requires use of -e\n");
 		usage();
 	}
+	if (dump_opt['d']) {
+		/* <pool>[/<dataset | objset id> is accepted */
+		if (argv[2] && (objset_str = strchr(argv[2], '/')) != NULL &&
+		    objset_str++ != NULL) {
+			char *endptr;
+			errno = 0;
+			objset_id = strtoull(objset_str, &endptr, 0);
+			/* dataset 0 is the same as opening the pool */
+			if (errno == 0 && endptr != objset_str &&
+			    objset_id != 0) {
+				target_is_spa = B_FALSE;
+				dataset_lookup = B_TRUE;
+			} else if (objset_id != 0) {
+				printf("failed to open objset %s "
+				    "%llu %s", objset_str,
+				    (u_longlong_t)objset_id,
+				    strerror(errno));
+				exit(1);
+			}
+			/* normal dataset name not an objset ID */
+			if (endptr == objset_str) {
+				objset_id = -1;
+			}
+		}
+	}

 #if defined(_LP64)
 	/*
@@ -8468,18 +8326,13 @@ main(int argc, char **argv)
 	 */
 	spa_load_verify_dryrun = B_TRUE;

-	/*
-	 * ZDB should have ability to read spacemaps.
-	 */
-	spa_mode_readable_spacemaps = B_TRUE;
-
 	kernel_init(SPA_MODE_READ);

 	if (dump_all)
 		verbose = MAX(verbose, 1);

 	for (c = 0; c < 256; c++) {
-		if (dump_all && strchr("AeEFklLNOPrRSXy", c) == NULL)
+		if (dump_all && strchr("AeEFklLOPRSXy", c) == NULL)
 			dump_opt[c] = 1;
 		if (dump_opt[c])
 			dump_opt[c] += verbose;
@@ -8515,24 +8368,13 @@ main(int argc, char **argv)
 		if (argc != 2)
 			usage();
 		dump_opt['v'] = verbose + 3;
-		return (dump_path(argv[0], argv[1], NULL));
-	}
-	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);
+		return (dump_path(argv[0], argv[1]));
 	}

 	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)
@@ -8551,34 +8393,6 @@ main(int argc, char **argv)
 		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");
-			exit(1);
-		}
 	} else {
 		target_pool = target;
 	}
@@ -8615,11 +8429,6 @@ main(int argc, char **argv)
 		}
 	}

-	if (searchdirs != NULL) {
-		umem_free(searchdirs, nsearch * sizeof (char *));
-		searchdirs = NULL;
-	}
-
 	/*
 	 * import_checkpointed_state makes the assumption that the
 	 * target pool that we pass it is already part of the spa
@@ -8638,11 +8447,6 @@ main(int argc, char **argv)
 			target = checkpoint_target;
 	}

-	if (cfg != NULL) {
-		nvlist_free(cfg);
-		cfg = NULL;
-	}
-
 	if (target_pool != target)
 		free(target_pool);

@@ -8696,27 +8500,13 @@ main(int argc, char **argv)
 			}
 			return (error);
 		} 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);
+				error = spa_open(target, &spa, FTAG);
 				if (error == 0) {
 					error = name_from_objset_id(spa,
 					    objset_id, dsname);
@@ -8725,23 +8515,10 @@ retry_lookup:
 						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);
-					}
-				}
+			if (error == 0)
 				error = open_objset(target, FTAG, &os);
-			}
 			if (error == 0)
 				spa = dmu_objset_spa(os);
-			free(target_pool);
 		}
 	}
 	nvlist_free(policy);
@@ -8759,9 +8536,7 @@ retry_lookup:

 	argv++;
 	argc--;
-	if (dump_opt['r']) {
-		error = zdb_copy_object(os, object, argv[1]);
-	} else if (!dump_opt['R']) {
+	if (!dump_opt['R']) {
 		flagbits['d'] = ZOR_FLAG_DIRECTORY;
 		flagbits['f'] = ZOR_FLAG_PLAIN_FILE;
 		flagbits['m'] = ZOR_FLAG_SPACE_MAP;
@@ -1,10 +1,8 @@
 include $(top_srcdir)/config/Rules.am
-include $(top_srcdir)/config/Shellcheck.am

 AM_CFLAGS += $(LIBUDEV_CFLAGS) $(LIBUUID_CFLAGS)

 SUBDIRS = zed.d
-SHELLCHECKDIRS = $(SUBDIRS)

 sbin_PROGRAMS = zed

@@ -45,9 +43,7 @@ zed_LDADD = \
 	$(abs_top_builddir)/lib/libnvpair/libnvpair.la \
 	$(abs_top_builddir)/lib/libuutil/libuutil.la

-zed_LDADD += -lrt $(LIBATOMIC_LIBS) $(LIBUDEV_LIBS) $(LIBUUID_LIBS)
+zed_LDADD += -lrt $(LIBUDEV_LIBS) $(LIBUUID_LIBS)
 zed_LDFLAGS = -pthread

 EXTRA_DIST = agents/README.md
-
-include $(top_srcdir)/config/CppCheck.am
@@ -13,7 +13,6 @@
 /*
 * Copyright (c) 2016, Intel Corporation.
 * Copyright (c) 2018, loli10K <ezomori.nozomu@gmail.com>
- * Copyright (c) 2021 Hewlett Packard Enterprise Development LP
 */

 #include <libnvpair.h>
@@ -182,8 +181,6 @@ zfs_agent_post_event(const char *class, const char *subclass, nvlist_t *nvl)
 	 * from the vdev_disk layer after a hot unplug. Fortunately we do
 	 * get an EC_DEV_REMOVE from our disk monitor and it is a suitable
 	 * proxy so we remap it here for the benefit of the diagnosis engine.
-	 * Starting in OpenZFS 2.0, we do get FM_RESOURCE_REMOVED from the spa
-	 * layer. Processing multiple FM_RESOURCE_REMOVED events is not harmful.
 	 */
 	if ((strcmp(class, EC_DEV_REMOVE) == 0) &&
 	    (strcmp(subclass, ESC_DISK) == 0) &&
@@ -212,18 +209,12 @@ zfs_agent_post_event(const char *class, const char *subclass, nvlist_t *nvl)
 		 * For multipath, spare and l2arc devices ZFS_EV_VDEV_GUID or
 		 * ZFS_EV_POOL_GUID may be missing so find them.
 		 */
-		if (pool_guid == 0 || vdev_guid == 0) {
-			if ((nvlist_lookup_string(nvl, DEV_IDENTIFIER,
-			    &search.gs_devid) == 0) &&
-			    (zpool_iter(g_zfs_hdl, zfs_agent_iter_pool, &search)
-			    == 1)) {
-				if (pool_guid == 0)
-					pool_guid = search.gs_pool_guid;
-				if (vdev_guid == 0)
-					vdev_guid = search.gs_vdev_guid;
-				devtype = search.gs_vdev_type;
-			}
-		}
+		(void) nvlist_lookup_string(nvl, DEV_IDENTIFIER,
+		    &search.gs_devid);
+		(void) zpool_iter(g_zfs_hdl, zfs_agent_iter_pool, &search);
+		pool_guid = search.gs_pool_guid;
+		vdev_guid = search.gs_vdev_guid;
+		devtype = search.gs_vdev_type;

 		/*
 		 * We want to avoid reporting "remove" events coming from
@@ -392,7 +383,6 @@ zfs_agent_init(libzfs_handle_t *zfs_hdl)
 		list_destroy(&agent_events);
 		zed_log_die("Failed to initialize agents");
 	}
-	pthread_setname_np(g_agents_tid, "agents");
 }

 void
@@ -35,7 +35,6 @@
 #include <sys/fs/zfs.h>
 #include <sys/fm/protocol.h>
 #include <sys/fm/fs/zfs.h>
-#include <sys/zio.h>

 #include "zfs_agents.h"
 #include "fmd_api.h"
@@ -774,8 +773,6 @@ zfs_fm_recv(fmd_hdl_t *hdl, fmd_event_t *ep, nvlist_t *nvl, const char *class)
 	    ZFS_MAKE_EREPORT(FM_EREPORT_ZFS_PROBE_FAILURE))) {
 		char *failmode = NULL;
 		boolean_t checkremove = B_FALSE;
-		uint32_t pri = 0;
-		int32_t flags = 0;

 		/*
 		 * If this is a checksum or I/O error, then toss it into the
@@ -798,23 +795,6 @@ zfs_fm_recv(fmd_hdl_t *hdl, fmd_event_t *ep, nvlist_t *nvl, const char *class)
 				checkremove = B_TRUE;
 		} else if (fmd_nvl_class_match(hdl, nvl,
 		    ZFS_MAKE_EREPORT(FM_EREPORT_ZFS_CHECKSUM))) {
-			/*
-			 * We ignore ereports for checksum errors generated by
-			 * scrub/resilver I/O to avoid potentially further
-			 * degrading the pool while it's being repaired.
-			 */
-			if (((nvlist_lookup_uint32(nvl,
-			    FM_EREPORT_PAYLOAD_ZFS_ZIO_PRIORITY, &pri) == 0) &&
-			    (pri == ZIO_PRIORITY_SCRUB ||
-			    pri == ZIO_PRIORITY_REBUILD)) ||
-			    ((nvlist_lookup_int32(nvl,
-			    FM_EREPORT_PAYLOAD_ZFS_ZIO_FLAGS, &flags) == 0) &&
-			    (flags & (ZIO_FLAG_SCRUB | ZIO_FLAG_RESILVER)))) {
-				fmd_hdl_debug(hdl, "ignoring '%s' for "
-				    "scrub/resilver I/O", class);
-				return;
-			}
-
 			if (zcp->zc_data.zc_serd_checksum[0] == '\0') {
 				zfs_serd_name(zcp->zc_data.zc_serd_checksum,
 				    pool_guid, vdev_guid, "checksum");
@@ -183,14 +183,14 @@ zfs_process_add(zpool_handle_t *zhp, nvlist_t *vdev, boolean_t labeled)
 	nvlist_t *nvroot, *newvd;
 	pendingdev_t *device;
 	uint64_t wholedisk = 0ULL;
-	uint64_t offline = 0ULL, faulted = 0ULL;
+	uint64_t offline = 0ULL;
 	uint64_t guid = 0ULL;
 	char *physpath = NULL, *new_devid = NULL, *enc_sysfs_path = NULL;
 	char rawpath[PATH_MAX], fullpath[PATH_MAX];
 	char devpath[PATH_MAX];
 	int ret;
+	boolean_t is_dm = B_FALSE;
 	boolean_t is_sd = B_FALSE;
-	boolean_t is_mpath_wholedisk = B_FALSE;
 	uint_t c;
 	vdev_stat_t *vs;

@@ -211,73 +211,15 @@ zfs_process_add(zpool_handle_t *zhp, nvlist_t *vdev, boolean_t labeled)
 	    &enc_sysfs_path);
 	(void) nvlist_lookup_uint64(vdev, ZPOOL_CONFIG_WHOLE_DISK, &wholedisk);
 	(void) nvlist_lookup_uint64(vdev, ZPOOL_CONFIG_OFFLINE, &offline);
-	(void) nvlist_lookup_uint64(vdev, ZPOOL_CONFIG_FAULTED, &faulted);
-
 	(void) nvlist_lookup_uint64(vdev, ZPOOL_CONFIG_GUID, &guid);

-	/*
-	 * Special case:
-	 *
-	 * We've seen times where a disk won't have a ZPOOL_CONFIG_PHYS_PATH
-	 * entry in their config. For example, on this force-faulted disk:
-	 *
-	 *	children[0]:
-	 *	   type: 'disk'
-	 *	   id: 0
-	 *	   guid: 14309659774640089719
-	 *        path: '/dev/disk/by-vdev/L28'
-	 *        whole_disk: 0
-	 *        DTL: 654
-	 *        create_txg: 4
-	 *        com.delphix:vdev_zap_leaf: 1161
-	 *        faulted: 1
-	 *        aux_state: 'external'
-	 *	children[1]:
-	 *        type: 'disk'
-	 *        id: 1
-	 *        guid: 16002508084177980912
-	 *        path: '/dev/disk/by-vdev/L29'
-	 *        devid: 'dm-uuid-mpath-35000c500a61d68a3'
-	 *        phys_path: 'L29'
-	 *        vdev_enc_sysfs_path: '/sys/class/enclosure/0:0:1:0/SLOT 30 32'
-	 *        whole_disk: 0
-	 *        DTL: 1028
-	 *        create_txg: 4
-	 *        com.delphix:vdev_zap_leaf: 131
-	 *
-	 * If the disk's path is a /dev/disk/by-vdev/ path, then we can infer
-	 * the ZPOOL_CONFIG_PHYS_PATH from the by-vdev disk name.
-	 */
-	if (physpath == NULL && path != NULL) {
-		/* If path begins with "/dev/disk/by-vdev/" ... */
-		if (strncmp(path, DEV_BYVDEV_PATH,
-		    strlen(DEV_BYVDEV_PATH)) == 0) {
-			/* Set physpath to the char after "/dev/disk/by-vdev" */
-			physpath = &path[strlen(DEV_BYVDEV_PATH)];
-		}
-	}
+	if (offline)
+		return;  /* don't intervene if it was taken offline */

-	/*
-	 * We don't want to autoreplace offlined disks.  However, we do want to
-	 * replace force-faulted disks (`zpool offline -f`).  Force-faulted
-	 * disks have both offline=1 and faulted=1 in the nvlist.
-	 */
-	if (offline && !faulted) {
-		zed_log_msg(LOG_INFO, "%s: %s is offline, skip autoreplace",
-		    __func__, path);
-		return;
-	}
-
-	is_mpath_wholedisk = is_mpath_whole_disk(path);
+	is_dm = zfs_dev_is_dm(path);
 	zed_log_msg(LOG_INFO, "zfs_process_add: pool '%s' vdev '%s', phys '%s'"
-	    " %s blank disk, %s mpath blank disk, %s labeled, enc sysfs '%s', "
-	    "(guid %llu)",
-	    zpool_get_name(zhp), path,
-	    physpath ? physpath : "NULL",
-	    wholedisk ? "is" : "not",
-	    is_mpath_wholedisk? "is" : "not",
-	    labeled ? "is" : "not",
-	    enc_sysfs_path,
+	    " wholedisk %d, %s dm (guid %llu)", zpool_get_name(zhp), path,
+	    physpath ? physpath : "NULL", wholedisk, is_dm ? "is" : "not",
 	    (long long unsigned int)guid);

 	/*
@@ -311,9 +253,8 @@ zfs_process_add(zpool_handle_t *zhp, nvlist_t *vdev, boolean_t labeled)
 	    ZFS_ONLINE_CHECKREMOVE | ZFS_ONLINE_UNSPARE, &newstate) == 0 &&
 	    (newstate == VDEV_STATE_HEALTHY ||
 	    newstate == VDEV_STATE_DEGRADED)) {
-		zed_log_msg(LOG_INFO,
-		    "  zpool_vdev_online: vdev '%s' ('%s') is "
-		    "%s", fullpath, physpath, (newstate == VDEV_STATE_HEALTHY) ?
+		zed_log_msg(LOG_INFO, "  zpool_vdev_online: vdev %s is %s",
+		    fullpath, (newstate == VDEV_STATE_HEALTHY) ?
 		    "HEALTHY" : "DEGRADED");
 		return;
 	}
@@ -330,12 +271,11 @@ zfs_process_add(zpool_handle_t *zhp, nvlist_t *vdev, boolean_t labeled)
 	 * vdev online to trigger a FMA fault by posting an ereport.
 	 */
 	if (!zpool_get_prop_int(zhp, ZPOOL_PROP_AUTOREPLACE, NULL) ||
-	    !(wholedisk || is_mpath_wholedisk) || (physpath == NULL)) {
+	    !(wholedisk || is_dm) || (physpath == NULL)) {
 		(void) zpool_vdev_online(zhp, fullpath, ZFS_ONLINE_FORCEFAULT,
 		    &newstate);
 		zed_log_msg(LOG_INFO, "Pool's autoreplace is not enabled or "
-		    "not a blank disk for '%s' ('%s')", fullpath,
-		    physpath);
+		    "not a whole disk for '%s'", fullpath);
 		return;
 	}

@@ -347,7 +287,7 @@ zfs_process_add(zpool_handle_t *zhp, nvlist_t *vdev, boolean_t labeled)
 	(void) snprintf(rawpath, sizeof (rawpath), "%s%s",
 	    is_sd ? DEV_BYVDEV_PATH : DEV_BYPATH_PATH, physpath);

-	if (realpath(rawpath, devpath) == NULL && !is_mpath_wholedisk) {
+	if (realpath(rawpath, devpath) == NULL && !is_dm) {
 		zed_log_msg(LOG_INFO, "  realpath: %s failed (%s)",
 		    rawpath, strerror(errno));

@@ -363,14 +303,12 @@ zfs_process_add(zpool_handle_t *zhp, nvlist_t *vdev, boolean_t labeled)
 	if ((vs->vs_state != VDEV_STATE_DEGRADED) &&
 	    (vs->vs_state != VDEV_STATE_FAULTED) &&
 	    (vs->vs_state != VDEV_STATE_CANT_OPEN)) {
-		zed_log_msg(LOG_INFO, "  not autoreplacing since disk isn't in "
-		    "a bad state (currently %d)", vs->vs_state);
 		return;
 	}

 	nvlist_lookup_string(vdev, "new_devid", &new_devid);

-	if (is_mpath_wholedisk) {
+	if (is_dm) {
 		/* Don't label device mapper or multipath disks. */
 	} else if (!labeled) {
 		/*
@@ -497,15 +435,7 @@ zfs_process_add(zpool_handle_t *zhp, nvlist_t *vdev, boolean_t labeled)
 		return;
 	}

-	/*
-	 * Prefer sequential resilvering when supported (mirrors and dRAID),
-	 * otherwise fallback to a traditional healing resilver.
-	 */
-	ret = zpool_vdev_attach(zhp, fullpath, path, nvroot, B_TRUE, B_TRUE);
-	if (ret != 0) {
-		ret = zpool_vdev_attach(zhp, fullpath, path, nvroot,
-		    B_TRUE, B_FALSE);
-	}
+	ret = zpool_vdev_attach(zhp, fullpath, path, nvroot, B_TRUE, B_FALSE);

 	zed_log_msg(LOG_INFO, "  zpool_vdev_replace: %s with %s (%s)",
 	    fullpath, path, (ret == 0) ? "no errors" :
@@ -584,11 +514,8 @@ zfs_iter_vdev(zpool_handle_t *zhp, nvlist_t *nvl, void *data)
 		 * the dp->dd_compare value.
 		 */
 		if (nvlist_lookup_string(nvl, dp->dd_prop, &path) != 0 ||
-		    strcmp(dp->dd_compare, path) != 0) {
-			zed_log_msg(LOG_INFO, "  %s: no match (%s != vdev %s)",
-			    __func__, dp->dd_compare, path);
+		    strcmp(dp->dd_compare, path) != 0)
 			return;
-		}

 		zed_log_msg(LOG_INFO, "  zfs_iter_vdev: matched %s on %s",
 		    dp->dd_prop, path);
@@ -636,8 +563,6 @@ zfs_iter_pool(zpool_handle_t *zhp, void *data)
 			    ZPOOL_CONFIG_VDEV_TREE, &nvl);
 			zfs_iter_vdev(zhp, nvl, data);
 		}
-	} else {
-		zed_log_msg(LOG_INFO, "%s: no config\n", __func__);
 	}

 	/*
@@ -686,72 +611,6 @@ devphys_iter(const char *physical, const char *devid, zfs_process_func_t func,
 	return (data.dd_found);
 }

-/*
- * Given a device identifier, find any vdevs with a matching by-vdev
- * path.  Normally we shouldn't need this as the comparison would be
- * made earlier in the devphys_iter().  For example, if we were replacing
- * /dev/disk/by-vdev/L28, normally devphys_iter() would match the
- * ZPOOL_CONFIG_PHYS_PATH of "L28" from the old disk config to "L28"
- * of the new disk config.  However, we've seen cases where
- * ZPOOL_CONFIG_PHYS_PATH was not in the config for the old disk.  Here's
- * an example of a real 2-disk mirror pool where one disk was force
- * faulted:
- *
- *       com.delphix:vdev_zap_top: 129
- *           children[0]:
- *               type: 'disk'
- *               id: 0
- *               guid: 14309659774640089719
- *               path: '/dev/disk/by-vdev/L28'
- *               whole_disk: 0
- *               DTL: 654
- *               create_txg: 4
- *               com.delphix:vdev_zap_leaf: 1161
- *               faulted: 1
- *               aux_state: 'external'
- *           children[1]:
- *               type: 'disk'
- *               id: 1
- *               guid: 16002508084177980912
- *               path: '/dev/disk/by-vdev/L29'
- *               devid: 'dm-uuid-mpath-35000c500a61d68a3'
- *               phys_path: 'L29'
- *               vdev_enc_sysfs_path: '/sys/class/enclosure/0:0:1:0/SLOT 30 32'
- *               whole_disk: 0
- *               DTL: 1028
- *               create_txg: 4
- *               com.delphix:vdev_zap_leaf: 131
- *
- * So in the case above, the only thing we could compare is the path.
- *
- * We can do this because we assume by-vdev paths are authoritative as physical
- * paths.  We could not assume this for normal paths like /dev/sda since the
- * physical location /dev/sda points to could change over time.
- */
-static boolean_t
-by_vdev_path_iter(const char *by_vdev_path, const char *devid,
-    zfs_process_func_t func, boolean_t is_slice)
-{
-	dev_data_t data = { 0 };
-
-	data.dd_compare = by_vdev_path;
-	data.dd_func = func;
-	data.dd_prop = ZPOOL_CONFIG_PATH;
-	data.dd_found = B_FALSE;
-	data.dd_islabeled = is_slice;
-	data.dd_new_devid = devid;
-
-	if (strncmp(by_vdev_path, DEV_BYVDEV_PATH,
-	    strlen(DEV_BYVDEV_PATH)) != 0) {
-		/* by_vdev_path doesn't start with "/dev/disk/by-vdev/" */
-		return (B_FALSE);
-	}
-
-	(void) zpool_iter(g_zfshdl, zfs_iter_pool, &data);
-
-	return (data.dd_found);
-}
-
 /*
 * Given a device identifier, find any vdevs with a matching devid.
 * On Linux we can match devid directly which is always a whole disk.
@@ -773,27 +632,6 @@ devid_iter(const char *devid, zfs_process_func_t func, boolean_t is_slice)
 	return (data.dd_found);
 }

-/*
- * Given a device guid, find any vdevs with a matching guid.
- */
-static boolean_t
-guid_iter(uint64_t pool_guid, uint64_t vdev_guid, const char *devid,
-    zfs_process_func_t func, boolean_t is_slice)
-{
-	dev_data_t data = { 0 };
-
-	data.dd_func = func;
-	data.dd_found = B_FALSE;
-	data.dd_pool_guid = pool_guid;
-	data.dd_vdev_guid = vdev_guid;
-	data.dd_islabeled = is_slice;
-	data.dd_new_devid = devid;
-
-	(void) zpool_iter(g_zfshdl, zfs_iter_pool, &data);
-
-	return (data.dd_found);
-}
-
 /*
 * Handle a EC_DEV_ADD.ESC_DISK event.
 *
@@ -816,21 +654,16 @@ guid_iter(uint64_t pool_guid, uint64_t vdev_guid, const char *devid,
 static int
 zfs_deliver_add(nvlist_t *nvl, boolean_t is_lofi)
 {
-	char *devpath = NULL, *devid = NULL;
-	uint64_t pool_guid = 0, vdev_guid = 0;
+	char *devpath = NULL, *devid;
 	boolean_t is_slice;

 	/*
-	 * Expecting a devid string and an optional physical location and guid
+	 * Expecting a devid string and an optional physical location
 	 */
-	if (nvlist_lookup_string(nvl, DEV_IDENTIFIER, &devid) != 0) {
-		zed_log_msg(LOG_INFO, "%s: no dev identifier\n", __func__);
+	if (nvlist_lookup_string(nvl, DEV_IDENTIFIER, &devid) != 0)
 		return (-1);
-	}

 	(void) nvlist_lookup_string(nvl, DEV_PHYS_PATH, &devpath);
-	(void) nvlist_lookup_uint64(nvl, ZFS_EV_POOL_GUID, &pool_guid);
-	(void) nvlist_lookup_uint64(nvl, ZFS_EV_VDEV_GUID, &vdev_guid);

 	is_slice = (nvlist_lookup_boolean(nvl, DEV_IS_PART) == 0);

@@ -841,28 +674,12 @@ zfs_deliver_add(nvlist_t *nvl, boolean_t is_lofi)
 	 * Iterate over all vdevs looking for a match in the following order:
 	 * 1. ZPOOL_CONFIG_DEVID (identifies the unique disk)
 	 * 2. ZPOOL_CONFIG_PHYS_PATH (identifies disk physical location).
-	 * 3. ZPOOL_CONFIG_GUID (identifies unique vdev).
-	 * 4. ZPOOL_CONFIG_PATH for /dev/disk/by-vdev devices only (since
-	 *    by-vdev paths represent physical paths).
+	 *
+	 * For disks, we only want to pay attention to vdevs marked as whole
+	 * disks or are a multipath device.
 	 */
-	if (devid_iter(devid, zfs_process_add, is_slice))
-		return (0);
-	if (devpath != NULL && devphys_iter(devpath, devid, zfs_process_add,
-	    is_slice))
-		return (0);
-	if (vdev_guid != 0)
-		(void) guid_iter(pool_guid, vdev_guid, devid, zfs_process_add,
-		    is_slice);
-
-	if (devpath != NULL) {
-		/* Can we match a /dev/disk/by-vdev/ path? */
-		char by_vdev_path[MAXPATHLEN];
-		snprintf(by_vdev_path, sizeof (by_vdev_path),
-		    "/dev/disk/by-vdev/%s", devpath);
-		if (by_vdev_path_iter(by_vdev_path, devid, zfs_process_add,
-		    is_slice))
-			return (0);
-	}
+	if (!devid_iter(devid, zfs_process_add, is_slice) && devpath != NULL)
+		(void) devphys_iter(devpath, devid, zfs_process_add, is_slice);

 	return (0);
 }
@@ -894,90 +711,14 @@ zfs_deliver_check(nvlist_t *nvl)
 	return (0);
 }

-/*
- * Given a path to a vdev, lookup the vdev's physical size from its
- * config nvlist.
- *
- * Returns the vdev's physical size in bytes on success, 0 on error.
- */
-static uint64_t
-vdev_size_from_config(zpool_handle_t *zhp, const char *vdev_path)
-{
-	nvlist_t *nvl = NULL;
-	boolean_t avail_spare, l2cache, log;
-	vdev_stat_t *vs = NULL;
-	uint_t c;
-
-	nvl = zpool_find_vdev(zhp, vdev_path, &avail_spare, &l2cache, &log);
-	if (!nvl)
-		return (0);
-
-	verify(nvlist_lookup_uint64_array(nvl, ZPOOL_CONFIG_VDEV_STATS,
-	    (uint64_t **)&vs, &c) == 0);
-	if (!vs) {
-		zed_log_msg(LOG_INFO, "%s: no nvlist for '%s'", __func__,
-		    vdev_path);
-		return (0);
-	}
-
-	return (vs->vs_pspace);
-}
-
-/*
- * Given a path to a vdev, lookup if the vdev is a "whole disk" in the
- * config nvlist.  "whole disk" means that ZFS was passed a whole disk
- * at pool creation time, which it partitioned up and has full control over.
- * Thus a partition with wholedisk=1 set tells us that zfs created the
- * partition at creation time.  A partition without whole disk set would have
- * been created by externally (like with fdisk) and passed to ZFS.
- *
- * Returns the whole disk value (either 0 or 1).
- */
-static uint64_t
-vdev_whole_disk_from_config(zpool_handle_t *zhp, const char *vdev_path)
-{
-	nvlist_t *nvl = NULL;
-	boolean_t avail_spare, l2cache, log;
-	uint64_t wholedisk;
-
-	nvl = zpool_find_vdev(zhp, vdev_path, &avail_spare, &l2cache, &log);
-	if (!nvl)
-		return (0);
-
-	verify(nvlist_lookup_uint64(nvl, ZPOOL_CONFIG_WHOLE_DISK,
-	    &wholedisk) == 0);
-
-	return (wholedisk);
-}
-
-/*
- * If the device size grew more than 1% then return true.
- */
-#define	DEVICE_GREW(oldsize, newsize) \
-		    ((newsize > oldsize) && \
-		    ((newsize / (newsize - oldsize)) <= 100))
-
 static int
 zfsdle_vdev_online(zpool_handle_t *zhp, void *data)
 {
+	char *devname = data;
 	boolean_t avail_spare, l2cache;
-	nvlist_t *udev_nvl = data;
 	nvlist_t *tgt;
 	int error;

-	char *tmp_devname, devname[MAXPATHLEN];
-	uint64_t guid;
-
-	if (nvlist_lookup_uint64(udev_nvl, ZFS_EV_VDEV_GUID, &guid) == 0) {
-		sprintf(devname, "%llu", (u_longlong_t)guid);
-	} else if (nvlist_lookup_string(udev_nvl, DEV_PHYS_PATH,
-	    &tmp_devname) == 0) {
-		strlcpy(devname, tmp_devname, MAXPATHLEN);
-		zfs_append_partition(devname, MAXPATHLEN);
-	} else {
-		zed_log_msg(LOG_INFO, "%s: no guid or physpath", __func__);
-	}
-
 	zed_log_msg(LOG_INFO, "zfsdle_vdev_online: searching for '%s' in '%s'",
 	    devname, zpool_get_name(zhp));

@@ -1029,75 +770,12 @@ zfsdle_vdev_online(zpool_handle_t *zhp, void *data)
 			vdev_state_t newstate;

 			if (zpool_get_state(zhp) != POOL_STATE_UNAVAIL) {
-				/*
-				 * If this disk size has not changed, then
-				 * there's no need to do an autoexpand.  To
-				 * check we look at the disk's size in its
-				 * config, and compare it to the disk size
-				 * that udev is reporting.
-				 */
-				uint64_t udev_size = 0, conf_size = 0,
-				    wholedisk = 0, udev_parent_size = 0;
-
-				/*
-				 * Get the size of our disk that udev is
-				 * reporting.
-				 */
-				if (nvlist_lookup_uint64(udev_nvl, DEV_SIZE,
-				    &udev_size) != 0) {
-					udev_size = 0;
-				}
-
-				/*
-				 * Get the size of our disk's parent device
-				 * from udev (where sda1's parent is sda).
-				 */
-				if (nvlist_lookup_uint64(udev_nvl,
-				    DEV_PARENT_SIZE, &udev_parent_size) != 0) {
-					udev_parent_size = 0;
-				}
-
-				conf_size = vdev_size_from_config(zhp,
-				    fullpath);
-
-				wholedisk = vdev_whole_disk_from_config(zhp,
-				    fullpath);
-
-				/*
-				 * Only attempt an autoexpand if the vdev size
-				 * changed.  There are two different cases
-				 * to consider.
-				 *
-				 * 1. wholedisk=1
-				 * If you do a 'zpool create' on a whole disk
-				 * (like /dev/sda), then zfs will create
-				 * partitions on the disk (like /dev/sda1).  In
-				 * that case, wholedisk=1 will be set in the
-				 * partition's nvlist config.  So zed will need
-				 * to see if your parent device (/dev/sda)
-				 * expanded in size, and if so, then attempt
-				 * the autoexpand.
-				 *
-				 * 2. wholedisk=0
-				 * If you do a 'zpool create' on an existing
-				 * partition, or a device that doesn't allow
-				 * partitions, then wholedisk=0, and you will
-				 * simply need to check if the device itself
-				 * expanded in size.
-				 */
-				if (DEVICE_GREW(conf_size, udev_size) ||
-				    (wholedisk && DEVICE_GREW(conf_size,
-				    udev_parent_size))) {
-					error = zpool_vdev_online(zhp, fullpath,
-					    0, &newstate);
-
-					zed_log_msg(LOG_INFO,
-					    "%s: autoexpanding '%s' from %llu"
-					    " to %llu bytes in pool '%s': %d",
-					    __func__, fullpath, conf_size,
-					    MAX(udev_size, udev_parent_size),
-					    zpool_get_name(zhp), error);
-				}
+				error = zpool_vdev_online(zhp, fullpath, 0,
+				    &newstate);
+				zed_log_msg(LOG_INFO, "zfsdle_vdev_online: "
+				    "setting device '%s' to ONLINE state "
+				    "in pool '%s': %d", fullpath,
+				    zpool_get_name(zhp), error);
 			}
 		}
 		zpool_close(zhp);
@@ -1128,7 +806,7 @@ zfs_deliver_dle(nvlist_t *nvl)
 		zed_log_msg(LOG_INFO, "zfs_deliver_dle: no guid or physpath");
 	}

-	if (zpool_iter(g_zfshdl, zfsdle_vdev_online, nvl) != 1) {
+	if (zpool_iter(g_zfshdl, zfsdle_vdev_online, name) != 1) {
 		zed_log_msg(LOG_INFO, "zfs_deliver_dle: device '%s' not "
 		    "found", name);
 		return (1);
@@ -1232,7 +910,6 @@ zfs_slm_init()
 		return (-1);
 	}

-	pthread_setname_np(g_zfs_tid, "enum-pools");
 	list_create(&g_device_list, sizeof (struct pendingdev),
 	    offsetof(struct pendingdev, pd_node));

@@ -40,7 +40,6 @@
 #include <sys/fm/fs/zfs.h>
 #include <libzfs.h>
 #include <string.h>
-#include <libgen.h>

 #include "zfs_agents.h"
 #include "fmd_api.h"
@@ -220,18 +219,12 @@ replace_with_spare(fmd_hdl_t *hdl, zpool_handle_t *zhp, nvlist_t *vdev)
 	 * replace it.
 	 */
 	for (s = 0; s < nspares; s++) {
-		boolean_t rebuild = B_FALSE;
-		char *spare_name, *type;
+		char *spare_name;

 		if (nvlist_lookup_string(spares[s], ZPOOL_CONFIG_PATH,
 		    &spare_name) != 0)
 			continue;

-		/* prefer sequential resilvering for distributed spares */
-		if ((nvlist_lookup_string(spares[s], ZPOOL_CONFIG_TYPE,
-		    &type) == 0) && strcmp(type, VDEV_TYPE_DRAID_SPARE) == 0)
-			rebuild = B_TRUE;
-
 		/* if set, add the "ashift" pool property to the spare nvlist */
 		if (source != ZPROP_SRC_DEFAULT)
 			(void) nvlist_add_uint64(spares[s],
@@ -244,7 +237,7 @@ replace_with_spare(fmd_hdl_t *hdl, zpool_handle_t *zhp, nvlist_t *vdev)
 		    dev_name, basename(spare_name));

 		if (zpool_vdev_attach(zhp, dev_name, spare_name,
-		    replacement, B_TRUE, rebuild) == 0) {
+		    replacement, B_TRUE, B_FALSE) == 0) {
 			free(dev_name);
 			nvlist_free(replacement);
 			return (B_TRUE);
@@ -335,7 +328,7 @@ zfs_retire_recv(fmd_hdl_t *hdl, fmd_event_t *ep, nvlist_t *nvl,
 	 */
 	if (strcmp(class, "resource.fs.zfs.removed") == 0 ||
 	    (strcmp(class, "resource.fs.zfs.statechange") == 0 &&
-	    (state == VDEV_STATE_REMOVED || state == VDEV_STATE_FAULTED))) {
+	    state == VDEV_STATE_REMOVED)) {
 		char *devtype;
 		char *devname;

@@ -506,7 +499,6 @@ zfs_retire_recv(fmd_hdl_t *hdl, fmd_event_t *ep, nvlist_t *nvl,
 		 * Attempt to substitute a hot spare.
 		 */
 		(void) replace_with_spare(hdl, zhp, vdev);
-
 		zpool_close(zhp);
 	}

@@ -3,7 +3,7 @@
 *
 * Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
 * Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
- * Refer to the OpenZFS git commit log for authoritative copyright attribution.
+ * Refer to the ZoL git commit log for authoritative copyright attribution.
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License Version 1.0 (CDDL-1.0).
@@ -60,8 +60,8 @@ _setup_sig_handlers(void)
 		zed_log_die("Failed to initialize sigset");

 	sa.sa_flags = SA_RESTART;
-
 	sa.sa_handler = SIG_IGN;
+
 	if (sigaction(SIGPIPE, &sa, NULL) < 0)
 		zed_log_die("Failed to ignore SIGPIPE");

@@ -75,10 +75,6 @@ _setup_sig_handlers(void)
 	sa.sa_handler = _hup_handler;
 	if (sigaction(SIGHUP, &sa, NULL) < 0)
 		zed_log_die("Failed to register SIGHUP handler");
-
-	(void) sigaddset(&sa.sa_mask, SIGCHLD);
-	if (pthread_sigmask(SIG_BLOCK, &sa.sa_mask, NULL) < 0)
-		zed_log_die("Failed to block SIGCHLD");
 }

 /*
@@ -216,20 +212,22 @@ _finish_daemonize(void)
 int
 main(int argc, char *argv[])
 {
-	struct zed_conf zcp;
+	struct zed_conf *zcp;
 	uint64_t saved_eid;
 	int64_t saved_etime[2];

 	zed_log_init(argv[0]);
 	zed_log_stderr_open(LOG_NOTICE);
-	zed_conf_init(&zcp);
-	zed_conf_parse_opts(&zcp, argc, argv);
-	if (zcp.do_verbose)
+	zcp = zed_conf_create();
+	zed_conf_parse_opts(zcp, argc, argv);
+	if (zcp->do_verbose)
 		zed_log_stderr_open(LOG_INFO);

 	if (geteuid() != 0)
 		zed_log_die("Must be run as root");

+	zed_conf_parse_file(zcp);
+
 	zed_file_close_from(STDERR_FILENO + 1);

 	(void) umask(0);
@@ -237,32 +235,32 @@ main(int argc, char *argv[])
 	if (chdir("/") < 0)
 		zed_log_die("Failed to change to root directory");

-	if (zed_conf_scan_dir(&zcp) < 0)
+	if (zed_conf_scan_dir(zcp) < 0)
 		exit(EXIT_FAILURE);

-	if (!zcp.do_foreground) {
+	if (!zcp->do_foreground) {
 		_start_daemonize();
 		zed_log_syslog_open(LOG_DAEMON);
 	}
 	_setup_sig_handlers();

-	if (zcp.do_memlock)
+	if (zcp->do_memlock)
 		_lock_memory();

-	if ((zed_conf_write_pid(&zcp) < 0) && (!zcp.do_force))
+	if ((zed_conf_write_pid(zcp) < 0) && (!zcp->do_force))
 		exit(EXIT_FAILURE);

-	if (!zcp.do_foreground)
+	if (!zcp->do_foreground)
 		_finish_daemonize();

 	zed_log_msg(LOG_NOTICE,
 	    "ZFS Event Daemon %s-%s (PID %d)",
 	    ZFS_META_VERSION, ZFS_META_RELEASE, (int)getpid());

-	if (zed_conf_open_state(&zcp) < 0)
+	if (zed_conf_open_state(zcp) < 0)
 		exit(EXIT_FAILURE);

-	if (zed_conf_read_state(&zcp, &saved_eid, saved_etime) < 0)
+	if (zed_conf_read_state(zcp, &saved_eid, saved_etime) < 0)
 		exit(EXIT_FAILURE);

 idle:
@@ -271,38 +269,38 @@ idle:
 	 * successful.
 	 */
 	do {
-		if (!zed_event_init(&zcp))
+		if (!zed_event_init(zcp))
 			break;
 		/* Wait for some time and try again. tunable? */
 		sleep(30);
-	} while (!_got_exit && zcp.do_idle);
+	} while (!_got_exit && zcp->do_idle);

 	if (_got_exit)
 		goto out;

-	zed_event_seek(&zcp, saved_eid, saved_etime);
+	zed_event_seek(zcp, saved_eid, saved_etime);

 	while (!_got_exit) {
 		int rv;
 		if (_got_hup) {
 			_got_hup = 0;
-			(void) zed_conf_scan_dir(&zcp);
+			(void) zed_conf_scan_dir(zcp);
 		}
-		rv = zed_event_service(&zcp);
+		rv = zed_event_service(zcp);

 		/* ENODEV: When kernel module is unloaded (osx) */
-		if (rv != 0)
+		if (rv == ENODEV)
 			break;
 	}

 	zed_log_msg(LOG_NOTICE, "Exiting");
-	zed_event_fini(&zcp);
+	zed_event_fini(zcp);

-	if (zcp.do_idle && !_got_exit)
+	if (zcp->do_idle && !_got_exit)
 		goto idle;

 out:
-	zed_conf_destroy(&zcp);
+	zed_conf_destroy(zcp);
 	zed_log_fini();
 	exit(EXIT_SUCCESS);
 }
@@ -1,6 +1,5 @@
 include $(top_srcdir)/config/Rules.am
 include $(top_srcdir)/config/Substfiles.am
-include $(top_srcdir)/config/Shellcheck.am

 EXTRA_DIST += README

@@ -52,6 +51,3 @@ install-data-hook:
 	    ln -s "$(zedexecdir)/$${f}" "$(DESTDIR)$(zedconfdir)"; \
 	done
 	chmod 0600 "$(DESTDIR)$(zedconfdir)/zed.rc"
-
-# False positive: 1>&"${ZED_FLOCK_FD}" looks suspiciously similar to a >&filename bash extension
-CHECKBASHISMS_IGNORE = -e 'should be >word 2>&1' -e '&"$${ZED_FLOCK_FD}"'
@@ -12,11 +12,15 @@

 zed_exit_if_ignoring_this_event

-zed_lock "${ZED_DEBUG_LOG}"
-{
-	printenv | sort
-	echo
-} 1>&"${ZED_FLOCK_FD}"
-zed_unlock "${ZED_DEBUG_LOG}"
+lockfile="$(basename -- "${ZED_DEBUG_LOG}").lock"

+umask 077
+zed_lock "${lockfile}"
+exec >> "${ZED_DEBUG_LOG}"
+
+printenv | sort
+echo
+
+exec >&-
+zed_unlock "${lockfile}"
 exit 0
@@ -21,7 +21,7 @@ if [ "${ZED_SYSLOG_DISPLAY_GUIDS}" = "1" ]; then
    [ -n "${ZEVENT_VDEV_GUID}" ] && msg="${msg} vdev_guid=${ZEVENT_VDEV_GUID}"
 else
    [ -n "${ZEVENT_POOL}" ] && msg="${msg} pool='${ZEVENT_POOL}'"
-    [ -n "${ZEVENT_VDEV_PATH}" ] && msg="${msg} vdev=${ZEVENT_VDEV_PATH##*/}"
+    [ -n "${ZEVENT_VDEV_PATH}" ] && msg="${msg} vdev=$(basename "${ZEVENT_VDEV_PATH}")"
 fi

 # log pool state if state is anything other than 'ACTIVE'
@@ -42,7 +42,6 @@ fi
    msg="${msg} delay=$((ZEVENT_ZIO_DELAY / 1000000))ms"

 # list the bookmark data together
-# shellcheck disable=SC2153
 [ -n "${ZEVENT_ZIO_OBJSET}" ] && \
    msg="${msg} bookmark=${ZEVENT_ZIO_OBJSET}:${ZEVENT_ZIO_OBJECT}:${ZEVENT_ZIO_LEVEL}:${ZEVENT_ZIO_BLKID}"

@@ -25,7 +25,7 @@ zed_rate_limit "${rate_limit_tag}" || exit 3

 umask 077
 note_subject="ZFS ${ZEVENT_SUBCLASS} error for ${ZEVENT_POOL} on $(hostname)"
-note_pathname="$(mktemp)"
+note_pathname="${TMPDIR:="/tmp"}/$(basename -- "$0").${ZEVENT_EID}.$$"
 {
    echo "ZFS has detected a data error:"
    echo
@@ -23,7 +23,7 @@

 # Rate-limit the notification based in part on the filename.
 #
-rate_limit_tag="${ZEVENT_POOL};${ZEVENT_SUBCLASS};${0##*/}"
+rate_limit_tag="${ZEVENT_POOL};${ZEVENT_SUBCLASS};$(basename -- "$0")"
 rate_limit_interval="${ZED_NOTIFY_INTERVAL_SECS}"
 zed_rate_limit "${rate_limit_tag}" "${rate_limit_interval}" || exit 3

@@ -31,7 +31,7 @@ umask 077
 pool_str="${ZEVENT_POOL:+" for ${ZEVENT_POOL}"}"
 host_str=" on $(hostname)"
 note_subject="ZFS ${ZEVENT_SUBCLASS} event${pool_str}${host_str}"
-note_pathname="$(mktemp)"
+note_pathname="${TMPDIR:="/tmp"}/$(basename -- "$0").${ZEVENT_EID}.$$"
 {
    echo "ZFS has posted the following event:"
    echo
@@ -3,8 +3,9 @@
 # Track changes to enumerated pools for use in early-boot
 set -ef

-FSLIST="@sysconfdir@/zfs/zfs-list.cache/${ZEVENT_POOL}"
-FSLIST_TMP="@runstatedir@/zfs-list.cache@${ZEVENT_POOL}"
+FSLIST_DIR="@sysconfdir@/zfs/zfs-list.cache"
+FSLIST_TMP="@runstatedir@/zfs-list.cache.new"
+FSLIST="${FSLIST_DIR}/${ZEVENT_POOL}"

 # If the pool specific cache file is not writeable, abort
 [ -w "${FSLIST}" ] || exit 0
@@ -12,21 +13,21 @@ FSLIST_TMP="@runstatedir@/zfs-list.cache@${ZEVENT_POOL}"
 [ -f "${ZED_ZEDLET_DIR}/zed.rc" ] && . "${ZED_ZEDLET_DIR}/zed.rc"
 . "${ZED_ZEDLET_DIR}/zed-functions.sh"

-[ "$ZEVENT_SUBCLASS" != "history_event" ] && exit 0
-zed_check_cmd "${ZFS}" sort diff
+zed_exit_if_ignoring_this_event
+zed_check_cmd "${ZFS}" sort diff grep

 # If we are acting on a snapshot, we have nothing to do
-[ "${ZEVENT_HISTORY_DSNAME%@*}" = "${ZEVENT_HISTORY_DSNAME}" ] || exit 0
+printf '%s' "${ZEVENT_HISTORY_DSNAME}" | grep '@' && exit 0

-# We lock the output file to avoid simultaneous writes.
+# We obtain a lock on zfs-list to avoid any simultaneous writes.
 # If we run into trouble, log and drop the lock
 abort_alter() {
-  zed_log_msg "Error updating zfs-list.cache for ${ZEVENT_POOL}!"
-  zed_unlock "${FSLIST}"
+  zed_log_msg "Error updating zfs-list.cache!"
+  zed_unlock zfs-list
 }

 finished() {
-  zed_unlock "${FSLIST}"
+  zed_unlock zfs-list
  trap - EXIT
  exit 0
 }
@@ -36,7 +37,7 @@ case "${ZEVENT_HISTORY_INTERNAL_NAME}" in
      ;;

    export)
-        zed_lock "${FSLIST}"
+        zed_lock zfs-list
        trap abort_alter EXIT
        echo > "${FSLIST}"
        finished
@@ -62,7 +63,7 @@ case "${ZEVENT_HISTORY_INTERNAL_NAME}" in
      ;;
 esac

-zed_lock "${FSLIST}"
+zed_lock zfs-list
 trap abort_alter EXIT

 PROPS="name,mountpoint,canmount,atime,relatime,devices,exec\
@@ -78,7 +79,7 @@ PROPS="name,mountpoint,canmount,atime,relatime,devices,exec\
 sort "${FSLIST_TMP}" -o "${FSLIST_TMP}"

 # Don't modify the file if it hasn't changed
-diff -q "${FSLIST_TMP}" "${FSLIST}" || cat "${FSLIST_TMP}" > "${FSLIST}"
+diff -q "${FSLIST_TMP}" "${FSLIST}" || mv "${FSLIST_TMP}" "${FSLIST}"
 rm -f "${FSLIST_TMP}"

 finished
@@ -41,7 +41,7 @@ fi

 umask 077
 note_subject="ZFS ${ZEVENT_SUBCLASS} event for ${ZEVENT_POOL} on $(hostname)"
-note_pathname="$(mktemp)"
+note_pathname="${TMPDIR:="/tmp"}/$(basename -- "$0").${ZEVENT_EID}.$$"
 {
    echo "ZFS has finished a ${action}:"
    echo
@@ -1,21 +1,21 @@
 #!/bin/sh
 #
-# Turn off/on vdevs' enclosure fault LEDs when their pool's state changes.
+# Turn off/on the VDEV's enclosure fault LEDs when the pool's state changes.
 #
-# Turn a vdev's fault LED on if it becomes FAULTED, DEGRADED or UNAVAIL.
-# Turn its LED off when it's back ONLINE again.
+# Turn the VDEV's fault LED on if it becomes FAULTED, DEGRADED or UNAVAIL.
+# Turn the LED off when it's back ONLINE again.
 #
 # This script run in two basic modes:
 #
 # 1. If $ZEVENT_VDEV_ENC_SYSFS_PATH and $ZEVENT_VDEV_STATE_STR are set, then
-# only set the LED for that particular vdev. This is the case for statechange
+# only set the LED for that particular VDEV. This is the case for statechange
 # events and some vdev_* events.
 #
-# 2. If those vars are not set, then check the state of all vdevs in the pool
+# 2. If those vars are not set, then check the state of all VDEVs in the pool
 # and set the LEDs accordingly.  This is the case for pool_import events.
 #
 # Note that this script requires that your enclosure be supported by the
-# Linux SCSI Enclosure services (SES) driver.  The script will do nothing
+# Linux SCSI enclosure services (ses) driver.  The script will do nothing
 # if you have no enclosure, or if your enclosure isn't supported.
 #
 # Exit codes:
@@ -29,8 +29,7 @@
 [ -f "${ZED_ZEDLET_DIR}/zed.rc" ] && . "${ZED_ZEDLET_DIR}/zed.rc"
 . "${ZED_ZEDLET_DIR}/zed-functions.sh"

-if [ ! -d /sys/class/enclosure ] && [ ! -d /sys/bus/pci/slots ] ; then
-	# No JBOD enclosure or NVMe slots
+if [ ! -d /sys/class/enclosure ] ; then
 	exit 1
 fi

@@ -60,10 +59,6 @@ check_and_set_led()
 	file="$1"
 	val="$2"

-	if [ -z "$val" ]; then
-		return 0
-	fi
-
 	if [ ! -e "$file" ] ; then
 		return 3
 	fi
@@ -71,11 +66,11 @@ check_and_set_led()
 	# If another process is accessing the LED when we attempt to update it,
 	# the update will be lost so retry until the LED actually changes or we
 	# timeout.
-	for _ in 1 2 3 4 5; do
+	for _ in $(seq 1 5); do
 		# We want to check the current state first, since writing to the
 		# 'fault' entry always causes a SES command, even if the
 		# current state is already what you want.
-		read -r current < "${file}"
+		current=$(cat "${file}")

 		# On some enclosures if you write 1 to fault, and read it back,
 		# it will return 2.  Treat all non-zero values as 1 for
@@ -90,84 +85,27 @@ check_and_set_led()
 		else
 			break
 		fi
-	done
-}
-
-# Fault LEDs for JBODs and NVMe drives are handled a little differently.
-#
-# On JBODs the fault LED is called 'fault' and on a path like this:
-#
-#   /sys/class/enclosure/0:0:1:0/SLOT 10/fault
-#
-# On NVMe it's called 'attention' and on a path like this:
-#
-#   /sys/bus/pci/slot/0/attention
-#
-# This function returns the full path to the fault LED file for a given
-# enclosure/slot directory.
-#
-path_to_led()
-{
-	dir=$1
-	if [ -f "$dir/fault" ] ; then
-		echo "$dir/fault"
-	elif [ -f "$dir/attention" ] ; then
-		echo "$dir/attention"
-	fi
+        done
 }

 state_to_val()
 {
 	state="$1"
-	case "$state" in
-		FAULTED|DEGRADED|UNAVAIL)
-			echo 1
-			;;
-		ONLINE)
-			echo 0
-			;;
-	esac
+	if [ "$state" = "FAULTED" ] || [ "$state" = "DEGRADED" ] || \
+	   [ "$state" = "UNAVAIL" ] ; then
+		echo 1
+	elif [ "$state" = "ONLINE" ] ; then
+		echo 0
+	fi
 }

+# process_pool ([pool])
 #
-# Given a nvme name like 'nvme0n1', pass back its slot directory
-# like "/sys/bus/pci/slots/0"
-#
-nvme_dev_to_slot()
-{
-	dev="$1"
-
-	# Get the address "0000:01:00.0"
-	address=$(cat "/sys/class/block/$dev/device/address")
-
-	# For each /sys/bus/pci/slots subdir that is an actual number
-	# (rather than weird directories like "1-3/").
-	# shellcheck disable=SC2010
-	for i in $(ls /sys/bus/pci/slots/ | grep -E "^[0-9]+$") ; do
-		this_address=$(cat "/sys/bus/pci/slots/$i/address")
-
-		# The format of address is a little different between
-		# /sys/class/block/$dev/device/address and
-		# /sys/bus/pci/slots/
-		#
-		# address=           "0000:01:00.0"
-		# this_address =     "0000:01:00"
-		#
-		if echo "$address" | grep -Eq ^"$this_address" ; then
-			echo "/sys/bus/pci/slots/$i"
-			break
-		fi
-	done
-}
-
-
-# process_pool (pool)
-#
-# Iterate through a pool and set the vdevs' enclosure slot LEDs to
-# those vdevs' state.
+# Iterate through a pool (or pools) and set the VDEV's enclosure slot LEDs to
+# the VDEV's state.
 #
 # Arguments
-#   pool:	Pool name.
+#   pool:	Optional pool name.  If not specified, iterate though all pools.
 #
 # Return
 #  0 on success, 3 on missing sysfs path
@@ -175,27 +113,19 @@ nvme_dev_to_slot()
 process_pool()
 {
 	pool="$1"
-
-	# The output will be the vdevs only (from "grep '/dev/'"):
-	#
-	#    U45     ONLINE       0     0     0   /dev/sdk          0
-	#    U46     ONLINE       0     0     0   /dev/sdm          0
-	#    U47     ONLINE       0     0     0   /dev/sdn          0
-	#    U50     ONLINE       0     0     0  /dev/sdbn          0
-	#
-	ZPOOL_SCRIPTS_AS_ROOT=1 $ZPOOL status -c upath,fault_led "$pool" | grep '/dev/' | (
 	rc=0
-	while read -r vdev state _ _ _ therest; do
-		# Read out current LED value and path
-		# Get dev name (like 'sda')
-		dev=$(basename "$(echo "$therest" | awk '{print $(NF-1)}')")
-		vdev_enc_sysfs_path=$(realpath "/sys/class/block/$dev/device/enclosure_device"*)
-		if [ ! -d "$vdev_enc_sysfs_path" ] ; then
-			# This is not a JBOD disk, but it could be a PCI NVMe drive
-			vdev_enc_sysfs_path=$(nvme_dev_to_slot "$dev")
-		fi

-		current_val=$(echo "$therest" | awk '{print $NF}')
+	# Lookup all the current LED values and paths in parallel
+	#shellcheck disable=SC2016
+	cmd='echo led_token=$(cat "$VDEV_ENC_SYSFS_PATH/fault"),"$VDEV_ENC_SYSFS_PATH",'
+	out=$($ZPOOL status -vc "$cmd" "$pool" | grep 'led_token=')
+
+	#shellcheck disable=SC2034
+	echo "$out" | while read -r vdev state read write chksum therest; do
+		# Read out current LED value and path
+		tmp=$(echo "$therest" | sed 's/^.*led_token=//g')
+		vdev_enc_sysfs_path=$(echo "$tmp" | awk -F ',' '{print $2}')
+		current_val=$(echo "$tmp" | awk -F ',' '{print $1}')

 		if [ "$current_val" != "0" ] ; then
 			current_val=1
@@ -206,33 +136,40 @@ process_pool()
 			continue
 		fi

-		led_path=$(path_to_led "$vdev_enc_sysfs_path")
-		if [ ! -e "$led_path" ] ; then
-			rc=3
-			zed_log_msg "vdev $vdev '$led_path' doesn't exist"
-			continue
+		if [ ! -e "$vdev_enc_sysfs_path/fault" ] ; then
+			#shellcheck disable=SC2030
+			rc=1
+			zed_log_msg "vdev $vdev '$file/fault' doesn't exist"
+			continue;
 		fi

 		val=$(state_to_val "$state")

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

-		if ! check_and_set_led "$led_path" "$val"; then
-			rc=3
+		if ! check_and_set_led "$vdev_enc_sysfs_path/fault" "$val"; then
+			rc=1
 		fi
+
 	done
-	exit "$rc"; )
+
+	#shellcheck disable=SC2031
+	if [ "$rc" = "0" ] ; then
+		return 0
+	else
+		# We didn't see a sysfs entry that we wanted to set
+		return 3
+	fi
 }

 if [ -n "$ZEVENT_VDEV_ENC_SYSFS_PATH" ] && [ -n "$ZEVENT_VDEV_STATE_STR" ] ; then
-	# Got a statechange for an individual vdev
+	# Got a statechange for an individual VDEV
 	val=$(state_to_val "$ZEVENT_VDEV_STATE_STR")
 	vdev=$(basename "$ZEVENT_VDEV_PATH")
-	ledpath=$(path_to_led "$ZEVENT_VDEV_ENC_SYSFS_PATH")
-	check_and_set_led "$ledpath" "$val"
+	check_and_set_led "$ZEVENT_VDEV_ENC_SYSFS_PATH/fault" "$val"
 else
 	# Process the entire pool
 	poolname=$(zed_guid_to_pool "$ZEVENT_POOL_GUID")
@@ -15,7 +15,7 @@
 # Send notification in response to a fault induced statechange
 #
 # ZEVENT_SUBCLASS: 'statechange'
-# ZEVENT_VDEV_STATE_STR: 'DEGRADED', 'FAULTED', 'REMOVED', or 'UNAVAIL'
+# ZEVENT_VDEV_STATE_STR: 'DEGRADED', 'FAULTED' or 'REMOVED'
 #
 # Exit codes:
 #   0: notification sent
@@ -31,14 +31,13 @@

 if [ "${ZEVENT_VDEV_STATE_STR}" != "FAULTED" ] \
        && [ "${ZEVENT_VDEV_STATE_STR}" != "DEGRADED" ] \
-        && [ "${ZEVENT_VDEV_STATE_STR}" != "REMOVED" ] \
-        && [ "${ZEVENT_VDEV_STATE_STR}" != "UNAVAIL" ]; then
+        && [ "${ZEVENT_VDEV_STATE_STR}" != "REMOVED" ]; then
    exit 3
 fi

 umask 077
 note_subject="ZFS device fault for pool ${ZEVENT_POOL_GUID} on $(hostname)"
-note_pathname="$(mktemp)"
+note_pathname="${TMPDIR:="/tmp"}/$(basename -- "$0").${ZEVENT_EID}.$$"
 {
    if [ "${ZEVENT_VDEV_STATE_STR}" = "FAULTED" ] ; then
        echo "The number of I/O errors associated with a ZFS device exceeded"
@@ -19,7 +19,7 @@ zed_check_cmd "${ZPOOL}" || exit 9

 umask 077
 note_subject="ZFS ${ZEVENT_SUBCLASS} event for ${ZEVENT_POOL} on $(hostname)"
-note_pathname="$(mktemp)"
+note_pathname="${TMPDIR:="/tmp"}/$(basename -- "$0").${ZEVENT_EID}.$$"
 {
    echo "ZFS has finished a trim:"
    echo
@@ -77,7 +77,7 @@ zed_log_msg()
 zed_log_err()
 {
    logger -p "${ZED_SYSLOG_PRIORITY}" -t "${ZED_SYSLOG_TAG}" -- "error:" \
-        "${0##*/}:""${ZEVENT_EID:+" eid=${ZEVENT_EID}:"}" "$@"
+        "$(basename -- "$0"):""${ZEVENT_EID:+" eid=${ZEVENT_EID}:"}" "$@"
 }


@@ -126,8 +126,10 @@ zed_lock()

    # Obtain a lock on the file bound to the given file descriptor.
    #
-    eval "exec ${fd}>> '${lockfile}'"
-    if ! err="$(flock --exclusive "${fd}" 2>&1)"; then
+    eval "exec ${fd}> '${lockfile}'"
+    err="$(flock --exclusive "${fd}" 2>&1)"
+    # shellcheck disable=SC2181
+    if [ $? -ne 0 ]; then
        zed_log_err "failed to lock \"${lockfile}\": ${err}"
    fi

@@ -163,7 +165,9 @@ zed_unlock()
    fi

    # Release the lock and close the file descriptor.
-    if ! err="$(flock --unlock "${fd}" 2>&1)"; then
+    err="$(flock --unlock "${fd}" 2>&1)"
+    # shellcheck disable=SC2181
+    if [ $? -ne 0 ]; then
        zed_log_err "failed to unlock \"${lockfile}\": ${err}"
    fi
    eval "exec ${fd}>&-"
@@ -202,10 +206,6 @@ zed_notify()
    [ "${rv}" -eq 0 ] && num_success=$((num_success + 1))
    [ "${rv}" -eq 1 ] && num_failure=$((num_failure + 1))

-    zed_notify_pushover "${subject}" "${pathname}"; rv=$?
-    [ "${rv}" -eq 0 ] && num_success=$((num_success + 1))
-    [ "${rv}" -eq 1 ] && num_failure=$((num_failure + 1))
-
    [ "${num_success}" -gt 0 ] && return 0
    [ "${num_failure}" -gt 0 ] && return 1
    return 2
@@ -224,8 +224,6 @@ zed_notify()
 # ZED_EMAIL_OPTS.  This undergoes the following keyword substitutions:
 # - @ADDRESS@ is replaced with the space-delimited recipient email address(es)
 # - @SUBJECT@ is replaced with the notification subject
-#   If @SUBJECT@ was omited here, a "Subject: ..." header will be added to notification
-#
 #
 # Arguments
 #   subject: notification subject
@@ -243,7 +241,7 @@ zed_notify()
 #
 zed_notify_email()
 {
-    local subject="${1:-"ZED notification"}"
+    local subject="$1"
    local pathname="${2:-"/dev/null"}"

    : "${ZED_EMAIL_PROG:="mail"}"
@@ -260,30 +258,19 @@ zed_notify_email()
    [ -n "${subject}" ] || return 1
    if [ ! -r "${pathname}" ]; then
        zed_log_err \
-                "${ZED_EMAIL_PROG##*/} cannot read \"${pathname}\""
+                "$(basename "${ZED_EMAIL_PROG}") cannot read \"${pathname}\""
        return 1
    fi

-    # construct cmdline options
-    ZED_EMAIL_OPTS_PARSED="$(echo "${ZED_EMAIL_OPTS}" \
+    ZED_EMAIL_OPTS="$(echo "${ZED_EMAIL_OPTS}" \
        | sed   -e "s/@ADDRESS@/${ZED_EMAIL_ADDR}/g" \
                -e "s/@SUBJECT@/${subject}/g")"

-    # pipe message to email prog
-    # shellcheck disable=SC2086,SC2248
-    {
-        # no subject passed as option?
-        if [ "${ZED_EMAIL_OPTS%@SUBJECT@*}" = "${ZED_EMAIL_OPTS}" ] ; then
-            # inject subject header
-            printf "Subject: %s\n" "${subject}"
-        fi
-        # output message
-        cat "${pathname}"
-    } |
-    eval ${ZED_EMAIL_PROG} ${ZED_EMAIL_OPTS_PARSED} >/dev/null 2>&1
+    # shellcheck disable=SC2086
+    eval "${ZED_EMAIL_PROG}" ${ZED_EMAIL_OPTS} < "${pathname}" >/dev/null 2>&1
    rv=$?
    if [ "${rv}" -ne 0 ]; then
-        zed_log_err "${ZED_EMAIL_PROG##*/} exit=${rv}"
+        zed_log_err "$(basename "${ZED_EMAIL_PROG}") exit=${rv}"
        return 1
    fi
    return 0
@@ -380,7 +367,7 @@ zed_notify_pushbullet()
 #
 # Notification via Slack Webhook <https://api.slack.com/incoming-webhooks>.
 # The Webhook URL (ZED_SLACK_WEBHOOK_URL) identifies this client to the
-# Slack channel.
+# Slack channel. 
 #
 # Requires awk, curl, and sed executables to be installed in the standard PATH.
 #
@@ -430,7 +417,7 @@ zed_notify_slack_webhook()

    # Construct the JSON message for posting.
    #
-    msg_json="$(printf '{"text": "*%s*\\n%s"}' "${subject}" "${msg_body}" )"
+    msg_json="$(printf '{"text": "*%s*\n%s"}' "${subject}" "${msg_body}" )"

    # Send the POST request and check for errors.
    #
@@ -450,84 +437,6 @@ zed_notify_slack_webhook()
    return 0
 }

-# zed_notify_pushover (subject, pathname)
-#
-# Send a notification via Pushover <https://pushover.net/>.
-# The access token (ZED_PUSHOVER_TOKEN) identifies this client to the
-# Pushover server. The user token (ZED_PUSHOVER_USER) defines the user or
-# group to which the notification will be sent.
-#
-# Requires curl and sed executables to be installed in the standard PATH.
-#
-# References
-#   https://pushover.net/api
-#
-# Arguments
-#   subject: notification subject
-#   pathname: pathname containing the notification message (OPTIONAL)
-#
-# Globals
-#   ZED_PUSHOVER_TOKEN
-#   ZED_PUSHOVER_USER
-#
-# Return
-#   0: notification sent
-#   1: notification failed
-#   2: not configured
-#
-zed_notify_pushover()
-{
-    local subject="$1"
-    local pathname="${2:-"/dev/null"}"
-    local msg_body
-    local msg_out
-    local msg_err
-    local url="https://api.pushover.net/1/messages.json"
-
-    [ -n "${ZED_PUSHOVER_TOKEN}" ] && [ -n "${ZED_PUSHOVER_USER}" ] || return 2
-
-    if [ ! -r "${pathname}" ]; then
-        zed_log_err "pushover cannot read \"${pathname}\""
-        return 1
-    fi
-
-    zed_check_cmd "curl" "sed" || return 1
-
-    # Read the message body in.
-    #
-    msg_body="$(cat "${pathname}")"
-
-    if [ -z "${msg_body}" ]
-    then
-        msg_body=$subject
-        subject=""
-    fi
-
-    # Send the POST request and check for errors.
-    #
-    msg_out="$( \
-        curl \
-        --form-string "token=${ZED_PUSHOVER_TOKEN}" \
-        --form-string "user=${ZED_PUSHOVER_USER}" \
-        --form-string "message=${msg_body}" \
-        --form-string "title=${subject}" \
-        "${url}" \
-        2>/dev/null \
-        )"; rv=$?
-    if [ "${rv}" -ne 0 ]; then
-        zed_log_err "curl exit=${rv}"
-        return 1
-    fi
-    msg_err="$(echo "${msg_out}" \
-        | sed -n -e 's/.*"errors" *:.*\[\(.*\)\].*/\1/p')"
-    if [ -n "${msg_err}" ]; then
-        zed_log_err "pushover \"${msg_err}"\"
-        return 1
-    fi
-    return 0
-}
-
-
 # zed_rate_limit (tag, [interval])
 #
 # Check whether an event of a given type [tag] has already occurred within the
@@ -602,8 +511,10 @@ zed_guid_to_pool()
 		return
 	fi

-	guid="$(printf "%u" "$1")"
-	$ZPOOL get -H -ovalue,name guid | awk '$1 == '"$guid"' {print $2; exit}'
+	guid=$(printf "%llu" "$1")
+	if [ -n "$guid" ] ; then
+		$ZPOOL get -H -ovalue,name guid | awk '$1=='"$guid"' {print $2}'
+	fi
 }

 # zed_exit_if_ignoring_this_event
@@ -13,9 +13,9 @@
 # Email address of the zpool administrator for receipt of notifications;
 #   multiple addresses can be specified if they are delimited by whitespace.
 # Email will only be sent if ZED_EMAIL_ADDR is defined.
-# Enabled by default; comment to disable.
+# Disabled by default; uncomment to enable.
 #
-ZED_EMAIL_ADDR="root"
+#ZED_EMAIL_ADDR="root"

 ##
 # Name or path of executable responsible for sending notifications via email;
@@ -30,7 +30,6 @@ ZED_EMAIL_ADDR="root"
 # The string @SUBJECT@ will be replaced with the notification subject;
 #   this should be protected with quotes to prevent word-splitting.
 # Email will only be sent if ZED_EMAIL_ADDR is defined.
-# If @SUBJECT@ was omited here, a "Subject: ..." header will be added to notification
 #
 #ZED_EMAIL_OPTS="-s '@SUBJECT@' @ADDRESS@"

@@ -83,23 +82,6 @@ ZED_EMAIL_ADDR="root"
 #
 #ZED_SLACK_WEBHOOK_URL=""

-##
-# Pushover token.
-# This defines the application from which the notification will be sent.
-#   <https://pushover.net/api#registration>
-# Disabled by default; uncomment to enable.
-# ZED_PUSHOVER_USER, below, must also be configured.
-#
-#ZED_PUSHOVER_TOKEN=""
-
-##
-# Pushover user key.
-# This defines which user or group will receive Pushover notifications.
-#  <https://pushover.net/api#identifiers>
-# Disabled by default; uncomment to enable.
-# ZED_PUSHOVER_TOKEN, above, must also be configured.
-#ZED_PUSHOVER_USER=""
-
 ##
 # Default directory for zed state files.
 #
@@ -107,8 +89,8 @@ ZED_EMAIL_ADDR="root"

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

@@ -3,7 +3,7 @@
 *
 * Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
 * Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
- * Refer to the OpenZFS git commit log for authoritative copyright attribution.
+ * Refer to the ZoL git commit log for authoritative copyright attribution.
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License Version 1.0 (CDDL-1.0).
@@ -15,6 +15,11 @@
 #ifndef	ZED_H
 #define	ZED_H

+/*
+ * Absolute path for the default zed configuration file.
+ */
+#define	ZED_CONF_FILE		SYSCONFDIR "/zfs/zed.conf"
+
 /*
 * Absolute path for the default zed pid file.
 */
@@ -30,6 +35,16 @@
 */
 #define	ZED_ZEDLET_DIR		SYSCONFDIR "/zfs/zed.d"

+/*
+ * Reserved for future use.
+ */
+#define	ZED_MAX_EVENTS		0
+
+/*
+ * Reserved for future use.
+ */
+#define	ZED_MIN_EVENTS		0
+
 /*
 * String prefix for ZED variables passed via environment variables.
 */
@@ -3,7 +3,7 @@
 *
 * Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
 * Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
- * Refer to the OpenZFS git commit log for authoritative copyright attribution.
+ * Refer to the ZoL git commit log for authoritative copyright attribution.
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License Version 1.0 (CDDL-1.0).
@@ -22,7 +22,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/uio.h>
 #include <unistd.h>
@@ -33,26 +32,43 @@
 #include "zed_strings.h"

 /*
- * Initialise the configuration with default values.
+ * Return a new configuration with default values.
 */
-void
-zed_conf_init(struct zed_conf *zcp)
+struct zed_conf *
+zed_conf_create(void)
 {
-	memset(zcp, 0, sizeof (*zcp));
+	struct zed_conf *zcp;

-	/* zcp->zfs_hdl opened in zed_event_init() */
-	/* zcp->zedlets created in zed_conf_scan_dir() */
+	zcp = calloc(1, sizeof (*zcp));
+	if (!zcp)
+		goto nomem;

-	zcp->pid_fd = -1;		/* opened in zed_conf_write_pid() */
-	zcp->state_fd = -1;		/* opened in zed_conf_open_state() */
-	zcp->zevent_fd = -1;		/* opened in zed_event_init() */
+	zcp->syslog_facility = LOG_DAEMON;
+	zcp->min_events = ZED_MIN_EVENTS;
+	zcp->max_events = ZED_MAX_EVENTS;
+	zcp->pid_fd = -1;
+	zcp->zedlets = NULL;		/* created via zed_conf_scan_dir() */
+	zcp->state_fd = -1;		/* opened via zed_conf_open_state() */
+	zcp->zfs_hdl = NULL;		/* opened via zed_event_init() */
+	zcp->zevent_fd = -1;		/* opened via zed_event_init() */

-	zcp->max_jobs = 16;
+	if (!(zcp->conf_file = strdup(ZED_CONF_FILE)))
+		goto nomem;

-	if (!(zcp->pid_file = strdup(ZED_PID_FILE)) ||
-	    !(zcp->zedlet_dir = strdup(ZED_ZEDLET_DIR)) ||
-	    !(zcp->state_file = strdup(ZED_STATE_FILE)))
-		zed_log_die("Failed to create conf: %s", strerror(errno));
+	if (!(zcp->pid_file = strdup(ZED_PID_FILE)))
+		goto nomem;
+
+	if (!(zcp->zedlet_dir = strdup(ZED_ZEDLET_DIR)))
+		goto nomem;
+
+	if (!(zcp->state_file = strdup(ZED_STATE_FILE)))
+		goto nomem;
+
+	return (zcp);
+
+nomem:
+	zed_log_die("Failed to create conf: %s", strerror(errno));
+	return (NULL);
 }

 /*
@@ -63,6 +79,9 @@ zed_conf_init(struct zed_conf *zcp)
 void
 zed_conf_destroy(struct zed_conf *zcp)
 {
+	if (!zcp)
+		return;
+
 	if (zcp->state_fd >= 0) {
 		if (close(zcp->state_fd) < 0)
 			zed_log_msg(LOG_WARNING,
@@ -83,6 +102,10 @@ zed_conf_destroy(struct zed_conf *zcp)
 			    zcp->pid_file, strerror(errno));
 		zcp->pid_fd = -1;
 	}
+	if (zcp->conf_file) {
+		free(zcp->conf_file);
+		zcp->conf_file = NULL;
+	}
 	if (zcp->pid_file) {
 		free(zcp->pid_file);
 		zcp->pid_file = NULL;
@@ -99,6 +122,7 @@ zed_conf_destroy(struct zed_conf *zcp)
 		zed_strings_destroy(zcp->zedlets);
 		zcp->zedlets = NULL;
 	}
+	free(zcp);
 }

 /*
@@ -108,52 +132,46 @@ zed_conf_destroy(struct zed_conf *zcp)
 * otherwise, output to stderr and exit with a failure status.
 */
 static void
-_zed_conf_display_help(const char *prog, boolean_t got_err)
+_zed_conf_display_help(const char *prog, int got_err)
 {
-	struct opt { const char *o, *d, *v; };
-
 	FILE *fp = got_err ? stderr : stdout;
-
-	struct opt *oo;
-	struct opt iopts[] = {
-		{ .o = "-h", .d = "Display help" },
-		{ .o = "-L", .d = "Display license information" },
-		{ .o = "-V", .d = "Display version information" },
-		{},
-	};
-	struct opt nopts[] = {
-		{ .o = "-v", .d = "Be verbose" },
-		{ .o = "-f", .d = "Force daemon to run" },
-		{ .o = "-F", .d = "Run daemon in the foreground" },
-		{ .o = "-I",
-		    .d = "Idle daemon until kernel module is (re)loaded" },
-		{ .o = "-M", .d = "Lock all pages in memory" },
-		{ .o = "-P", .d = "$PATH for ZED to use (only used by ZTS)" },
-		{ .o = "-Z", .d = "Zero state file" },
-		{},
-	};
-	struct opt vopts[] = {
-		{ .o = "-d DIR", .d = "Read enabled ZEDLETs from DIR.",
-		    .v = ZED_ZEDLET_DIR },
-		{ .o = "-p FILE", .d = "Write daemon's PID to FILE.",
-		    .v = ZED_PID_FILE },
-		{ .o = "-s FILE", .d = "Write daemon's state to FILE.",
-		    .v = ZED_STATE_FILE },
-		{ .o = "-j JOBS", .d = "Start at most JOBS at once.",
-		    .v = "16" },
-		{},
-	};
+	int w1 = 4;			/* width of leading whitespace */
+	int w2 = 8;			/* width of L-justified option field */

 	fprintf(fp, "Usage: %s [OPTION]...\n", (prog ? prog : "zed"));
 	fprintf(fp, "\n");
-	for (oo = iopts; oo->o; ++oo)
-		fprintf(fp, "    %*s %s\n", -8, oo->o, oo->d);
+	fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-h",
+	    "Display help.");
+	fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-L",
+	    "Display license information.");
+	fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-V",
+	    "Display version information.");
 	fprintf(fp, "\n");
-	for (oo = nopts; oo->o; ++oo)
-		fprintf(fp, "    %*s %s\n", -8, oo->o, oo->d);
+	fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-v",
+	    "Be verbose.");
+	fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-f",
+	    "Force daemon to run.");
+	fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-F",
+	    "Run daemon in the foreground.");
+	fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-I",
+	    "Idle daemon until kernel module is (re)loaded.");
+	fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-M",
+	    "Lock all pages in memory.");
+	fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-P",
+	    "$PATH for ZED to use (only used by ZTS).");
+	fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-Z",
+	    "Zero state file.");
 	fprintf(fp, "\n");
-	for (oo = vopts; oo->o; ++oo)
-		fprintf(fp, "    %*s %s [%s]\n", -8, oo->o, oo->d, oo->v);
+#if 0
+	fprintf(fp, "%*c%*s %s [%s]\n", w1, 0x20, -w2, "-c FILE",
+	    "Read configuration from FILE.", ZED_CONF_FILE);
+#endif
+	fprintf(fp, "%*c%*s %s [%s]\n", w1, 0x20, -w2, "-d DIR",
+	    "Read enabled ZEDLETs from DIR.", ZED_ZEDLET_DIR);
+	fprintf(fp, "%*c%*s %s [%s]\n", w1, 0x20, -w2, "-p FILE",
+	    "Write daemon's PID to FILE.", ZED_PID_FILE);
+	fprintf(fp, "%*c%*s %s [%s]\n", w1, 0x20, -w2, "-s FILE",
+	    "Write daemon's state to FILE.", ZED_STATE_FILE);
 	fprintf(fp, "\n");

 	exit(got_err ? EXIT_FAILURE : EXIT_SUCCESS);
@@ -165,14 +183,20 @@ _zed_conf_display_help(const char *prog, boolean_t got_err)
 static void
 _zed_conf_display_license(void)
 {
-	printf(
-	    "The ZFS Event Daemon (ZED) is distributed under the terms of the\n"
-	    "  Common Development and Distribution License (CDDL-1.0)\n"
-	    "  <http://opensource.org/licenses/CDDL-1.0>.\n"
-	    "\n"
+	const char **pp;
+	const char *text[] = {
+	    "The ZFS Event Daemon (ZED) is distributed under the terms of the",
+	    "  Common Development and Distribution License (CDDL-1.0)",
+	    "  <http://opensource.org/licenses/CDDL-1.0>.",
+	    "",
 	    "Developed at Lawrence Livermore National Laboratory"
-	    " (LLNL-CODE-403049).\n"
-	    "\n");
+	    " (LLNL-CODE-403049).",
+	    "",
+	    NULL
+	};
+
+	for (pp = text; *pp; pp++)
+		printf("%s\n", *pp);

 	exit(EXIT_SUCCESS);
 }
@@ -207,19 +231,16 @@ _zed_conf_parse_path(char **resultp, const char *path)

 	if (path[0] == '/') {
 		*resultp = strdup(path);
+	} else if (!getcwd(buf, sizeof (buf))) {
+		zed_log_die("Failed to get current working dir: %s",
+		    strerror(errno));
+	} else if (strlcat(buf, "/", sizeof (buf)) >= sizeof (buf)) {
+		zed_log_die("Failed to copy path: %s", strerror(ENAMETOOLONG));
+	} else if (strlcat(buf, path, sizeof (buf)) >= sizeof (buf)) {
+		zed_log_die("Failed to copy path: %s", strerror(ENAMETOOLONG));
 	} else {
-		if (!getcwd(buf, sizeof (buf)))
-			zed_log_die("Failed to get current working dir: %s",
-			    strerror(errno));
-
-		if (strlcat(buf, "/", sizeof (buf)) >= sizeof (buf) ||
-		    strlcat(buf, path, sizeof (buf)) >= sizeof (buf))
-			zed_log_die("Failed to copy path: %s",
-			    strerror(ENAMETOOLONG));
-
 		*resultp = strdup(buf);
 	}
-
 	if (!*resultp)
 		zed_log_die("Failed to copy path: %s", strerror(ENOMEM));
 }
@@ -230,9 +251,8 @@ _zed_conf_parse_path(char **resultp, const char *path)
 void
 zed_conf_parse_opts(struct zed_conf *zcp, int argc, char **argv)
 {
-	const char * const opts = ":hLVd:p:P:s:vfFMZIj:";
+	const char * const opts = ":hLVc:d:p:P:s:vfFMZI";
 	int opt;
-	unsigned long raw;

 	if (!zcp || !argv || !argv[0])
 		zed_log_die("Failed to parse options: Internal error");
@@ -242,7 +262,7 @@ zed_conf_parse_opts(struct zed_conf *zcp, int argc, char **argv)
 	while ((opt = getopt(argc, argv, opts)) != -1) {
 		switch (opt) {
 		case 'h':
-			_zed_conf_display_help(argv[0], B_FALSE);
+			_zed_conf_display_help(argv[0], EXIT_SUCCESS);
 			break;
 		case 'L':
 			_zed_conf_display_license();
@@ -250,6 +270,9 @@ zed_conf_parse_opts(struct zed_conf *zcp, int argc, char **argv)
 		case 'V':
 			_zed_conf_display_version();
 			break;
+		case 'c':
+			_zed_conf_parse_path(&zcp->conf_file, optarg);
+			break;
 		case 'd':
 			_zed_conf_parse_path(&zcp->zedlet_dir, optarg);
 			break;
@@ -280,30 +303,31 @@ zed_conf_parse_opts(struct zed_conf *zcp, int argc, char **argv)
 		case 'Z':
 			zcp->do_zero = 1;
 			break;
-		case 'j':
-			errno = 0;
-			raw = strtoul(optarg, NULL, 0);
-			if (errno == ERANGE || raw > INT16_MAX) {
-				zed_log_die("%lu is too many jobs", raw);
-			} if (raw == 0) {
-				zed_log_die("0 jobs makes no sense");
-			} else {
-				zcp->max_jobs = raw;
-			}
-			break;
 		case '?':
 		default:
 			if (optopt == '?')
-				_zed_conf_display_help(argv[0], B_FALSE);
+				_zed_conf_display_help(argv[0], EXIT_SUCCESS);

-			fprintf(stderr, "%s: Invalid option '-%c'\n\n",
-			    argv[0], optopt);
-			_zed_conf_display_help(argv[0], B_TRUE);
+			fprintf(stderr, "%s: %s '-%c'\n\n", argv[0],
+			    "Invalid option", optopt);
+			_zed_conf_display_help(argv[0], EXIT_FAILURE);
 			break;
 		}
 	}
 }

+/*
+ * Parse the configuration file into the configuration [zcp].
+ *
+ * FIXME: Not yet implemented.
+ */
+void
+zed_conf_parse_file(struct zed_conf *zcp)
+{
+	if (!zcp)
+		zed_log_die("Failed to parse config: %s", strerror(EINVAL));
+}
+
 /*
 * Scan the [zcp] zedlet_dir for files to exec based on the event class.
 * Files must be executable by user, but not writable by group or other.
@@ -311,6 +335,8 @@ zed_conf_parse_opts(struct zed_conf *zcp, int argc, char **argv)
 *
 * Return 0 on success with an updated set of zedlets,
 * or -1 on error with errno set.
+ *
+ * FIXME: Check if zedlet_dir and all parent dirs are secure.
 */
 int
 zed_conf_scan_dir(struct zed_conf *zcp)
@@ -426,6 +452,8 @@ zed_conf_scan_dir(struct zed_conf *zcp)
 int
 zed_conf_write_pid(struct zed_conf *zcp)
 {
+	const mode_t dirmode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
+	const mode_t filemode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
 	char buf[PATH_MAX];
 	int n;
 	char *p;
@@ -453,7 +481,7 @@ zed_conf_write_pid(struct zed_conf *zcp)
 	if (p)
 		*p = '\0';

-	if ((mkdirp(buf, 0755) < 0) && (errno != EEXIST)) {
+	if ((mkdirp(buf, dirmode) < 0) && (errno != EEXIST)) {
 		zed_log_msg(LOG_ERR, "Failed to create directory \"%s\": %s",
 		    buf, strerror(errno));
 		goto err;
@@ -463,7 +491,7 @@ zed_conf_write_pid(struct zed_conf *zcp)
 	 */
 	mask = umask(0);
 	umask(mask | 022);
-	zcp->pid_fd = open(zcp->pid_file, O_RDWR | O_CREAT | O_CLOEXEC, 0644);
+	zcp->pid_fd = open(zcp->pid_file, (O_RDWR | O_CREAT), filemode);
 	umask(mask);
 	if (zcp->pid_fd < 0) {
 		zed_log_msg(LOG_ERR, "Failed to open PID file \"%s\": %s",
@@ -500,7 +528,7 @@ zed_conf_write_pid(struct zed_conf *zcp)
 		errno = ERANGE;
 		zed_log_msg(LOG_ERR, "Failed to write PID file \"%s\": %s",
 		    zcp->pid_file, strerror(errno));
-	} else if (write(zcp->pid_fd, buf, n) != n) {
+	} else if (zed_file_write_n(zcp->pid_fd, buf, n) != n) {
 		zed_log_msg(LOG_ERR, "Failed to write PID file \"%s\": %s",
 		    zcp->pid_file, strerror(errno));
 	} else if (fdatasync(zcp->pid_fd) < 0) {
@@ -528,6 +556,7 @@ int
 zed_conf_open_state(struct zed_conf *zcp)
 {
 	char dirbuf[PATH_MAX];
+	mode_t dirmode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
 	int n;
 	char *p;
 	int rv;
@@ -549,7 +578,7 @@ zed_conf_open_state(struct zed_conf *zcp)
 	if (p)
 		*p = '\0';

-	if ((mkdirp(dirbuf, 0755) < 0) && (errno != EEXIST)) {
+	if ((mkdirp(dirbuf, dirmode) < 0) && (errno != EEXIST)) {
 		zed_log_msg(LOG_WARNING,
 		    "Failed to create directory \"%s\": %s",
 		    dirbuf, strerror(errno));
@@ -567,7 +596,7 @@ zed_conf_open_state(struct zed_conf *zcp)
 		(void) unlink(zcp->state_file);

 	zcp->state_fd = open(zcp->state_file,
-	    O_RDWR | O_CREAT | O_CLOEXEC, 0644);
+	    (O_RDWR | O_CREAT), (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH));
 	if (zcp->state_fd < 0) {
 		zed_log_msg(LOG_WARNING, "Failed to open state file \"%s\": %s",
 		    zcp->state_file, strerror(errno));
@@ -3,7 +3,7 @@
 *
 * Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
 * Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
- * Refer to the OpenZFS git commit log for authoritative copyright attribution.
+ * Refer to the ZoL git commit log for authoritative copyright attribution.
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License Version 1.0 (CDDL-1.0).
@@ -20,39 +20,43 @@
 #include "zed_strings.h"

 struct zed_conf {
+	unsigned	do_force:1;		/* true if force enabled */
+	unsigned	do_foreground:1;	/* true if run in foreground */
+	unsigned	do_memlock:1;		/* true if locking memory */
+	unsigned	do_verbose:1;		/* true if verbosity enabled */
+	unsigned	do_zero:1;		/* true if zeroing state */
+	unsigned	do_idle:1;		/* true if idle enabled */
+	int		syslog_facility;	/* syslog facility value */
+	int		min_events;		/* RESERVED FOR FUTURE USE */
+	int		max_events;		/* RESERVED FOR FUTURE USE */
+	char		*conf_file;		/* abs path to config file */
 	char		*pid_file;		/* abs path to pid file */
-	char		*zedlet_dir;		/* abs path to zedlet dir */
-	char		*state_file;		/* abs path to state file */
-
-	libzfs_handle_t	*zfs_hdl;		/* handle to libzfs */
-	zed_strings_t	*zedlets;		/* names of enabled zedlets */
-	char		*path;		/* custom $PATH for zedlets to use */
-
 	int		pid_fd;			/* fd to pid file for lock */
+	char		*zedlet_dir;		/* abs path to zedlet dir */
+	zed_strings_t	*zedlets;		/* names of enabled zedlets */
+	char		*state_file;		/* abs path to state file */
 	int		state_fd;		/* fd to state file */
+	libzfs_handle_t	*zfs_hdl;		/* handle to libzfs */
 	int		zevent_fd;		/* fd for access to zevents */
-
-	int16_t max_jobs;		/* max zedlets to run at one time */
-
-	boolean_t	do_force:1;		/* true if force enabled */
-	boolean_t	do_foreground:1;	/* true if run in foreground */
-	boolean_t	do_memlock:1;		/* true if locking memory */
-	boolean_t	do_verbose:1;		/* true if verbosity enabled */
-	boolean_t	do_zero:1;		/* true if zeroing state */
-	boolean_t	do_idle:1;		/* true if idle enabled */
+	char		*path;		/* custom $PATH for zedlets to use */
 };

-void zed_conf_init(struct zed_conf *zcp);
+struct zed_conf *zed_conf_create(void);
+
 void zed_conf_destroy(struct zed_conf *zcp);

 void zed_conf_parse_opts(struct zed_conf *zcp, int argc, char **argv);

+void zed_conf_parse_file(struct zed_conf *zcp);
+
 int zed_conf_scan_dir(struct zed_conf *zcp);

 int zed_conf_write_pid(struct zed_conf *zcp);

 int zed_conf_open_state(struct zed_conf *zcp);
+
 int zed_conf_read_state(struct zed_conf *zcp, uint64_t *eidp, int64_t etime[]);
+
 int zed_conf_write_state(struct zed_conf *zcp, uint64_t eid, int64_t etime[]);

 #endif	/* !ZED_CONF_H */
@@ -72,14 +72,10 @@ zed_udev_event(const char *class, const char *subclass, nvlist_t *nvl)
 		zed_log_msg(LOG_INFO, "\t%s: %s", DEV_PATH, strval);
 	if (nvlist_lookup_string(nvl, DEV_IDENTIFIER, &strval) == 0)
 		zed_log_msg(LOG_INFO, "\t%s: %s", DEV_IDENTIFIER, strval);
-	if (nvlist_lookup_boolean(nvl, DEV_IS_PART) == B_TRUE)
-		zed_log_msg(LOG_INFO, "\t%s: B_TRUE", DEV_IS_PART);
 	if (nvlist_lookup_string(nvl, DEV_PHYS_PATH, &strval) == 0)
 		zed_log_msg(LOG_INFO, "\t%s: %s", DEV_PHYS_PATH, strval);
 	if (nvlist_lookup_uint64(nvl, DEV_SIZE, &numval) == 0)
 		zed_log_msg(LOG_INFO, "\t%s: %llu", DEV_SIZE, numval);
-	if (nvlist_lookup_uint64(nvl, DEV_PARENT_SIZE, &numval) == 0)
-		zed_log_msg(LOG_INFO, "\t%s: %llu", DEV_PARENT_SIZE, numval);
 	if (nvlist_lookup_uint64(nvl, ZFS_EV_POOL_GUID, &numval) == 0)
 		zed_log_msg(LOG_INFO, "\t%s: %llu", ZFS_EV_POOL_GUID, numval);
 	if (nvlist_lookup_uint64(nvl, ZFS_EV_VDEV_GUID, &numval) == 0)
@@ -132,20 +128,6 @@ dev_event_nvlist(struct udev_device *dev)

 		numval *= strtoull(value, NULL, 10);
 		(void) nvlist_add_uint64(nvl, DEV_SIZE, numval);
-
-		/*
-		 * If the device has a parent, then get the parent block
-		 * device's size as well.  For example, /dev/sda1's parent
-		 * is /dev/sda.
-		 */
-		struct udev_device *parent_dev = udev_device_get_parent(dev);
-		if ((value = udev_device_get_sysattr_value(parent_dev, "size"))
-		    != NULL) {
-			uint64_t numval = DEV_BSIZE;
-
-			numval *= strtoull(value, NULL, 10);
-			(void) nvlist_add_uint64(nvl, DEV_PARENT_SIZE, numval);
-		}
 	}

 	/*
@@ -185,7 +167,7 @@ zed_udev_monitor(void *arg)
 	while (1) {
 		struct udev_device *dev;
 		const char *action, *type, *part, *sectors;
-		const char *bus, *uuid, *devpath;
+		const char *bus, *uuid;
 		const char *class, *subclass;
 		nvlist_t *nvl;
 		boolean_t is_zfs = B_FALSE;
@@ -224,12 +206,6 @@ zed_udev_monitor(void *arg)
 		 * if this is a disk and it is partitioned, then the
 		 * zfs label will reside in a DEVTYPE=partition and
 		 * we can skip passing this event
-		 *
-		 * Special case: Blank disks are sometimes reported with
-		 * an erroneous 'atari' partition, and should not be
-		 * excluded from being used as an autoreplace disk:
-		 *
-		 * https://github.com/openzfs/zfs/issues/13497
 		 */
 		type = udev_device_get_property_value(dev, "DEVTYPE");
 		part = udev_device_get_property_value(dev,
@@ -237,23 +213,9 @@ zed_udev_monitor(void *arg)
 		if (type != NULL && type[0] != '\0' &&
 		    strcmp(type, "disk") == 0 &&
 		    part != NULL && part[0] != '\0') {
-			const char *devname =
-			    udev_device_get_property_value(dev, "DEVNAME");
-
-			if (strcmp(part, "atari") == 0) {
-				zed_log_msg(LOG_INFO,
-				    "%s: %s is reporting an atari partition, "
-				    "but we're going to assume it's a false "
-				    "positive and still use it (issue #13497)",
-				    __func__, devname);
-			} else {
-				zed_log_msg(LOG_INFO,
-				    "%s: skip %s since it has a %s partition "
-				    "already", __func__, devname, part);
-				/* skip and wait for partition event */
-				udev_device_unref(dev);
-				continue;
-			}
+			/* skip and wait for partition event */
+			udev_device_unref(dev);
+			continue;
 		}

 		/*
@@ -265,11 +227,6 @@ zed_udev_monitor(void *arg)
 			sectors = udev_device_get_sysattr_value(dev, "size");
 		if (sectors != NULL &&
 		    strtoull(sectors, NULL, 10) < MINIMUM_SECTORS) {
-			zed_log_msg(LOG_INFO,
-			    "%s: %s sectors %s < %llu (minimum)",
-			    __func__,
-			    udev_device_get_property_value(dev, "DEVNAME"),
-			    sectors, MINIMUM_SECTORS);
 			udev_device_unref(dev);
 			continue;
 		}
@@ -279,19 +236,10 @@ zed_udev_monitor(void *arg)
 		 * device id string is required in the message schema
 		 * for matching with vdevs. Preflight here for expected
 		 * udev information.
-		 *
-		 * Special case:
-		 * NVMe devices don't have ID_BUS set (at least on RHEL 7-8),
-		 * but they are valid for autoreplace.  Add a special case for
-		 * them by searching for "/nvme/" in the udev DEVPATH:
-		 *
-		 * DEVPATH=/devices/pci0000:00/0000:00:1e.0/nvme/nvme2/nvme2n1
 		 */
 		bus = udev_device_get_property_value(dev, "ID_BUS");
 		uuid = udev_device_get_property_value(dev, "DM_UUID");
-		devpath = udev_device_get_devpath(dev);
-		if (!is_zfs && (bus == NULL && uuid == NULL &&
-		    strstr(devpath, "/nvme/") == NULL)) {
+		if (!is_zfs && (bus == NULL && uuid == NULL)) {
 			zed_log_msg(LOG_INFO, "zed_udev_monitor: %s no devid "
 			    "source", udev_device_get_devnode(dev));
 			udev_device_unref(dev);
@@ -431,7 +379,6 @@ zed_disk_event_init()
 		return (-1);
 	}

-	pthread_setname_np(g_mon_tid, "udev monitor");
 	zed_log_msg(LOG_INFO, "zed_disk_event_init");

 	return (0);
@@ -3,7 +3,7 @@
 *
 * Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
 * Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
- * Refer to the OpenZFS git commit log for authoritative copyright attribution.
+ * Refer to the ZoL git commit log for authoritative copyright attribution.
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License Version 1.0 (CDDL-1.0).
@@ -15,7 +15,7 @@
 #include <ctype.h>
 #include <errno.h>
 #include <fcntl.h>
-#include <libzfs_core.h>
+#include <libzfs.h>			/* FIXME: Replace with libzfs_core. */
 #include <paths.h>
 #include <stdarg.h>
 #include <stdio.h>
@@ -54,7 +54,7 @@ zed_event_init(struct zed_conf *zcp)
 		zed_log_die("Failed to initialize libzfs");
 	}

-	zcp->zevent_fd = open(ZFS_DEV, O_RDWR | O_CLOEXEC);
+	zcp->zevent_fd = open(ZFS_DEV, O_RDWR);
 	if (zcp->zevent_fd < 0) {
 		if (zcp->do_idle)
 			return (-1);
@@ -96,47 +96,6 @@ zed_event_fini(struct zed_conf *zcp)
 		libzfs_fini(zcp->zfs_hdl);
 		zcp->zfs_hdl = NULL;
 	}
-
-	zed_exec_fini();
-}
-
-static void
-_bump_event_queue_length(void)
-{
-	int zzlm = -1, wr;
-	char qlen_buf[12] = {0}; /* parameter is int => max "-2147483647\n" */
-	long int qlen;
-
-	zzlm = open("/sys/module/zfs/parameters/zfs_zevent_len_max", O_RDWR);
-	if (zzlm < 0)
-		goto done;
-
-	if (read(zzlm, qlen_buf, sizeof (qlen_buf)) < 0)
-		goto done;
-	qlen_buf[sizeof (qlen_buf) - 1] = '\0';
-
-	errno = 0;
-	qlen = strtol(qlen_buf, NULL, 10);
-	if (errno == ERANGE)
-		goto done;
-
-	if (qlen <= 0)
-		qlen = 512; /* default zfs_zevent_len_max value */
-	else
-		qlen *= 2;
-
-	if (qlen > INT_MAX)
-		qlen = INT_MAX;
-	wr = snprintf(qlen_buf, sizeof (qlen_buf), "%ld", qlen);
-
-	if (pwrite(zzlm, qlen_buf, wr, 0) < 0)
-		goto done;
-
-	zed_log_msg(LOG_WARNING, "Bumping queue length to %ld", qlen);
-
-done:
-	if (zzlm > -1)
-		(void) close(zzlm);
 }

 /*
@@ -177,7 +136,10 @@ zed_event_seek(struct zed_conf *zcp, uint64_t saved_eid, int64_t saved_etime[])

 		if (n_dropped > 0) {
 			zed_log_msg(LOG_WARNING, "Missed %d events", n_dropped);
-			_bump_event_queue_length();
+			/*
+			 * FIXME: Increase max size of event nvlist in
+			 *   /sys/module/zfs/parameters/zfs_zevent_len_max ?
+			 */
 		}
 		if (nvlist_lookup_uint64(nvl, "eid", &eid) != 0) {
 			zed_log_msg(LOG_WARNING, "Failed to lookup zevent eid");
@@ -249,7 +211,7 @@ _zed_event_value_is_hex(const char *name)
 *
 * All environment variables in [zsp] should be added through this function.
 */
-static __attribute__((format(printf, 5, 6))) int
+static int
 _zed_event_add_var(uint64_t eid, zed_strings_t *zsp,
    const char *prefix, const char *name, const char *fmt, ...)
 {
@@ -624,6 +586,8 @@ _zed_event_add_string_array(uint64_t eid, zed_strings_t *zsp,
 * Convert the nvpair [nvp] to a string which is added to the environment
 * of the child process.
 * Return 0 on success, -1 on error.
+ *
+ * FIXME: Refactor with cmd/zpool/zpool_main.c:zpool_do_events_nvprint()?
 */
 static void
 _zed_event_add_nvpair(uint64_t eid, zed_strings_t *zsp, nvpair_t *nvp)
@@ -722,11 +686,23 @@ _zed_event_add_nvpair(uint64_t eid, zed_strings_t *zsp, nvpair_t *nvp)
 		_zed_event_add_var(eid, zsp, prefix, name,
 		    "%llu", (u_longlong_t)i64);
 		break;
+	case DATA_TYPE_NVLIST:
+		_zed_event_add_var(eid, zsp, prefix, name,
+		    "%s", "_NOT_IMPLEMENTED_");			/* FIXME */
+		break;
 	case DATA_TYPE_STRING:
 		(void) nvpair_value_string(nvp, &str);
 		_zed_event_add_var(eid, zsp, prefix, name,
 		    "%s", (str ? str : "<NULL>"));
 		break;
+	case DATA_TYPE_BOOLEAN_ARRAY:
+		_zed_event_add_var(eid, zsp, prefix, name,
+		    "%s", "_NOT_IMPLEMENTED_");			/* FIXME */
+		break;
+	case DATA_TYPE_BYTE_ARRAY:
+		_zed_event_add_var(eid, zsp, prefix, name,
+		    "%s", "_NOT_IMPLEMENTED_");			/* FIXME */
+		break;
 	case DATA_TYPE_INT8_ARRAY:
 		_zed_event_add_int8_array(eid, zsp, prefix, nvp);
 		break;
@@ -754,11 +730,9 @@ _zed_event_add_nvpair(uint64_t eid, zed_strings_t *zsp, nvpair_t *nvp)
 	case DATA_TYPE_STRING_ARRAY:
 		_zed_event_add_string_array(eid, zsp, prefix, nvp);
 		break;
-	case DATA_TYPE_NVLIST:
-	case DATA_TYPE_BOOLEAN_ARRAY:
-	case DATA_TYPE_BYTE_ARRAY:
 	case DATA_TYPE_NVLIST_ARRAY:
-		_zed_event_add_var(eid, zsp, prefix, name, "_NOT_IMPLEMENTED_");
+		_zed_event_add_var(eid, zsp, prefix, name,
+		    "%s", "_NOT_IMPLEMENTED_");			/* FIXME */
 		break;
 	default:
 		errno = EINVAL;
@@ -938,7 +912,10 @@ zed_event_service(struct zed_conf *zcp)

 	if (n_dropped > 0) {
 		zed_log_msg(LOG_WARNING, "Missed %d events", n_dropped);
-		_bump_event_queue_length();
+		/*
+		 * FIXME: Increase max size of event nvlist in
+		 * /sys/module/zfs/parameters/zfs_zevent_len_max ?
+		 */
 	}
 	if (nvlist_lookup_uint64(nvl, "eid", &eid) != 0) {
 		zed_log_msg(LOG_WARNING, "Failed to lookup zevent eid");
@@ -976,7 +953,8 @@ zed_event_service(struct zed_conf *zcp)

 		_zed_event_add_time_strings(eid, zsp, etime);

-		zed_exec_process(eid, class, subclass, zcp, zsp);
+		zed_exec_process(eid, class, subclass,
+		    zcp->zedlet_dir, zcp->zedlets, zsp, zcp->zevent_fd);

 		zed_conf_write_state(zcp, eid, etime);

@@ -3,7 +3,7 @@
 *
 * Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
 * Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
- * Refer to the OpenZFS git commit log for authoritative copyright attribution.
+ * Refer to the ZoL git commit log for authoritative copyright attribution.
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License Version 1.0 (CDDL-1.0).
@@ -3,7 +3,7 @@
 *
 * Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
 * Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
- * Refer to the OpenZFS git commit log for authoritative copyright attribution.
+ * Refer to the ZoL git commit log for authoritative copyright attribution.
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License Version 1.0 (CDDL-1.0).
@@ -18,55 +18,17 @@
 #include <fcntl.h>
 #include <stdlib.h>
 #include <string.h>
-#include <stddef.h>
-#include <sys/avl.h>
-#include <sys/resource.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
 #include <time.h>
 #include <unistd.h>
-#include <pthread.h>
-#include <signal.h>
-
 #include "zed_exec.h"
+#include "zed_file.h"
 #include "zed_log.h"
 #include "zed_strings.h"

 #define	ZEVENT_FILENO	3

-struct launched_process_node {
-	avl_node_t node;
-	pid_t pid;
-	uint64_t eid;
-	char *name;
-};
-
-static int
-_launched_process_node_compare(const void *x1, const void *x2)
-{
-	pid_t p1;
-	pid_t p2;
-
-	assert(x1 != NULL);
-	assert(x2 != NULL);
-
-	p1 = ((const struct launched_process_node *) x1)->pid;
-	p2 = ((const struct launched_process_node *) x2)->pid;
-
-	if (p1 < p2)
-		return (-1);
-	else if (p1 == p2)
-		return (0);
-	else
-		return (1);
-}
-
-static pthread_t _reap_children_tid = (pthread_t)-1;
-static volatile boolean_t _reap_children_stop;
-static avl_tree_t _launched_processes;
-static pthread_mutex_t _launched_processes_lock = PTHREAD_MUTEX_INITIALIZER;
-static int16_t _launched_processes_limit;
-
 /*
 * Create an environment string array for passing to execve() using the
 * NAME=VALUE strings in container [zsp].
@@ -117,26 +79,20 @@ _zed_exec_create_env(zed_strings_t *zsp)
 */
 static void
 _zed_exec_fork_child(uint64_t eid, const char *dir, const char *prog,
-    char *env[], int zfd, boolean_t in_foreground)
+    char *env[], int zfd)
 {
 	char path[PATH_MAX];
 	int n;
 	pid_t pid;
 	int fd;
-	struct launched_process_node *node;
-	sigset_t mask;
-	struct timespec launch_timeout =
-		{ .tv_sec = 0, .tv_nsec = 200 * 1000 * 1000, };
+	pid_t wpid;
+	int status;

 	assert(dir != NULL);
 	assert(prog != NULL);
 	assert(env != NULL);
 	assert(zfd >= 0);

-	while (__atomic_load_n(&_launched_processes_limit,
-	    __ATOMIC_SEQ_CST) <= 0)
-		(void) nanosleep(&launch_timeout, NULL);
-
 	n = snprintf(path, sizeof (path), "%s/%s", dir, prog);
 	if ((n < 0) || (n >= sizeof (path))) {
 		zed_log_msg(LOG_WARNING,
@@ -144,179 +100,100 @@ _zed_exec_fork_child(uint64_t eid, const char *dir, const char *prog,
 		    prog, eid, strerror(ENAMETOOLONG));
 		return;
 	}
-	(void) pthread_mutex_lock(&_launched_processes_lock);
 	pid = fork();
 	if (pid < 0) {
-		(void) pthread_mutex_unlock(&_launched_processes_lock);
 		zed_log_msg(LOG_WARNING,
 		    "Failed to fork \"%s\" for eid=%llu: %s",
 		    prog, eid, strerror(errno));
 		return;
 	} else if (pid == 0) {
-		(void) sigemptyset(&mask);
-		(void) sigprocmask(SIG_SETMASK, &mask, NULL);
-
 		(void) umask(022);
-		if (in_foreground && /* we're already devnulled if daemonised */
-		    (fd = open("/dev/null", O_RDWR | O_CLOEXEC)) != -1) {
+		if ((fd = open("/dev/null", O_RDWR)) != -1) {
 			(void) dup2(fd, STDIN_FILENO);
 			(void) dup2(fd, STDOUT_FILENO);
 			(void) dup2(fd, STDERR_FILENO);
 		}
 		(void) dup2(zfd, ZEVENT_FILENO);
+		zed_file_close_from(ZEVENT_FILENO + 1);
 		execle(path, prog, NULL, env);
 		_exit(127);
 	}

 	/* parent process */

-	node = calloc(1, sizeof (*node));
-	if (node) {
-		node->pid = pid;
-		node->eid = eid;
-		node->name = strdup(prog);
-
-		avl_add(&_launched_processes, node);
-	}
-	(void) pthread_mutex_unlock(&_launched_processes_lock);
-
-	__atomic_sub_fetch(&_launched_processes_limit, 1, __ATOMIC_SEQ_CST);
 	zed_log_msg(LOG_INFO, "Invoking \"%s\" eid=%llu pid=%d",
 	    prog, eid, pid);
-}

-static void
-_nop(int sig)
-{}
+	/* FIXME: Timeout rogue child processes with sigalarm? */

-static void *
-_reap_children(void *arg)
-{
-	struct launched_process_node node, *pnode;
-	pid_t pid;
-	int status;
-	struct rusage usage;
-	struct sigaction sa = {};
+	/*
+	 * Wait for child process using WNOHANG to limit
+	 * the time spent waiting to 10 seconds (10,000ms).
+	 */
+	for (n = 0; n < 1000; n++) {
+		wpid = waitpid(pid, &status, WNOHANG);
+		if (wpid == (pid_t)-1) {
+			if (errno == EINTR)
+				continue;
+			zed_log_msg(LOG_WARNING,
+			    "Failed to wait for \"%s\" eid=%llu pid=%d",
+			    prog, eid, pid);
+			break;
+		} else if (wpid == 0) {
+			struct timespec t;

-	(void) sigfillset(&sa.sa_mask);
-	(void) sigdelset(&sa.sa_mask, SIGCHLD);
-	(void) pthread_sigmask(SIG_SETMASK, &sa.sa_mask, NULL);
-
-	(void) sigemptyset(&sa.sa_mask);
-	sa.sa_handler = _nop;
-	sa.sa_flags = SA_NOCLDSTOP;
-	(void) sigaction(SIGCHLD, &sa, NULL);
-
-	for (_reap_children_stop = B_FALSE; !_reap_children_stop; ) {
-		(void) pthread_mutex_lock(&_launched_processes_lock);
-		pid = wait4(0, &status, WNOHANG, &usage);
-
-		if (pid == 0 || pid == (pid_t)-1) {
-			(void) pthread_mutex_unlock(&_launched_processes_lock);
-			if (pid == 0 || errno == ECHILD)
-				pause();
-			else if (errno != EINTR)
-				zed_log_msg(LOG_WARNING,
-				    "Failed to wait for children: %s",
-				    strerror(errno));
-		} else {
-			memset(&node, 0, sizeof (node));
-			node.pid = pid;
-			pnode = avl_find(&_launched_processes, &node, NULL);
-			if (pnode) {
-				memcpy(&node, pnode, sizeof (node));
-
-				avl_remove(&_launched_processes, pnode);
-				free(pnode);
-			}
-			(void) pthread_mutex_unlock(&_launched_processes_lock);
-			__atomic_add_fetch(&_launched_processes_limit, 1,
-			    __ATOMIC_SEQ_CST);
-
-			usage.ru_utime.tv_sec += usage.ru_stime.tv_sec;
-			usage.ru_utime.tv_usec += usage.ru_stime.tv_usec;
-			usage.ru_utime.tv_sec +=
-			    usage.ru_utime.tv_usec / (1000 * 1000);
-			usage.ru_utime.tv_usec %= 1000 * 1000;
-
-			if (WIFEXITED(status)) {
-				zed_log_msg(LOG_INFO,
-				    "Finished \"%s\" eid=%llu pid=%d "
-				    "time=%llu.%06us exit=%d",
-				    node.name, node.eid, pid,
-				    (unsigned long long) usage.ru_utime.tv_sec,
-				    (unsigned int) usage.ru_utime.tv_usec,
-				    WEXITSTATUS(status));
-			} else if (WIFSIGNALED(status)) {
-				zed_log_msg(LOG_INFO,
-				    "Finished \"%s\" eid=%llu pid=%d "
-				    "time=%llu.%06us sig=%d/%s",
-				    node.name, node.eid, pid,
-				    (unsigned long long) usage.ru_utime.tv_sec,
-				    (unsigned int) usage.ru_utime.tv_usec,
-				    WTERMSIG(status),
-				    strsignal(WTERMSIG(status)));
-			} else {
-				zed_log_msg(LOG_INFO,
-				    "Finished \"%s\" eid=%llu pid=%d "
-				    "time=%llu.%06us status=0x%X",
-				    node.name, node.eid,
-				    (unsigned long long) usage.ru_utime.tv_sec,
-				    (unsigned int) usage.ru_utime.tv_usec,
-				    (unsigned int) status);
-			}
-
-			free(node.name);
+			/* child still running */
+			t.tv_sec = 0;
+			t.tv_nsec = 10000000;	/* 10ms */
+			(void) nanosleep(&t, NULL);
+			continue;
 		}
+
+		if (WIFEXITED(status)) {
+			zed_log_msg(LOG_INFO,
+			    "Finished \"%s\" eid=%llu pid=%d exit=%d",
+			    prog, eid, pid, WEXITSTATUS(status));
+		} else if (WIFSIGNALED(status)) {
+			zed_log_msg(LOG_INFO,
+			    "Finished \"%s\" eid=%llu pid=%d sig=%d/%s",
+			    prog, eid, pid, WTERMSIG(status),
+			    strsignal(WTERMSIG(status)));
+		} else {
+			zed_log_msg(LOG_INFO,
+			    "Finished \"%s\" eid=%llu pid=%d status=0x%X",
+			    prog, eid, (unsigned int) status);
+		}
+		break;
 	}

-	return (NULL);
-}
-
-void
-zed_exec_fini(void)
-{
-	struct launched_process_node *node;
-	void *ck = NULL;
-
-	if (_reap_children_tid == (pthread_t)-1)
-		return;
-
-	_reap_children_stop = B_TRUE;
-	(void) pthread_kill(_reap_children_tid, SIGCHLD);
-	(void) pthread_join(_reap_children_tid, NULL);
-
-	while ((node = avl_destroy_nodes(&_launched_processes, &ck)) != NULL) {
-		free(node->name);
-		free(node);
+	/*
+	 * kill child process after 10 seconds
+	 */
+	if (wpid == 0) {
+		zed_log_msg(LOG_WARNING, "Killing hung \"%s\" pid=%d",
+		    prog, pid);
+		(void) kill(pid, SIGKILL);
 	}
-	avl_destroy(&_launched_processes);
-
-	(void) pthread_mutex_destroy(&_launched_processes_lock);
-	(void) pthread_mutex_init(&_launched_processes_lock, NULL);
-
-	_reap_children_tid = (pthread_t)-1;
 }

 /*
 * Process the event [eid] by synchronously invoking all zedlets with a
 * matching class prefix.
 *
- * Each executable in [zcp->zedlets] from the directory [zcp->zedlet_dir]
- * is matched against the event's [class], [subclass], and the "all" class
- * (which matches all events).
- * Every zedlet with a matching class prefix is invoked.
+ * Each executable in [zedlets] from the directory [dir] is matched against
+ * the event's [class], [subclass], and the "all" class (which matches
+ * all events).  Every zedlet with a matching class prefix is invoked.
 * The NAME=VALUE strings in [envs] will be passed to the zedlet as
 * environment variables.
 *
- * The file descriptor [zcp->zevent_fd] is the zevent_fd used to track the
+ * The file descriptor [zfd] is the zevent_fd used to track the
 * current cursor location within the zevent nvlist.
 *
 * Return 0 on success, -1 on error.
 */
 int
 zed_exec_process(uint64_t eid, const char *class, const char *subclass,
-    struct zed_conf *zcp, zed_strings_t *envs)
+    const char *dir, zed_strings_t *zedlets, zed_strings_t *envs, int zfd)
 {
 	const char *class_strings[4];
 	const char *allclass = "all";
@@ -325,22 +202,9 @@ zed_exec_process(uint64_t eid, const char *class, const char *subclass,
 	char **e;
 	int n;

-	if (!zcp->zedlet_dir || !zcp->zedlets || !envs || zcp->zevent_fd < 0)
+	if (!dir || !zedlets || !envs || zfd < 0)
 		return (-1);

-	if (_reap_children_tid == (pthread_t)-1) {
-		_launched_processes_limit = zcp->max_jobs;
-
-		if (pthread_create(&_reap_children_tid, NULL,
-		    _reap_children, NULL) != 0)
-			return (-1);
-		pthread_setname_np(_reap_children_tid, "reap ZEDLETs");
-
-		avl_create(&_launched_processes, _launched_process_node_compare,
-		    sizeof (struct launched_process_node),
-		    offsetof(struct launched_process_node, node));
-	}
-
 	csp = class_strings;

 	if (class)
@@ -356,13 +220,11 @@ zed_exec_process(uint64_t eid, const char *class, const char *subclass,

 	e = _zed_exec_create_env(envs);

-	for (z = zed_strings_first(zcp->zedlets); z;
-	    z = zed_strings_next(zcp->zedlets)) {
+	for (z = zed_strings_first(zedlets); z; z = zed_strings_next(zedlets)) {
 		for (csp = class_strings; *csp; csp++) {
 			n = strlen(*csp);
 			if ((strncmp(z, *csp, n) == 0) && !isalpha(z[n]))
-				_zed_exec_fork_child(eid, zcp->zedlet_dir,
-				    z, e, zcp->zevent_fd, zcp->do_foreground);
+				_zed_exec_fork_child(eid, dir, z, e, zfd);
 		}
 	}
 	free(e);
@@ -3,7 +3,7 @@
 *
 * Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
 * Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
- * Refer to the OpenZFS git commit log for authoritative copyright attribution.
+ * Refer to the ZoL git commit log for authoritative copyright attribution.
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License Version 1.0 (CDDL-1.0).
@@ -17,11 +17,9 @@

 #include <stdint.h>
 #include "zed_strings.h"
-#include "zed_conf.h"
-
-void zed_exec_fini(void);

 int zed_exec_process(uint64_t eid, const char *class, const char *subclass,
-    struct zed_conf *zcp, zed_strings_t *envs);
+    const char *dir, zed_strings_t *zedlets, zed_strings_t *envs,
+    int zevent_fd);

 #endif	/* !ZED_EXEC_H */
@@ -3,7 +3,7 @@
 *
 * Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
 * Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
- * Refer to the OpenZFS git commit log for authoritative copyright attribution.
+ * Refer to the ZoL git commit log for authoritative copyright attribution.
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License Version 1.0 (CDDL-1.0).
@@ -12,17 +12,73 @@
 * You may not use this file except in compliance with the license.
 */

-#include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <string.h>
+#include <sys/resource.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include "zed_file.h"
 #include "zed_log.h"

+/*
+ * Read up to [n] bytes from [fd] into [buf].
+ * Return the number of bytes read, 0 on EOF, or -1 on error.
+ */
+ssize_t
+zed_file_read_n(int fd, void *buf, size_t n)
+{
+	unsigned char *p;
+	size_t n_left;
+	ssize_t n_read;
+
+	p = buf;
+	n_left = n;
+	while (n_left > 0) {
+		if ((n_read = read(fd, p, n_left)) < 0) {
+			if (errno == EINTR)
+				continue;
+			else
+				return (-1);
+
+		} else if (n_read == 0) {
+			break;
+		}
+		n_left -= n_read;
+		p += n_read;
+	}
+	return (n - n_left);
+}
+
+/*
+ * Write [n] bytes from [buf] out to [fd].
+ * Return the number of bytes written, or -1 on error.
+ */
+ssize_t
+zed_file_write_n(int fd, void *buf, size_t n)
+{
+	const unsigned char *p;
+	size_t n_left;
+	ssize_t n_written;
+
+	p = buf;
+	n_left = n;
+	while (n_left > 0) {
+		if ((n_written = write(fd, p, n_left)) < 0) {
+			if (errno == EINTR)
+				continue;
+			else
+				return (-1);
+
+		}
+		n_left -= n_written;
+		p += n_written;
+	}
+	return (n);
+}
+
 /*
 * Set an exclusive advisory lock on the open file descriptor [fd].
 * Return 0 on success, 1 if a conflicting lock is held by another process,
@@ -104,13 +160,6 @@ zed_file_is_locked(int fd)
 	return (lock.l_pid);
 }

-
-#if __APPLE__
-#define	PROC_SELF_FD "/dev/fd"
-#else /* Linux-compatible layout */
-#define	PROC_SELF_FD "/proc/self/fd"
-#endif
-
 /*
 * Close all open file descriptors greater than or equal to [lowfd].
 * Any errors encountered while closing file descriptors are ignored.
@@ -118,24 +167,51 @@ zed_file_is_locked(int fd)
 void
 zed_file_close_from(int lowfd)
 {
-	int errno_bak = errno;
-	int maxfd = 0;
+	const int maxfd_def = 256;
+	int errno_bak;
+	struct rlimit rl;
+	int maxfd;
 	int fd;
-	DIR *fddir;
-	struct dirent *fdent;

-	if ((fddir = opendir(PROC_SELF_FD)) != NULL) {
-		while ((fdent = readdir(fddir)) != NULL) {
-			fd = atoi(fdent->d_name);
-			if (fd > maxfd && fd != dirfd(fddir))
-				maxfd = fd;
-		}
-		(void) closedir(fddir);
+	errno_bak = errno;
+
+	if (getrlimit(RLIMIT_NOFILE, &rl) < 0) {
+		maxfd = maxfd_def;
+	} else if (rl.rlim_max == RLIM_INFINITY) {
+		maxfd = maxfd_def;
 	} else {
-		maxfd = sysconf(_SC_OPEN_MAX);
+		maxfd = rl.rlim_max;
 	}
 	for (fd = lowfd; fd < maxfd; fd++)
 		(void) close(fd);

 	errno = errno_bak;
 }
+
+/*
+ * Set the CLOEXEC flag on file descriptor [fd] so it will be automatically
+ * closed upon successful execution of one of the exec functions.
+ * Return 0 on success, or -1 on error.
+ *
+ * FIXME: No longer needed?
+ */
+int
+zed_file_close_on_exec(int fd)
+{
+	int flags;
+
+	if (fd < 0) {
+		errno = EBADF;
+		return (-1);
+	}
+	flags = fcntl(fd, F_GETFD);
+	if (flags == -1)
+		return (-1);
+
+	flags |= FD_CLOEXEC;
+
+	if (fcntl(fd, F_SETFD, flags) == -1)
+		return (-1);
+
+	return (0);
+}
@@ -3,7 +3,7 @@
 *
 * Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
 * Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
- * Refer to the OpenZFS git commit log for authoritative copyright attribution.
+ * Refer to the ZoL git commit log for authoritative copyright attribution.
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License Version 1.0 (CDDL-1.0).
@@ -18,6 +18,10 @@
 #include <sys/types.h>
 #include <unistd.h>

+ssize_t zed_file_read_n(int fd, void *buf, size_t n);
+
+ssize_t zed_file_write_n(int fd, void *buf, size_t n);
+
 int zed_file_lock(int fd);

 int zed_file_unlock(int fd);
@@ -26,4 +30,6 @@ pid_t zed_file_is_locked(int fd);

 void zed_file_close_from(int fd);

+int zed_file_close_on_exec(int fd);
+
 #endif	/* !ZED_FILE_H */
@@ -3,7 +3,7 @@
 *
 * Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
 * Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
- * Refer to the OpenZFS git commit log for authoritative copyright attribution.
+ * Refer to the ZoL git commit log for authoritative copyright attribution.
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License Version 1.0 (CDDL-1.0).
@@ -3,7 +3,7 @@
 *
 * Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
 * Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
- * Refer to the OpenZFS git commit log for authoritative copyright attribution.
+ * Refer to the ZoL git commit log for authoritative copyright attribution.
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License Version 1.0 (CDDL-1.0).
@@ -3,7 +3,7 @@
 *
 * Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
 * Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
- * Refer to the OpenZFS git commit log for authoritative copyright attribution.
+ * Refer to the ZoL git commit log for authoritative copyright attribution.
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License Version 1.0 (CDDL-1.0).
@@ -3,7 +3,7 @@
 *
 * Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
 * Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
- * Refer to the OpenZFS git commit log for authoritative copyright attribution.
+ * Refer to the ZoL git commit log for authoritative copyright attribution.
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License Version 1.0 (CDDL-1.0).
@@ -21,5 +21,3 @@ zfs_LDADD += $(LTLIBINTL)
 if BUILD_FREEBSD
 zfs_LDADD += -lgeom -ljail
 endif
-
-include $(top_srcdir)/config/CppCheck.am
@@ -53,6 +53,7 @@
 #include <grp.h>
 #include <pwd.h>
 #include <signal.h>
+#include <sys/debug.h>
 #include <sys/list.h>
 #include <sys/mkdev.h>
 #include <sys/mntent.h>
@@ -70,6 +71,7 @@
 #include <zfs_prop.h>
 #include <zfs_deleg.h>
 #include <libzutil.h>
+#include <libuutil.h>
 #ifdef HAVE_IDMAP
 #include <aclutils.h>
 #include <directory.h>
@@ -268,7 +270,7 @@ get_usage(zfs_help_t idx)
 		return (gettext("\tclone [-p] [-o property=value] ... "
 		    "<snapshot> <filesystem|volume>\n"));
 	case HELP_CREATE:
-		return (gettext("\tcreate [-Pnpuv] [-o property=value] ... "
+		return (gettext("\tcreate [-Pnpv] [-o property=value] ... "
 		    "<filesystem>\n"
 		    "\tcreate [-Pnpsv] [-b blocksize] [-o property=value] ... "
 		    "-V <size> <volume>\n"));
@@ -317,7 +319,7 @@ get_usage(zfs_help_t idx)
 	case HELP_SEND:
 		return (gettext("\tsend [-DnPpRvLecwhb] [-[i|I] snapshot] "
 		    "<snapshot>\n"
-		    "\tsend [-DnvPLecw] [-i snapshot|bookmark] "
+		    "\tsend [-nvPLecw] [-i snapshot|bookmark] "
 		    "<filesystem|volume|snapshot>\n"
 		    "\tsend [-DnPpvLec] [-i bookmark|snapshot] "
 		    "--redact <bookmark> <snapshot>\n"
@@ -728,32 +730,6 @@ finish_progress(char *done)
 	pt_header = NULL;
 }

-/* This function checks if the passed fd refers to /dev/null or /dev/zero */
-#ifdef __linux__
-static boolean_t
-is_dev_nullzero(int fd)
-{
-	struct stat st;
-	fstat(fd, &st);
-	return (major(st.st_rdev) == 1 && (minor(st.st_rdev) == 3 /* null */ ||
-	    minor(st.st_rdev) == 5 /* zero */));
-}
-#endif
-
-static void
-note_dev_error(int err, int fd)
-{
-#ifdef __linux__
-	if (err == EINVAL && is_dev_nullzero(fd)) {
-		(void) fprintf(stderr,
-		    gettext("Error: Writing directly to /dev/{null,zero} files"
-		    " on certain kernels is not currently implemented.\n"
-		    "(As a workaround, "
-		    "try \"zfs send [...] | cat > /dev/null\")\n"));
-	}
-#endif
-}
-
 static int
 zfs_mount_and_share(libzfs_handle_t *hdl, const char *dataset, zfs_type_t type)
 {
@@ -916,107 +892,6 @@ usage:
 	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
@@ -1036,8 +911,6 @@ default_volblocksize(zpool_handle_t *zhp, nvlist_t *props)
 * 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'.
@@ -1054,19 +927,17 @@ zfs_do_create(int argc, char **argv)
 	boolean_t bflag = B_FALSE;
 	boolean_t parents = B_FALSE;
 	boolean_t dryrun = B_FALSE;
-	boolean_t nomount = B_FALSE;
 	boolean_t verbose = B_FALSE;
 	boolean_t parseable = B_FALSE;
 	int ret = 1;
 	nvlist_t *props;
 	uint64_t intval;
-	char *strval;

 	if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
 		nomem();

 	/* check options */
-	while ((c = getopt(argc, argv, ":PV:b:nso:puv")) != -1) {
+	while ((c = getopt(argc, argv, ":PV:b:nso:pv")) != -1) {
 		switch (c) {
 		case 'V':
 			type = ZFS_TYPE_VOLUME;
@@ -1113,9 +984,6 @@ zfs_do_create(int argc, char **argv)
 		case 's':
 			noreserve = B_TRUE;
 			break;
-		case 'u':
-			nomount = B_TRUE;
-			break;
 		case 'v':
 			verbose = B_TRUE;
 			break;
@@ -1135,11 +1003,6 @@ zfs_do_create(int argc, char **argv)
 		    "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;
@@ -1155,7 +1018,7 @@ zfs_do_create(int argc, char **argv)
 		goto badusage;
 	}

-	if (dryrun || type == ZFS_TYPE_VOLUME) {
+	if (dryrun || (type == ZFS_TYPE_VOLUME && !noreserve)) {
 		char msg[ZFS_MAX_DATASET_NAME_LEN * 2];
 		char *p;

@@ -1177,24 +1040,18 @@ zfs_do_create(int argc, char **argv)
 		}
 	}

+	/*
+	 * if volsize is not a multiple of volblocksize, round it up to the
+	 * nearest multiple of the volblocksize
+	 */
 	if (type == ZFS_TYPE_VOLUME) {
-		const char *prop = zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE);
-		uint64_t volblocksize = default_volblocksize(zpool_handle,
-		    real_props);
+		uint64_t volblocksize;

-		if (volblocksize != ZVOL_DEFAULT_BLOCKSIZE &&
-		    nvlist_lookup_string(props, prop, &strval) != 0) {
-			if (asprintf(&strval, "%llu",
-			    (u_longlong_t)volblocksize) == -1)
-				nomem();
-			nvlist_add_string(props, prop, strval);
-			free(strval);
-		}
+		if (nvlist_lookup_uint64(props,
+		    zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
+		    &volblocksize) != 0)
+			volblocksize = ZVOL_DEFAULT_BLOCKSIZE;

-		/*
-		 * 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);
@@ -1207,9 +1064,11 @@ zfs_do_create(int argc, char **argv)
 		}
 	}

+
 	if (type == ZFS_TYPE_VOLUME && !noreserve) {
 		uint64_t spa_version;
 		zfs_prop_t resv_prop;
+		char *strval;

 		spa_version = zpool_get_prop_int(zpool_handle,
 		    ZPOOL_PROP_VERSION, NULL);
@@ -1300,11 +1159,6 @@ zfs_do_create(int argc, char **argv)
 		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);
@@ -2480,7 +2334,7 @@ upgrade_set_callback(zfs_handle_t *zhp, void *data)

 	/* upgrade */
 	if (version < cb->cb_version) {
-		char verstr[24];
+		char verstr[16];
 		(void) snprintf(verstr, sizeof (verstr),
 		    "%llu", (u_longlong_t)cb->cb_version);
 		if (cb->cb_lastfs[0] && !same_pool(zhp, cb->cb_lastfs)) {
@@ -4402,7 +4256,6 @@ zfs_do_send(int argc, char **argv)

 	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'},
@@ -4421,7 +4274,7 @@ zfs_do_send(int argc, char **argv)
 	};

 	/* check options */
-	while ((c = getopt_long(argc, argv, ":i:I:RsDpvnPLeht:cwbd:S",
+	while ((c = getopt_long(argc, argv, ":i:I:RDpvnPLeht:cwbd:S",
 	    long_options, NULL)) != -1) {
 		switch (c) {
 		case 'i':
@@ -4438,9 +4291,6 @@ zfs_do_send(int argc, char **argv)
 		case 'R':
 			flags.replicate = B_TRUE;
 			break;
-		case 's':
-			flags.skipmissing = B_TRUE;
-			break;
 		case 'd':
 			redactbook = optarg;
 			break;
@@ -4598,23 +4448,11 @@ zfs_do_send(int argc, char **argv)

 		err = zfs_send_saved(zhp, &flags, STDOUT_FILENO,
 		    resume_token);
-		if (err != 0)
-			note_dev_error(errno, STDOUT_FILENO);
 		zfs_close(zhp);
 		return (err != 0);
 	} else if (resume_token != NULL) {
-		err = zfs_send_resume(g_zfs, &flags, STDOUT_FILENO,
-		    resume_token);
-		if (err != 0)
-			note_dev_error(errno, STDOUT_FILENO);
-		return (err);
-	}
-
-	if (flags.skipmissing && !flags.replicate) {
-		(void) fprintf(stderr,
-		    gettext("skip-missing flag can only be used in "
-		    "conjunction with replicate\n"));
-		usage(B_FALSE);
+		return (zfs_send_resume(g_zfs, &flags, STDOUT_FILENO,
+		    resume_token));
 	}

 	/*
@@ -4658,8 +4496,6 @@ zfs_do_send(int argc, char **argv)
 		err = zfs_send_one(zhp, fromname, STDOUT_FILENO, &flags,
 		    redactbook);
 		zfs_close(zhp);
-		if (err != 0)
-			note_dev_error(errno, STDOUT_FILENO);
 		return (err != 0);
 	}

@@ -4736,7 +4572,6 @@ zfs_do_send(int argc, char **argv)
 		nvlist_free(dbgnv);
 	}
 	zfs_close(zhp);
-	note_dev_error(errno, STDOUT_FILENO);

 	return (err != 0);
 }
@@ -6593,7 +6428,7 @@ zfs_do_holds(int argc, char **argv)
 		/*
 		 *  1. collect holds data, set format options
 		 */
-		ret = zfs_for_each(1, argv + i, flags, types, NULL, NULL, limit,
+		ret = zfs_for_each(argc, argv, flags, types, NULL, NULL, limit,
 		    holds_callback, &cb);
 		if (ret != 0)
 			++errors;
@@ -6955,6 +6790,9 @@ report_mount_progress(int current, int total)
 	time_t now = time(NULL);
 	char info[32];

+	/* report 1..n instead of 0..n-1 */
+	++current;
+
 	/* display header if we're here for the first time */
 	if (current == 1) {
 		set_progress_header(gettext("Mounting ZFS filesystems"));
@@ -7475,7 +7313,6 @@ unshare_unmount(int op, int argc, char **argv)
 				if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) ==
 				    ZFS_CANMOUNT_NOAUTO)
 					continue;
-				break;
 			default:
 				break;
 			}
@@ -7672,7 +7509,7 @@ zfs_do_diff(int argc, char **argv)
 	int c;
 	struct sigaction sa;

-	while ((c = getopt(argc, argv, "FHth")) != -1) {
+	while ((c = getopt(argc, argv, "FHt")) != -1) {
 		switch (c) {
 		case 'F':
 			flags |= ZFS_DIFF_CLASSIFY;
@@ -7683,9 +7520,6 @@ zfs_do_diff(int argc, char **argv)
 		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);
@@ -8536,7 +8370,7 @@ zfs_do_wait(int argc, char **argv)
 {
 	boolean_t enabled[ZFS_WAIT_NUM_ACTIVITIES];
 	int error, i;
-	int c;
+	char c;

 	/* By default, wait for all types of activity. */
 	for (i = 0; i < ZFS_WAIT_NUM_ACTIVITIES; i++)
@@ -207,6 +207,7 @@ static int
 zfs_project_handle_dir(const char *name, zfs_project_control_t *zpc,
    list_t *head)
 {
+	char fullname[PATH_MAX];
 	struct dirent *ent;
 	DIR *dir;
 	int ret = 0;
@@ -226,28 +227,21 @@ zfs_project_handle_dir(const char *name, zfs_project_control_t *zpc,
 	zpc->zpc_ignore_noent = B_TRUE;
 	errno = 0;
 	while (!ret && (ent = readdir(dir)) != NULL) {
-		char *fullname;
-
 		/* skip "." and ".." */
 		if (strcmp(ent->d_name, ".") == 0 ||
 		    strcmp(ent->d_name, "..") == 0)
 			continue;

-		if (strlen(ent->d_name) + strlen(name) + 1 >= PATH_MAX) {
+		if (strlen(ent->d_name) + strlen(name) >=
+		    sizeof (fullname) + 1) {
 			errno = ENAMETOOLONG;
 			break;
 		}

-		if (asprintf(&fullname, "%s/%s", name, ent->d_name) == -1) {
-			errno = ENOMEM;
-			break;
-		}
-
+		sprintf(fullname, "%s/%s", name, ent->d_name);
 		ret = zfs_project_handle_one(fullname, zpc);
 		if (!ret && zpc->zpc_recursive && ent->d_type == DT_DIR)
 			zfs_project_item_alloc(head, fullname);
-
-		free(fullname);
 	}

 	if (errno && !ret) {
@@ -7,5 +7,3 @@ zfs_ids_to_path_SOURCES = \

 zfs_ids_to_path_LDADD = \
        $(abs_top_builddir)/lib/libzfs/libzfs.la
-
-include $(top_srcdir)/config/CppCheck.am
@@ -35,7 +35,7 @@ libzfs_handle_t *g_zfs;
 static void
 usage(int err)
 {
-	fprintf(stderr, "Usage: zfs_ids_to_path [-v] <pool> <objset id> "
+	fprintf(stderr, "Usage: [-v] zfs_ids_to_path <pool> <objset id> "
 	    "<object id>\n");
 	exit(err);
 }
@@ -44,7 +44,7 @@ int
 main(int argc, char **argv)
 {
 	boolean_t verbose = B_FALSE;
-	int c;
+	char c;
 	while ((c = getopt(argc, argv, "v")) != -1) {
 		switch (c) {
 		case 'v':
@@ -63,11 +63,11 @@ main(int argc, char **argv)

 	uint64_t objset, object;
 	if (sscanf(argv[1], "%llu", (u_longlong_t *)&objset) != 1) {
-		(void) fprintf(stderr, "Invalid objset id: %s\n", argv[1]);
+		(void) fprintf(stderr, "Invalid objset id: %s\n", argv[2]);
 		usage(2);
 	}
 	if (sscanf(argv[2], "%llu", (u_longlong_t *)&object) != 1) {
-		(void) fprintf(stderr, "Invalid object id: %s\n", argv[2]);
+		(void) fprintf(stderr, "Invalid object id: %s\n", argv[3]);
 		usage(3);
 	}
 	if ((g_zfs = libzfs_init()) == NULL) {
@@ -76,7 +76,7 @@ main(int argc, char **argv)
 	}
 	zpool_handle_t *pool = zpool_open(g_zfs, argv[0]);
 	if (pool == NULL) {
-		fprintf(stderr, "Could not open pool %s\n", argv[0]);
+		fprintf(stderr, "Could not open pool %s\n", argv[1]);
 		libzfs_fini(g_zfs);
 		return (5);
 	}
@@ -1,7 +1,5 @@
 include $(top_srcdir)/config/Rules.am

-sbin_PROGRAMS = zgenhostid
+bin_PROGRAMS = zgenhostid

 zgenhostid_SOURCES = zgenhostid.c
-
-include $(top_srcdir)/config/CppCheck.am
@@ -36,6 +36,8 @@
 #include <time.h>
 #include <unistd.h>

+static void usage(void);
+
 static void
 usage(void)
 {
@@ -58,11 +60,12 @@ int
 main(int argc, char **argv)
 {
 	/* default file path, can be optionally set by user */
-	const char *path = "/etc/hostid";
+	char path[PATH_MAX] = "/etc/hostid";
 	/* holds converted user input or lrand48() generated value */
 	unsigned long input_i = 0;

 	int opt;
+	int pathlen;
 	int force_fwrite = 0;
 	while ((opt = getopt_long(argc, argv, "fo:h?", 0, 0)) != -1) {
 		switch (opt) {
@@ -70,7 +73,14 @@ main(int argc, char **argv)
 			force_fwrite = 1;
 			break;
 		case 'o':
-			path = optarg;
+			pathlen = snprintf(path, sizeof (path), "%s", optarg);
+			if (pathlen >= sizeof (path)) {
+				fprintf(stderr, "%s\n", strerror(EOVERFLOW));
+				exit(EXIT_FAILURE);
+			} else if (pathlen < 1) {
+				fprintf(stderr, "%s\n", strerror(EINVAL));
+				exit(EXIT_FAILURE);
+			}
 			break;
 		case 'h':
 		case '?':
@@ -108,7 +118,7 @@ main(int argc, char **argv)
 	if (force_fwrite == 0 && stat(path, &fstat) == 0 &&
 	    S_ISREG(fstat.st_mode)) {
 		fprintf(stderr, "%s: %s\n", path, strerror(EEXIST));
-		exit(EXIT_FAILURE);
+			exit(EXIT_FAILURE);
 	}

 	/*
@@ -127,7 +137,7 @@ main(int argc, char **argv)
 	}

 	/*
-	 * we need just 4 bytes in native endianness
+	 * we need just 4 bytes in native endianess
 	 * not using sethostid() because it may be missing or just a stub
 	 */
 	uint32_t hostid = input_i;
@@ -12,5 +12,3 @@ zhack_LDADD = \
 	$(abs_top_builddir)/lib/libzpool/libzpool.la \
 	$(abs_top_builddir)/lib/libzfs_core/libzfs_core.la \
 	$(abs_top_builddir)/lib/libnvpair/libnvpair.la
-
-include $(top_srcdir)/config/CppCheck.am
@@ -150,7 +150,6 @@ zhack_import(char *target, boolean_t readonly)
 	zfeature_checks_disable = B_TRUE;
 	error = spa_import(target, config, props,
 	    (readonly ?  ZFS_IMPORT_SKIP_MMP : ZFS_IMPORT_NORMAL));
-	fnvlist_free(config);
 	zfeature_checks_disable = B_FALSE;
 	if (error == EEXIST)
 		error = 0;
@@ -11,5 +11,3 @@ zinject_LDADD = \
 	$(abs_top_builddir)/lib/libzfs/libzfs.la \
 	$(abs_top_builddir)/lib/libzfs_core/libzfs_core.la \
 	$(abs_top_builddir)/lib/libnvpair/libnvpair.la
-
-include $(top_srcdir)/config/CppCheck.am
@@ -1,5 +1,4 @@
 include $(top_srcdir)/config/Rules.am
-include $(top_srcdir)/config/Shellcheck.am

 AM_CFLAGS += $(LIBBLKID_CFLAGS) $(LIBUUID_CFLAGS)

@@ -26,8 +25,7 @@ zpool_LDADD = \
 	$(abs_top_builddir)/lib/libzfs/libzfs.la \
 	$(abs_top_builddir)/lib/libzfs_core/libzfs_core.la \
 	$(abs_top_builddir)/lib/libnvpair/libnvpair.la \
-	$(abs_top_builddir)/lib/libuutil/libuutil.la \
-	$(abs_top_builddir)/lib/libzutil/libzutil.la
+	$(abs_top_builddir)/lib/libuutil/libuutil.la

 zpool_LDADD += $(LTLIBINTL)

@@ -36,12 +34,10 @@ zpool_LDADD += -lgeom
 endif
 zpool_LDADD += -lm $(LIBBLKID_LIBS) $(LIBUUID_LIBS)

-include $(top_srcdir)/config/CppCheck.am
-
 zpoolconfdir = $(sysconfdir)/zfs/zpool.d
 zpoolexecdir = $(zfsexecdir)/zpool.d

-EXTRA_DIST = zpool.d/README compatibility.d
+EXTRA_DIST = zpool.d/README

 dist_zpoolexec_SCRIPTS = \
 	zpool.d/dm-deps \
@@ -131,52 +127,6 @@ zpoolconfdefaults = \
 	test_progress \
 	test_ended

-zpoolcompatdir = $(pkgdatadir)/compatibility.d
-
-dist_zpoolcompat_DATA = \
-	compatibility.d/compat-2018 \
-	compatibility.d/compat-2019 \
-	compatibility.d/compat-2020 \
-	compatibility.d/compat-2021 \
-	compatibility.d/freebsd-11.0 \
-	compatibility.d/freebsd-11.2 \
-	compatibility.d/freebsd-11.3 \
-	compatibility.d/freenas-9.10.2 \
-	compatibility.d/grub2 \
-	compatibility.d/openzfsonosx-1.7.0 \
-	compatibility.d/openzfsonosx-1.8.1 \
-	compatibility.d/openzfsonosx-1.9.3 \
-	compatibility.d/openzfs-2.0-freebsd \
-	compatibility.d/openzfs-2.0-linux \
-	compatibility.d/openzfs-2.1-freebsd \
-	compatibility.d/openzfs-2.1-linux \
-	compatibility.d/zol-0.6.1 \
-	compatibility.d/zol-0.6.4 \
-	compatibility.d/zol-0.6.5 \
-	compatibility.d/zol-0.7 \
-	compatibility.d/zol-0.8
-
-# canonical <- alias symbolic link pairs
-# eg: "2018" is a link to "compat-2018"
-zpoolcompatlinks = \
-	"compat-2018		2018" \
-	"compat-2019		2019" \
-	"compat-2020		2020" \
-	"compat-2021		2021" \
-	"freebsd-11.0		freebsd-11.1" \
-	"freebsd-11.0		freenas-11.0" \
-	"freebsd-11.2		freenas-11.2" \
-	"freebsd-11.3		freebsd-11.4" \
-	"freebsd-11.3		freebsd-12.0" \
-	"freebsd-11.3		freebsd-12.1" \
-	"freebsd-11.3		freebsd-12.2" \
-	"freebsd-11.3		freenas-11.3" \
-	"freenas-11.0		freenas-11.1" \
-	"openzfsonosx-1.9.3	openzfsonosx-1.9.4" \
-	"openzfs-2.0-freebsd	truenas-12.0" \
-	"zol-0.7		ubuntu-18.04" \
-	"zol-0.8		ubuntu-20.04"
-
 install-data-hook:
 	$(MKDIR_P) "$(DESTDIR)$(zpoolconfdir)"
 	for f in $(zpoolconfdefaults); do \
@@ -184,6 +134,3 @@ install-data-hook:
 	       -L "$(DESTDIR)$(zpoolconfdir)/$${f}" || \
 	    ln -s "$(zpoolexecdir)/$${f}" "$(DESTDIR)$(zpoolconfdir)"; \
 	done
-	for l in $(zpoolcompatlinks); do \
-		(cd "$(DESTDIR)$(zpoolcompatdir)"; ln -sf $${l} ); \
-	done
@@ -1,12 +0,0 @@
-# Features supported by all Tier 1 platforms as of 2018
-async_destroy
-bookmarks
-embedded_data
-empty_bpobj
-enabled_txg
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-lz4_compress
-spacemap_histogram
@@ -1,15 +0,0 @@
-# Features supported by all Tier 1 platforms as of 2019
-async_destroy
-bookmarks
-embedded_data
-empty_bpobj
-enabled_txg
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-lz4_compress
-multi_vdev_crash_dump
-sha512
-skein
-spacemap_histogram
@@ -1,15 +0,0 @@
-# Features supported by all Tier 1 platforms as of 2020
-async_destroy
-bookmarks
-embedded_data
-empty_bpobj
-enabled_txg
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-lz4_compress
-multi_vdev_crash_dump
-sha512
-skein
-spacemap_histogram
@@ -1,19 +0,0 @@
-# Features supported by all Tier 1 platforms as of 2021
-async_destroy
-bookmarks
-device_removal
-embedded_data
-empty_bpobj
-enabled_txg
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-lz4_compress
-multi_vdev_crash_dump
-obsolete_counts
-sha512
-skein
-spacemap_histogram
-spacemap_v2
-zpool_checkpoint
@@ -1,15 +0,0 @@
-# Features supported by FreeBSD 11.0
-async_destroy
-bookmarks
-embedded_data
-empty_bpobj
-enabled_txg
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-lz4_compress
-multi_vdev_crash_dump
-sha512
-skein
-spacemap_histogram
@@ -1,18 +0,0 @@
-# Features supported by FreeBSD 11.2
-async_destroy
-bookmarks
-device_removal
-embedded_data
-empty_bpobj
-enabled_txg
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-lz4_compress
-multi_vdev_crash_dump
-obsolete_counts
-sha512
-skein
-spacemap_histogram
-zpool_checkpoint
@@ -1,19 +0,0 @@
-# Features supported by FreeBSD 11.3
-async_destroy
-bookmarks
-device_removal
-embedded_data
-empty_bpobj
-enabled_txg
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-lz4_compress
-multi_vdev_crash_dump
-obsolete_counts
-sha512
-skein
-spacemap_histogram
-spacemap_v2
-zpool_checkpoint
@@ -1,13 +0,0 @@
-# Features supported by FreeNAS 9.10.2
-async_destroy
-bookmarks
-embedded_data
-empty_bpobj
-enabled_txg
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-lz4_compress
-multi_vdev_crash_dump
-spacemap_histogram
@@ -1,12 +0,0 @@
-# Features which are supported by GRUB2
-async_destroy
-bookmarks
-embedded_data
-empty_bpobj
-enabled_txg
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-lz4_compress
-spacemap_histogram
@@ -1,33 +0,0 @@
-# Features supported by OpenZFS 2.0 on FreeBSD
-allocation_classes
-async_destroy
-bookmark_v2
-bookmark_written
-bookmarks
-device_rebuild
-device_removal
-embedded_data
-empty_bpobj
-enabled_txg
-encryption
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-large_dnode
-livelist
-log_spacemap
-lz4_compress
-multi_vdev_crash_dump
-obsolete_counts
-project_quota
-redacted_datasets
-redaction_bookmarks
-resilver_defer
-sha512
-skein
-spacemap_histogram
-spacemap_v2
-userobj_accounting
-zpool_checkpoint
-zstd_compress
@@ -1,34 +0,0 @@
-# Features supported by OpenZFS 2.0 on Linux
-allocation_classes
-async_destroy
-bookmark_v2
-bookmark_written
-bookmarks
-device_rebuild
-device_removal
-edonr
-embedded_data
-empty_bpobj
-enabled_txg
-encryption
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-large_dnode
-livelist
-log_spacemap
-lz4_compress
-multi_vdev_crash_dump
-obsolete_counts
-project_quota
-redacted_datasets
-redaction_bookmarks
-resilver_defer
-sha512
-skein
-spacemap_histogram
-spacemap_v2
-userobj_accounting
-zpool_checkpoint
-zstd_compress
@@ -1,34 +0,0 @@
-# Features supported by OpenZFS 2.1 on FreeBSD
-allocation_classes
-async_destroy
-bookmark_v2
-bookmark_written
-bookmarks
-device_rebuild
-device_removal
-draid
-embedded_data
-empty_bpobj
-enabled_txg
-encryption
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-large_dnode
-livelist
-log_spacemap
-lz4_compress
-multi_vdev_crash_dump
-obsolete_counts
-project_quota
-redacted_datasets
-redaction_bookmarks
-resilver_defer
-sha512
-skein
-spacemap_histogram
-spacemap_v2
-userobj_accounting
-zpool_checkpoint
-zstd_compress
@@ -1,35 +0,0 @@
-# Features supported by OpenZFS 2.1 on Linux
-allocation_classes
-async_destroy
-bookmark_v2
-bookmark_written
-bookmarks
-device_rebuild
-device_removal
-draid
-edonr
-embedded_data
-empty_bpobj
-enabled_txg
-encryption
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-large_dnode
-livelist
-log_spacemap
-lz4_compress
-multi_vdev_crash_dump
-obsolete_counts
-project_quota
-redacted_datasets
-redaction_bookmarks
-resilver_defer
-sha512
-skein
-spacemap_histogram
-spacemap_v2
-userobj_accounting
-zpool_checkpoint
-zstd_compress
@@ -1,16 +0,0 @@
-# Features supported by OpenZFSonOSX 1.7.0
-async_destroy
-bookmarks
-edonr
-embedded_data
-empty_bpobj
-enabled_txg
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-lz4_compress
-multi_vdev_crash_dump
-sha512
-skein
-spacemap_histogram
@@ -1,21 +0,0 @@
-# Features supported by OpenZFSonOSX 1.8.1
-async_destroy
-bookmarks
-device_removal
-edonr
-embedded_data
-empty_bpobj
-enabled_txg
-encryption
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-lz4_compress
-multi_vdev_crash_dump
-obsolete_counts
-sha512
-skein
-spacemap_histogram
-spacemap_v2
-zpool_checkpoint
@@ -1,27 +0,0 @@
-# Features supported by OpenZFSonOSX 1.9.3
-allocation_classes
-async_destroy
-bookmark_v2
-bookmarks
-device_removal
-edonr
-embedded_data
-empty_bpobj
-enabled_txg
-encryption
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-large_dnode
-lz4_compress
-multi_vdev_crash_dump
-obsolete_counts
-project_quota
-resilver_defer
-sha512
-skein
-spacemap_histogram
-spacemap_v2
-userobj_accounting
-zpool_checkpoint
@@ -1,4 +0,0 @@
-# Features supported by ZFSonLinux v0.6.1
-async_destroy
-empty_bpobj
-lz4_compress
@@ -1,10 +0,0 @@
-# Features supported by ZFSonLinux v0.6.4
-async_destroy
-bookmarks
-embedded_data
-empty_bpobj
-enabled_txg
-extensible_dataset
-hole_birth
-lz4_compress
-spacemap_histogram
@@ -1,12 +0,0 @@
-# Features supported by ZFSonLinux v0.6.5
-async_destroy
-bookmarks
-embedded_data
-empty_bpobj
-enabled_txg
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-lz4_compress
-spacemap_histogram
@@ -1,18 +0,0 @@
-# Features supported by ZFSonLinux v0.7
-async_destroy
-bookmarks
-edonr
-embedded_data
-empty_bpobj
-enabled_txg
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-large_dnode
-lz4_compress
-multi_vdev_crash_dump
-sha512
-skein
-spacemap_histogram
-userobj_accounting
@@ -1,27 +0,0 @@
-# Features supported by ZFSonLinux v0.8
-allocation_classes
-async_destroy
-bookmark_v2
-bookmarks
-device_removal
-edonr
-embedded_data
-empty_bpobj
-enabled_txg
-encryption
-extensible_dataset
-filesystem_limits
-hole_birth
-large_blocks
-large_dnode
-lz4_compress
-multi_vdev_crash_dump
-obsolete_counts
-project_quota
-resilver_defer
-sha512
-skein
-spacemap_histogram
-spacemap_v2
-userobj_accounting
-zpool_checkpoint
@@ -101,18 +101,3 @@ check_sector_size_database(char *path, int *sector_size)
 {
 	return (0);
 }
-
-void
-after_zpool_upgrade(zpool_handle_t *zhp)
-{
-	char bootfs[ZPOOL_MAXPROPLEN];
-
-	if (zpool_get_prop(zhp, ZPOOL_PROP_BOOTFS, bootfs,
-	    sizeof (bootfs), NULL, B_FALSE) == 0 &&
-	    strcmp(bootfs, "-") != 0) {
-		(void) printf(gettext("Pool '%s' has the bootfs "
-		    "property set, you might need to update\nthe boot "
-		    "code. See gptzfsboot(8) and loader.efi(8) for "
-		    "details.\n"), zpool_get_name(zhp));
-	}
-}
@@ -79,6 +79,9 @@

 #include <scsi/scsi.h>
 #include <scsi/sg.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
 #include <sys/efi_partition.h>
 #include <sys/stat.h>
 #include <sys/vtoc.h>
@@ -405,8 +408,3 @@ check_device(const char *path, boolean_t force,

 	return (error);
 }
-
-void
-after_zpool_upgrade(zpool_handle_t *zhp)
-{
-}
--- a/Show More
+++ b/Show More