git: 2f10ffc003be - main - zfs: merge openzfs/zfs@02b5baf13
- Go to: [ bottom of page ] [ top of archives ] [ this month ]
Date: Mon, 14 Sep 2026 12:38:10 UTC
The branch main has been updated by mm:
URL: https://cgit.FreeBSD.org/src/commit/?id=2f10ffc003be396f3fc23cd2888023896560252b
commit 2f10ffc003be396f3fc23cd2888023896560252b
Merge: 9315ab37fdc1 02b5baf13cbf
Author: Martin Matuska <mm@FreeBSD.org>
AuthorDate: 2026-09-14 09:54:55 +0000
Commit: Martin Matuska <mm@FreeBSD.org>
CommitDate: 2026-09-14 12:37:46 +0000
zfs: merge openzfs/zfs@02b5baf13
Notable upstream pull request merges:
#18808 6d4ff3b4f Pool split leaks DTL spacemap objects
#18844 0833cfd64 Decline Direct I/O reads on a file handle after a benign
verify failure
#18853 39764eb06 Fix double free when cloning a block with a pending free
#18901 51fe1fb84 dmu_send: a meta-dnode range does not start where an
object does
#18903 904d4327f dmu_objset_open_impl: unregister prop callbacks on error
#18906 e45640415 zdb: add detailed diagnostics for MOS leaks and spacemap
refs
#18909 1b7143557 Keep a grown vdev from adopting an older pool's labels
#18912 -multiple Defer destruction of a snapshot that a mount is holding
open
#18921 33ae06bb6 ZIO: Batch vdev children completions
#18940 7853c27eb ZIO: Batch lightweight ZIOs
#18967 -multiple Speed up pool rewind and allow it to tolerate minor damage
#18968 b0fff48dc arc: harness buf_hdr's anon state invariant checks
#18969 b0da5c4ce dsl_crypt: validate every key change-key will rewrap
#18974 b19fa7c97 log_spacemap: make zfs_log_sm_blksz tunable
#18982 c878ee452 zstream: track and limit memory use
#18991 a1261384a zstream: self-tuning queues
#18992 fd639b075 zcp: support bookmarks in zfs.sync.destroy
#18993 0498c554d vdev_disk_open: fix ENOENT retry & cleanup error handling
#19003 5280a08f6 Write uberblocks only to vdevs used by the txg
#19008 c47591d5d arc: apply arc_min tunables set before arc_init() has run
#19016 cd578e518 dnode: fix heap-use-after-free in dnode_rele_and_unlock()
#19017 b824f3116 zstd: declare __asan_*_memory_region() for user space
builds
#19029 6860d1c2f DDT: Use proper size when calling kmem_free on
ddt_prune_entry_t
#19041 aa26ca67b Do not complete a device removal that hit IO errors
#19042 8e5bb1d4b Wait for the initialize and trim threads to exit
#19051 ba524e0d7 zpool: things get messy with 0 columns
#19053 69ef525a4 dsl_deadlist_space_range: use correct tree when summing
up space
#19059 0ee8ea01b FreeBSD: use sys/abi_compat.h for time32_t
#19062 e08bc2973 Skip interior dnode slots when receiving DRR_FREEOBJECTS
#19066 92a3904af Wait for the txg that finished a scan to sync
#19071 db07a5e0a dbuf: account dirty data for embedded writes
#19072 1a8e51491 Fix self-deadlock when cloning a range within the same
file
#19075 75bd31c28 L2ARC: do not feed a device while its rebuild is pending
#19083 56e8d234b Stop the TRIM and initialize threads when a vdev goes
offline
#19090 ab994acdd dmu: remove dmu_prealloc()
#19092 61fbdf1a2 zfs: spa_sync_upgrades() should only take lock when needed
Obtained from: OpenZFS
OpenZFS commit: 02b5baf13cbfdf9abd33b939a082b448951d9174
cddl/usr.sbin/zhack/Makefile | 2 +-
sys/contrib/openzfs/.github/workflows/README.md | 2 +-
.../.github/workflows/scripts/qemu-2-start.sh | 4 +-
.../.github/workflows/scripts/qemu-3-deps-vm.sh | 36 +-
sys/contrib/openzfs/.github/workflows/zfs-qemu.yml | 6 +-
sys/contrib/openzfs/cmd/zdb/zdb.c | 241 ++-
sys/contrib/openzfs/cmd/zhack.c | 655 ++++++-
sys/contrib/openzfs/cmd/zpool/zpool_main.c | 19 +-
sys/contrib/openzfs/cmd/zstream/Makefile.am | 4 +-
sys/contrib/openzfs/cmd/zstream/zstream_chain.c | 2 -
sys/contrib/openzfs/cmd/zstream/zstream_chain.h | 2 -
.../openzfs/cmd/zstream/zstream_decompress.c | 4 +-
.../openzfs/cmd/zstream/zstream_drop_record.c | 17 +-
.../openzfs/cmd/zstream/zstream_fletcher4.c | 14 +-
.../openzfs/cmd/zstream/zstream_fletcher4.h | 2 +-
sys/contrib/openzfs/cmd/zstream/zstream_io.c | 263 ++-
sys/contrib/openzfs/cmd/zstream/zstream_io.h | 18 +
sys/contrib/openzfs/cmd/zstream/zstream_modules.h | 11 +-
sys/contrib/openzfs/cmd/zstream/zstream_queue.c | 297 ++--
sys/contrib/openzfs/cmd/zstream/zstream_queue.h | 39 +-
sys/contrib/openzfs/cmd/zstream/zstream_raw.c | 19 +-
.../openzfs/cmd/zstream/zstream_recompress.c | 26 +-
sys/contrib/openzfs/cmd/zstream/zstream_redup.c | 9 +-
.../openzfs/cmd/zstream/zstream_selftest_queue.c | 215 ++-
sys/contrib/openzfs/cmd/ztest.c | 333 +++-
sys/contrib/openzfs/config/kernel-bio.m4 | 26 +
sys/contrib/openzfs/config/kernel-inode-create.m4 | 34 +
sys/contrib/openzfs/config/kernel-vfs-fop-flags.m4 | 28 +
sys/contrib/openzfs/config/kernel.m4 | 4 +
sys/contrib/openzfs/config/user.m4 | 1 +
sys/contrib/openzfs/include/libzdb.h | 2 +
.../openzfs/include/os/freebsd/spl/sys/uio.h | 8 +
sys/contrib/openzfs/include/os/linux/Makefile.am | 1 +
.../include/os/linux/kernel/linux/blkdev_compat.h | 15 +-
.../include/os/linux/kernel/linux/kthread_compat.h | 35 +
.../include/os/linux/kernel/linux/simd_x86.h | 14 +-
sys/contrib/openzfs/include/os/linux/spl/sys/uio.h | 10 +
sys/contrib/openzfs/include/sys/dmu.h | 2 -
sys/contrib/openzfs/include/sys/dsl_bookmark.h | 9 +
sys/contrib/openzfs/include/sys/dsl_destroy.h | 1 +
sys/contrib/openzfs/include/sys/dsl_scan.h | 6 +
sys/contrib/openzfs/include/sys/fs/zfs.h | 3 +
sys/contrib/openzfs/include/sys/spa.h | 1 +
sys/contrib/openzfs/include/sys/spa_impl.h | 2 +-
sys/contrib/openzfs/include/sys/vdev.h | 9 +-
sys/contrib/openzfs/include/sys/vdev_impl.h | 20 +
sys/contrib/openzfs/include/sys/zio.h | 20 +
sys/contrib/openzfs/lib/libzfs/libzfs_pool.c | 104 +-
sys/contrib/openzfs/man/man1/zhack.1 | 57 +-
sys/contrib/openzfs/man/man1/ztest.1 | 5 +-
sys/contrib/openzfs/man/man4/spl.4 | 11 +-
sys/contrib/openzfs/man/man4/zfs.4 | 18 +-
sys/contrib/openzfs/man/man8/zdb.8 | 9 +-
sys/contrib/openzfs/man/man8/zpool-import.8 | 26 +-
.../openzfs/module/os/freebsd/zfs/sysctl_os.c | 7 +-
.../openzfs/module/os/linux/spl/spl-kmem-cache.c | 3 -
.../openzfs/module/os/linux/spl/spl-taskq.c | 4 +-
.../openzfs/module/os/linux/spl/spl-thread.c | 7 +-
.../openzfs/module/os/linux/zfs/vdev_disk.c | 43 +-
.../openzfs/module/os/linux/zfs/zfs_znode_os.c | 9 +
sys/contrib/openzfs/module/os/linux/zfs/zpl_file.c | 84 +
.../openzfs/module/os/linux/zfs/zpl_inode.c | 5 +
sys/contrib/openzfs/module/zcommon/simd_stat.c | 8 +-
sys/contrib/openzfs/module/zcommon/zfs_comutil.c | 4 +
sys/contrib/openzfs/module/zfs/arc.c | 20 +-
sys/contrib/openzfs/module/zfs/dbuf.c | 10 +
sys/contrib/openzfs/module/zfs/ddt.c | 10 +-
sys/contrib/openzfs/module/zfs/dmu.c | 60 +-
sys/contrib/openzfs/module/zfs/dmu_objset.c | 1 +
sys/contrib/openzfs/module/zfs/dmu_recv.c | 11 +-
sys/contrib/openzfs/module/zfs/dmu_send.c | 23 +
sys/contrib/openzfs/module/zfs/dmu_traverse.c | 18 +-
sys/contrib/openzfs/module/zfs/dnode.c | 8 +-
sys/contrib/openzfs/module/zfs/dsl_bookmark.c | 10 +-
sys/contrib/openzfs/module/zfs/dsl_crypt.c | 108 +-
sys/contrib/openzfs/module/zfs/dsl_dataset.c | 14 +
sys/contrib/openzfs/module/zfs/dsl_deadlist.c | 4 +-
sys/contrib/openzfs/module/zfs/dsl_destroy.c | 124 +-
sys/contrib/openzfs/module/zfs/dsl_scan.c | 7 +
sys/contrib/openzfs/module/zfs/dsl_userhold.c | 16 +-
sys/contrib/openzfs/module/zfs/spa.c | 427 ++++-
sys/contrib/openzfs/module/zfs/spa_config.c | 2 +-
sys/contrib/openzfs/module/zfs/spa_log_spacemap.c | 11 +-
sys/contrib/openzfs/module/zfs/vdev.c | 161 +-
sys/contrib/openzfs/module/zfs/vdev_draid.c | 3 +-
sys/contrib/openzfs/module/zfs/vdev_initialize.c | 1 +
sys/contrib/openzfs/module/zfs/vdev_label.c | 64 +-
sys/contrib/openzfs/module/zfs/vdev_mirror.c | 12 +-
sys/contrib/openzfs/module/zfs/vdev_queue.c | 27 +-
sys/contrib/openzfs/module/zfs/vdev_raidz.c | 10 +-
sys/contrib/openzfs/module/zfs/vdev_removal.c | 14 +
sys/contrib/openzfs/module/zfs/vdev_trim.c | 1 +
sys/contrib/openzfs/module/zfs/zcp_synctask.c | 24 +-
sys/contrib/openzfs/module/zfs/zfs_vnops.c | 49 +-
sys/contrib/openzfs/module/zfs/zio.c | 483 +++++-
sys/contrib/openzfs/module/zstd/zfs_zstd.c | 2 +
sys/contrib/openzfs/tests/runfiles/common.run | 19 +-
sys/contrib/openzfs/tests/runfiles/linux.run | 7 +-
sys/contrib/openzfs/tests/runfiles/sanity.run | 3 +-
.../openzfs/tests/test-runner/bin/zts-report.py.in | 53 +-
sys/contrib/openzfs/tests/unit/.gitignore | 1 +
sys/contrib/openzfs/tests/unit/Makefile.am | 21 +-
sys/contrib/openzfs/tests/unit/test_btree.c | 93 +
sys/contrib/openzfs/tests/unit/test_nvpair.c | 1829 ++++++++++++++++++++
sys/contrib/openzfs/tests/unit/unit.c | 40 +
sys/contrib/openzfs/tests/unit/unit.h | 93 +-
sys/contrib/openzfs/tests/zfs-tests/cmd/.gitignore | 1 +
.../openzfs/tests/zfs-tests/cmd/Makefile.am | 3 +
sys/contrib/openzfs/tests/zfs-tests/cmd/ctime.c | 22 +-
.../tests/zfs-tests/cmd/file/file_uncached.c | 184 ++
.../openzfs/tests/zfs-tests/cmd/mmap_sync.c | 228 ++-
.../openzfs/tests/zfs-tests/include/blkdev.shlib | 10 +-
.../openzfs/tests/zfs-tests/include/commands.cfg | 1 +
.../openzfs/tests/zfs-tests/include/kstat.shlib | 9 +-
.../openzfs/tests/zfs-tests/include/libtest.shlib | 52 +
.../openzfs/tests/zfs-tests/tests/Makefile.am | 14 +
.../functional/alloc_class/alloc_class_016_pos.ksh | 6 +-
.../synctask_core/tst.destroy_bookmark.ksh | 45 +
.../cli_root/zdb/zdb_object_range_neg.ksh | 2 +-
.../zfs_change-key/zfs_change-key_mismatch.ksh | 76 +
.../cli_root/zfs_destroy/zfs_destroy_001_pos.ksh | 6 +-
.../cli_root/zfs_destroy/zfs_destroy_005_neg.ksh | 9 +-
.../cli_root/zfs_destroy/zfs_destroy_common.kshlib | 40 +
.../cli_root/zhack/zhack_mos_scan_reclaim.ksh | 197 +++
.../cli_root/zpool_expand/zpool_expand_007_pos.ksh | 153 ++
.../zpool_import/import_relax_metadata_damaged.ksh | 131 ++
.../import_rewind_metadata_damaged.ksh | 118 ++
.../zpool_import/zpool_import_missing_003_pos.ksh | 7 +-
.../zpool_initialize_online_offline.ksh | 9 +
.../cli_root/zpool_split/zpool_split_devices.ksh | 19 +-
.../functional/compression/compress_004_pos.ksh | 7 +-
.../functional/device_access/device_access.kshlib | 4 +-
.../device_access/device_access_import.ksh | 9 +-
.../tests/functional/device_access/setup.ksh | 3 +
.../functional/direct/dio_read_verify_decline.ksh | 117 ++
.../tests/functional/exec/exec_001_pos.ksh | 8 +-
.../tests/functional/history/history_001_pos.ksh | 2 +-
.../tests/functional/history/history_007_pos.ksh | 2 +-
.../l2arc/l2arc_multidev_scaling_pos.ksh | 161 +-
.../tests/zfs-tests/tests/functional/mmp/mmp.cfg | 7 +
.../zfs-tests/tests/functional/mmp/mmp.kshlib | 21 +-
.../tests/functional/mmp/mmp_concurrent_import.ksh | 34 +-
.../zfs-tests/tests/functional/mmp/mmp_hostid.ksh | 3 +-
.../zfs-tests/tests/functional/mmp/mmp_on_off.ksh | 3 +-
.../tests/functional/mmp/mmp_on_thread.ksh | 3 +-
.../tests/functional/mmp/mmp_on_uberblocks.ksh | 24 +-
.../zfs-tests/tests/functional/mmp/mmp_on_zdb.ksh | 3 +-
.../tests/functional/mmp/mmp_reset_interval.ksh | 10 +-
.../functional/mmp/mmp_write_distribution.ksh | 3 +-
.../tests/functional/mmp/mmp_write_uberblocks.ksh | 5 +-
.../functional/procfs/procfs_list_stale_read.ksh | 3 +-
.../functional/raidz/raidz_expand_001_pos.ksh | 17 +-
.../functional/raidz/raidz_expand_003_pos.ksh | 16 +-
.../functional/raidz/raidz_expand_005_pos.ksh | 17 +-
.../redacted_send/redacted_meta_dnode.ksh | 154 ++
.../rsend/send_realloc_dnode_interior.ksh | 116 ++
.../snapdir/snapdir_mount_destroy_defer.ksh | 101 ++
.../tests/functional/uncached/cleanup.ksh | 19 +
.../zfs-tests/tests/functional/uncached/setup.ksh | 20 +
.../functional/uncached/uncached_dontcache.ksh | 100 ++
.../tests/functional/uncached/uncached_noreuse.ksh | 103 ++
.../user_namespace/user_namespace_001.ksh | 4 +-
.../functional/zstream/zstream_raw_001_pos.ksh | 9 +-
sys/modules/zfs/zfs_config.h | 16 +-
sys/modules/zfs/zfs_gitrev.h | 2 +-
165 files changed, 8215 insertions(+), 1042 deletions(-)
diff --cc cddl/usr.sbin/zhack/Makefile
index f6225e7f5d99,000000000000..f8a7257e2053
mode 100644,000000..100644
--- a/cddl/usr.sbin/zhack/Makefile
+++ b/cddl/usr.sbin/zhack/Makefile
@@@ -1,31 -1,0 +1,31 @@@
+.PATH: ${ZFSTOP}/cmd
+.PATH: ${ZFSTOP}/man/man1
+
+PACKAGE= zfs
+PROG= zhack
+MAN= zhack.1
+
+WARNS?= 0
+CSTD= c99
+
+WARNS?= 2
+CFLAGS+= -DIN_BASE
+CFLAGS+= -I${ZFSTOP}/include
+CFLAGS+= -I${ZFSTOP}/lib/libspl/include/
+CFLAGS+= -I${ZFSTOP}/lib/libspl/include/os/freebsd
+CFLAGS+= -I${ZFSTOP}/lib/libzpool/include
+CFLAGS+= -I${SRCTOP}/sys
+CFLAGS+= -I${SRCTOP}/cddl/compat/opensolaris/include
+CFLAGS+= -I${ZFSTOP}/module/icp/include
+CFLAGS+= -include ${ZFSTOP}/include/sys/simd_config.h
+CFLAGS+= -include ${ZFSTOP}/include/os/freebsd/spl/sys/ccompile.h
+CFLAGS+= -DHAVE_ISSETUGID
+CFLAGS+= -include ${SRCTOP}/sys/modules/zfs/zfs_config.h
+
+
- LIBADD= nvpair zfs spl zutil zpool pthread
++LIBADD= avl nvpair zfs spl zutil zpool pthread
+
+CFLAGS+= -DDEBUG=1
+#DEBUG_FLAGS+= -g
+
+.include <bsd.prog.mk>
diff --cc sys/contrib/openzfs/config/kernel-inode-create.m4
index 000000000000,e0ab355873ad..e0ab355873ad
mode 000000,100644..100644
--- a/sys/contrib/openzfs/config/kernel-inode-create.m4
+++ b/sys/contrib/openzfs/config/kernel-inode-create.m4
diff --cc sys/contrib/openzfs/config/kernel-vfs-fop-flags.m4
index 000000000000,091221165ebb..091221165ebb
mode 000000,100644..100644
--- a/sys/contrib/openzfs/config/kernel-vfs-fop-flags.m4
+++ b/sys/contrib/openzfs/config/kernel-vfs-fop-flags.m4
diff --cc sys/contrib/openzfs/include/os/linux/kernel/linux/kthread_compat.h
index 000000000000,f68fc9f0979e..f68fc9f0979e
mode 000000,100644..100644
--- a/sys/contrib/openzfs/include/os/linux/kernel/linux/kthread_compat.h
+++ b/sys/contrib/openzfs/include/os/linux/kernel/linux/kthread_compat.h
diff --cc sys/contrib/openzfs/module/os/freebsd/zfs/sysctl_os.c
index 6d3737b3c255,000000000000..00a027f9101e
mode 100644,000000..100644
--- a/sys/contrib/openzfs/module/os/freebsd/zfs/sysctl_os.c
+++ b/sys/contrib/openzfs/module/os/freebsd/zfs/sysctl_os.c
@@@ -1,769 -1,0 +1,770 @@@
+// SPDX-License-Identifier: BSD-2-Clause
+/*
+ * Copyright (c) 2020 iXsystems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/kernel.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/mutex.h>
+#include <sys/proc.h>
+#include <sys/errno.h>
+#include <sys/uio.h>
+#include <sys/buf.h>
+#include <sys/file.h>
+#include <sys/kmem.h>
+#include <sys/conf.h>
+#include <sys/cmn_err.h>
+#include <sys/stat.h>
+#include <sys/zfs_ioctl.h>
+#include <sys/zfs_vfsops.h>
+#include <sys/zfs_znode.h>
+#include <sys/zap.h>
+#include <sys/spa.h>
+#include <sys/spa_impl.h>
+#include <sys/vdev.h>
+#include <sys/vdev_impl.h>
+#include <sys/arc_os.h>
+#include <sys/dmu.h>
+#include <sys/dsl_dir.h>
+#include <sys/dsl_dataset.h>
+#include <sys/dsl_prop.h>
+#include <sys/dsl_deleg.h>
+#include <sys/dmu_objset.h>
+#include <sys/dmu_impl.h>
+#include <sys/dmu_tx.h>
+#include <sys/sunddi.h>
+#include <sys/policy.h>
+#include <sys/zone.h>
+#include <sys/nvpair.h>
+#include <sys/mount.h>
+#include <sys/taskqueue.h>
+#include <sys/sdt.h>
+#include <sys/fs/zfs.h>
+#include <sys/zfs_ctldir.h>
+#include <sys/zfs_dir.h>
+#include <sys/zfs_onexit.h>
+#include <sys/zvol.h>
+#include <sys/dsl_scan.h>
+#include <sys/dmu_objset.h>
+#include <sys/dmu_send.h>
+#include <sys/dsl_destroy.h>
+#include <sys/dsl_bookmark.h>
+#include <sys/dsl_userhold.h>
+#include <sys/zfeature.h>
+#include <sys/zcp.h>
+#include <sys/zio_checksum.h>
+#include <sys/vdev_removal.h>
+#include <sys/dsl_crypt.h>
+
+#include <sys/zfs_ioctl_compat.h>
+#include <sys/zfs_context.h>
+
+#include <sys/arc_impl.h>
+#include <sys/dsl_pool.h>
+
+#include <sys/vmmeter.h>
+
+SYSCTL_DECL(_vfs_zfs);
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, arc, CTLFLAG_RW, 0,
+ "ZFS adaptive replacement cache");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, brt, CTLFLAG_RW, 0,
+ "ZFS Block Reference Table");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, condense, CTLFLAG_RW, 0, "ZFS condense");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, dbuf, CTLFLAG_RW, 0, "ZFS disk buf cache");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, dbuf_cache, CTLFLAG_RW, 0,
+ "ZFS disk buf cache");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, deadman, CTLFLAG_RW, 0, "ZFS deadman");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, dedup, CTLFLAG_RW, 0, "ZFS dedup");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, l2arc, CTLFLAG_RW, 0, "ZFS l2arc");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, livelist, CTLFLAG_RW, 0, "ZFS livelist");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, lua, CTLFLAG_RW, 0, "ZFS lua");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, metaslab, CTLFLAG_RW, 0, "ZFS metaslab");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, mg, CTLFLAG_RW, 0, "ZFS metaslab group");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, multihost, CTLFLAG_RW, 0,
+ "ZFS multihost protection");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, prefetch, CTLFLAG_RW, 0, "ZFS prefetch");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, reconstruct, CTLFLAG_RW, 0, "ZFS reconstruct");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, recv, CTLFLAG_RW, 0, "ZFS receive");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, send, CTLFLAG_RW, 0, "ZFS send");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, spa, CTLFLAG_RW, 0, "ZFS space allocation");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, trim, CTLFLAG_RW, 0, "ZFS TRIM");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, txg, CTLFLAG_RW, 0, "ZFS transaction group");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, vdev, CTLFLAG_RW, 0, "ZFS VDEV");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, vnops, CTLFLAG_RW, 0, "ZFS VNOPS");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, zevent, CTLFLAG_RW, 0, "ZFS event");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, zil, CTLFLAG_RW, 0, "ZFS ZIL");
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, zio, CTLFLAG_RW, 0, "ZFS ZIO");
+
+SYSCTL_NODE(_vfs_zfs_livelist, OID_AUTO, condense, CTLFLAG_RW, 0,
+ "ZFS livelist condense");
+SYSCTL_NODE(_vfs_zfs_vdev, OID_AUTO, file, CTLFLAG_RW, 0, "ZFS VDEV file");
+SYSCTL_NODE(_vfs_zfs_vdev, OID_AUTO, mirror, CTLFLAG_RD, 0,
+ "ZFS VDEV mirror");
+
+SYSCTL_DECL(_vfs_zfs_version);
+SYSCTL_CONST_STRING(_vfs_zfs_version, OID_AUTO, module, CTLFLAG_RD,
+ (ZFS_META_VERSION "-" ZFS_META_RELEASE), "OpenZFS module version");
+
+/* arc.c */
+
+int
+param_set_arc_u64(SYSCTL_HANDLER_ARGS)
+{
+ int err;
+
+ err = sysctl_handle_64(oidp, arg1, 0, req);
+ if (err != 0 || req->newptr == NULL)
+ return (err);
+
+ arc_tuning_update(B_TRUE);
+
+ return (0);
+}
+
+int
+param_set_arc_int(SYSCTL_HANDLER_ARGS)
+{
+ int err;
+
+ err = sysctl_handle_int(oidp, arg1, 0, req);
+ if (err != 0 || req->newptr == NULL)
+ return (err);
+
+ arc_tuning_update(B_TRUE);
+
+ return (0);
+}
+
+static void
+warn_deprecated_sysctl(const char *old, const char *new)
+{
+ printf("WARNING: sysctl vfs.zfs.%s is deprecated. Use vfs.zfs.%s instead.\n",
+ old, new);
+}
+
+int
+param_set_l2arc_dwpd_limit(SYSCTL_HANDLER_ARGS)
+{
+ uint64_t old_val = l2arc_dwpd_limit;
+ int err;
+
+ err = sysctl_handle_64(oidp, arg1, 0, req);
+ if (err != 0 || req->newptr == NULL)
+ return (err);
+
+ if (l2arc_dwpd_limit != old_val)
+ l2arc_dwpd_bump_reset();
+
+ return (0);
+}
+
+int
+param_set_arc_max(SYSCTL_HANDLER_ARGS)
+{
+ unsigned long val;
+ int err;
+
+ val = zfs_arc_max;
+ err = sysctl_handle_64(oidp, &val, 0, req);
+ if (err != 0 || req->newptr == NULL)
+ return (SET_ERROR(err));
+
+ if (val != 0 && (val < MIN_ARC_MAX || val <= arc_c_min ||
+ val >= arc_all_memory()))
+ return (SET_ERROR(EINVAL));
+
+ zfs_arc_max = val;
+ arc_tuning_update(B_TRUE);
+
+ /* Update the sysctl to the tuned value */
- if (val != 0)
++ if (val != 0 && arc_c_max != 0)
+ zfs_arc_max = arc_c_max;
+
+ if (arg2 != 0)
+ warn_deprecated_sysctl("arc_max", "arc.max");
+
+ return (0);
+}
+
+SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_max,
+ CTLTYPE_ULONG | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
+ NULL, 1, param_set_arc_max, "LU",
+ "Maximum ARC size in bytes (LEGACY)");
+
+int
+param_set_arc_min(SYSCTL_HANDLER_ARGS)
+{
+ unsigned long val;
+ int err;
+
+ val = zfs_arc_min;
+ err = sysctl_handle_64(oidp, &val, 0, req);
+ if (err != 0 || req->newptr == NULL)
+ return (SET_ERROR(err));
+
- if (val != 0 && (val < 2ULL << SPA_MAXBLOCKSHIFT || val > arc_c_max))
++ if (val != 0 && (val < 2ULL << SPA_MAXBLOCKSHIFT ||
++ (arc_c_max != 0 && val > arc_c_max)))
+ return (SET_ERROR(EINVAL));
+
+ zfs_arc_min = val;
+ arc_tuning_update(B_TRUE);
+
+ /* Update the sysctl to the tuned value */
- if (val != 0)
++ if (val != 0 && arc_c_max != 0)
+ zfs_arc_min = arc_c_min;
+
+ if (arg2 != 0)
+ warn_deprecated_sysctl("arc_min", "arc.min");
+
+ return (0);
+}
+
+SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_min,
+ CTLTYPE_ULONG | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
+ NULL, 1, param_set_arc_min, "LU",
+ "Minimum ARC size in bytes (LEGACY)");
+
+extern uint_t zfs_arc_free_target;
+
+int
+param_set_arc_free_target(SYSCTL_HANDLER_ARGS)
+{
+ uint_t val;
+ int err;
+
+ val = zfs_arc_free_target;
+ err = sysctl_handle_int(oidp, &val, 0, req);
+ if (err != 0 || req->newptr == NULL)
+ return (err);
+
+ if (val < minfree)
+ return (EINVAL);
+ if (val > vm_cnt.v_page_count)
+ return (EINVAL);
+
+ zfs_arc_free_target = val;
+
+ if (arg2 != 0)
+ warn_deprecated_sysctl("arc_free_target", "arc.free_target");
+
+ return (0);
+}
+
+/*
+ * NOTE: This sysctl is CTLFLAG_RW not CTLFLAG_RWTUN due to its dependency on
+ * pagedaemon initialization.
+ */
+SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_free_target,
+ CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_MPSAFE,
+ NULL, 1, param_set_arc_free_target, "IU",
+ "Desired number of free pages below which ARC triggers reclaim"
+ " (LEGACY)");
+
+int
+param_set_arc_no_grow_shift(SYSCTL_HANDLER_ARGS)
+{
+ int err, val;
+
+ val = zfs_arc_no_grow_shift;
+ err = sysctl_handle_int(oidp, &val, 0, req);
+ if (err != 0 || req->newptr == NULL)
+ return (err);
+
+ if (val < 0 || val >= arc_shrink_shift)
+ return (EINVAL);
+
+ zfs_arc_no_grow_shift = val;
+
+ if (arg2 != 0)
+ warn_deprecated_sysctl("arc_no_grow_shift", "arc.no_grow_shift");
+
+ return (0);
+}
+
+SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_no_grow_shift,
+ CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
+ NULL, 1, param_set_arc_no_grow_shift, "I",
+ "log2(fraction of ARC which must be free to allow growing) (LEGACY)");
+
+#if 0
+extern uint64_t l2arc_write_max;
+
+SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_write_max,
+ CTLFLAG_RWTUN, &l2arc_write_max, 0,
+ "Max write bytes per interval (LEGACY)");
+
+extern uint64_t l2arc_write_boost;
+
+SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_write_boost,
+ CTLFLAG_RWTUN, &l2arc_write_boost, 0,
+ "Extra write bytes during device warmup (LEGACY)");
+
+extern uint64_t l2arc_headroom;
+
+SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_headroom,
+ CTLFLAG_RWTUN, &l2arc_headroom, 0,
+ "Number of max device writes to precache (LEGACY)");
+
+extern uint64_t l2arc_headroom_boost;
+
+SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_headroom_boost,
+ CTLFLAG_RWTUN, &l2arc_headroom_boost, 0,
+ "Compressed l2arc_headroom multiplier (LEGACY)");
+
+extern uint64_t l2arc_feed_secs;
+
+SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_feed_secs,
+ CTLFLAG_RWTUN, &l2arc_feed_secs, 0,
+ "Seconds between L2ARC writing (LEGACY)");
+
+extern uint64_t l2arc_feed_min_ms;
+
+SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_feed_min_ms,
+ CTLFLAG_RWTUN, &l2arc_feed_min_ms, 0,
+ "Min feed interval in milliseconds (LEGACY)");
+
+extern int l2arc_noprefetch;
+
+SYSCTL_INT(_vfs_zfs, OID_AUTO, l2arc_noprefetch,
+ CTLFLAG_RWTUN, &l2arc_noprefetch, 0,
+ "Skip caching prefetched buffers (LEGACY)");
+
+extern int l2arc_feed_again;
+
+SYSCTL_INT(_vfs_zfs, OID_AUTO, l2arc_feed_again,
+ CTLFLAG_RWTUN, &l2arc_feed_again, 0,
+ "Turbo L2ARC warmup (LEGACY)");
+
+extern int l2arc_norw;
+
+SYSCTL_INT(_vfs_zfs, OID_AUTO, l2arc_norw,
+ CTLFLAG_RWTUN, &l2arc_norw, 0,
+ "No reads during writes (LEGACY)");
+
+#endif
+
+static int
+param_get_arc_state_size(SYSCTL_HANDLER_ARGS)
+{
+ arc_state_t *state = (arc_state_t *)arg1;
+ int64_t val;
+
+ val = zfs_refcount_count(&state->arcs_size[ARC_BUFC_DATA]) +
+ zfs_refcount_count(&state->arcs_size[ARC_BUFC_METADATA]);
+ return (sysctl_handle_64(oidp, &val, 0, req));
+}
+
+extern arc_state_t ARC_anon;
+
+SYSCTL_PROC(_vfs_zfs, OID_AUTO, anon_size,
+ CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
+ &ARC_anon, 0, param_get_arc_state_size, "Q",
+ "size of anonymous state");
+SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, anon_metadata_esize, CTLFLAG_RD,
+ &ARC_anon.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
+ "size of evictable metadata in anonymous state");
+SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, anon_data_esize, CTLFLAG_RD,
+ &ARC_anon.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
+ "size of evictable data in anonymous state");
+
+extern arc_state_t ARC_mru;
+
+SYSCTL_PROC(_vfs_zfs, OID_AUTO, mru_size,
+ CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
+ &ARC_mru, 0, param_get_arc_state_size, "Q",
+ "size of mru state");
+SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mru_metadata_esize, CTLFLAG_RD,
+ &ARC_mru.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
+ "size of evictable metadata in mru state");
+SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mru_data_esize, CTLFLAG_RD,
+ &ARC_mru.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
+ "size of evictable data in mru state");
+
+extern arc_state_t ARC_mru_ghost;
+
+SYSCTL_PROC(_vfs_zfs, OID_AUTO, mru_ghost_size,
+ CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
+ &ARC_mru_ghost, 0, param_get_arc_state_size, "Q",
+ "size of mru ghost state");
+SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mru_ghost_metadata_esize, CTLFLAG_RD,
+ &ARC_mru_ghost.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
+ "size of evictable metadata in mru ghost state");
+SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mru_ghost_data_esize, CTLFLAG_RD,
+ &ARC_mru_ghost.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
+ "size of evictable data in mru ghost state");
+
+extern arc_state_t ARC_mfu;
+
+SYSCTL_PROC(_vfs_zfs, OID_AUTO, mfu_size,
+ CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
+ &ARC_mfu, 0, param_get_arc_state_size, "Q",
+ "size of mfu state");
+SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_metadata_esize, CTLFLAG_RD,
+ &ARC_mfu.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
+ "size of evictable metadata in mfu state");
+SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_data_esize, CTLFLAG_RD,
+ &ARC_mfu.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
+ "size of evictable data in mfu state");
+
+extern arc_state_t ARC_mfu_ghost;
+
+SYSCTL_PROC(_vfs_zfs, OID_AUTO, mfu_ghost_size,
+ CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
+ &ARC_mfu_ghost, 0, param_get_arc_state_size, "Q",
+ "size of mfu ghost state");
+SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_ghost_metadata_esize, CTLFLAG_RD,
+ &ARC_mfu_ghost.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
+ "size of evictable metadata in mfu ghost state");
+SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_ghost_data_esize, CTLFLAG_RD,
+ &ARC_mfu_ghost.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
+ "size of evictable data in mfu ghost state");
+
+extern arc_state_t ARC_uncached;
+
+SYSCTL_PROC(_vfs_zfs, OID_AUTO, uncached_size,
+ CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
+ &ARC_uncached, 0, param_get_arc_state_size, "Q",
+ "size of uncached state");
+SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, uncached_metadata_esize, CTLFLAG_RD,
+ &ARC_uncached.arcs_esize[ARC_BUFC_METADATA].rc_count, 0,
+ "size of evictable metadata in uncached state");
+SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, uncached_data_esize, CTLFLAG_RD,
+ &ARC_uncached.arcs_esize[ARC_BUFC_DATA].rc_count, 0,
+ "size of evictable data in uncached state");
+
+extern arc_state_t ARC_l2c_only;
+
+SYSCTL_PROC(_vfs_zfs, OID_AUTO, l2c_only_size,
+ CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
+ &ARC_l2c_only, 0, param_get_arc_state_size, "Q",
+ "size of l2c_only state");
+
+/* dbuf.c */
+
+/* dmu.c */
+
+/* dmu_zfetch.c */
+
+SYSCTL_NODE(_vfs_zfs, OID_AUTO, zfetch, CTLFLAG_RW, 0, "ZFS ZFETCH (LEGACY)");
+
+extern uint32_t zfetch_max_distance;
+
+SYSCTL_UINT(_vfs_zfs_zfetch, OID_AUTO, max_distance,
+ CTLFLAG_RWTUN, &zfetch_max_distance, 0,
+ "Max bytes to prefetch per stream (LEGACY)");
+
+extern uint32_t zfetch_max_idistance;
+
+SYSCTL_UINT(_vfs_zfs_zfetch, OID_AUTO, max_idistance,
+ CTLFLAG_RWTUN, &zfetch_max_idistance, 0,
+ "Max bytes to prefetch indirects for per stream (LEGACY)");
+
+/* dsl_pool.c */
+
+/* dnode.c */
+
+/* dsl_scan.c */
+
+/* metaslab.c */
+
+int
+param_set_active_allocator(SYSCTL_HANDLER_ARGS)
+{
+ char buf[16];
+ int rc;
+
+ if (req->newptr == NULL)
+ strlcpy(buf, zfs_active_allocator, sizeof (buf));
+
+ rc = sysctl_handle_string(oidp, buf, sizeof (buf), req);
+ if (rc || req->newptr == NULL)
+ return (rc);
+ if (strcmp(buf, zfs_active_allocator) == 0)
+ return (0);
+
+ return (param_set_active_allocator_common(buf));
+}
+
+/*
+ * The in-core space map representation is more compact than its on-disk form.
+ * The zfs_metaslab_condense_pct determines how much more compact the in-core
+ * space map representation must be before we compact it on-disk.
+ * Values should be greater than or equal to 100.
+ */
+extern uint_t zfs_metaslab_condense_pct;
+
+SYSCTL_UINT(_vfs_zfs_metaslab, OID_AUTO, condense_pct,
+ CTLFLAG_RWTUN, &zfs_metaslab_condense_pct, 0,
+ "Condense on-disk spacemap when it is more than this many percents"
+ " of in-memory counterpart");
+
+extern uint_t zfs_remove_max_segment;
+
+SYSCTL_UINT(_vfs_zfs, OID_AUTO, remove_max_segment,
+ CTLFLAG_RWTUN, &zfs_remove_max_segment, 0,
+ "Largest contiguous segment ZFS will attempt to allocate when removing"
+ " a device");
+
+extern int zfs_removal_suspend_progress;
+
+SYSCTL_INT(_vfs_zfs, OID_AUTO, removal_suspend_progress,
+ CTLFLAG_RWTUN, &zfs_removal_suspend_progress, 0,
+ "Ensures certain actions can happen while in the middle of a removal");
+
+/* mmp.c */
+
+int
+param_set_multihost_interval(SYSCTL_HANDLER_ARGS)
+{
+ int err;
+
+ err = sysctl_handle_64(oidp, &zfs_multihost_interval, 0, req);
+ if (err != 0 || req->newptr == NULL)
+ return (err);
+
+ if (spa_mode_global != SPA_MODE_UNINIT)
+ mmp_signal_all_threads();
+
+ return (0);
+}
+
+/* spa_misc.c */
+
+extern int zfs_flags;
+
+static int
+sysctl_vfs_zfs_debug_flags(SYSCTL_HANDLER_ARGS)
+{
+ int err, val;
+
+ val = zfs_flags;
+ err = sysctl_handle_int(oidp, &val, 0, req);
+ if (err != 0 || req->newptr == NULL)
+ return (err);
+
+ /*
+ * ZFS_DEBUG_MODIFY must be enabled prior to boot so all
+ * arc buffers in the system have the necessary additional
+ * checksum data. However, it is safe to disable at any
+ * time.
+ */
+ if (!(zfs_flags & ZFS_DEBUG_MODIFY))
+ val &= ~ZFS_DEBUG_MODIFY;
+ zfs_flags = val;
+
+ return (0);
+}
+
+SYSCTL_PROC(_vfs_zfs, OID_AUTO, debugflags,
+ CTLTYPE_UINT | CTLFLAG_MPSAFE | CTLFLAG_RWTUN, NULL, 0,
+ sysctl_vfs_zfs_debug_flags, "IU", "Debug flags for ZFS testing.");
+
+int
+param_set_deadman_synctime(SYSCTL_HANDLER_ARGS)
+{
+ unsigned long val;
+ int err;
+
+ val = zfs_deadman_synctime_ms;
+ err = sysctl_handle_64(oidp, &val, 0, req);
+ if (err != 0 || req->newptr == NULL)
+ return (err);
+ zfs_deadman_synctime_ms = val;
+
+ spa_set_deadman_synctime(MSEC2NSEC(zfs_deadman_synctime_ms));
+
+ return (0);
+}
+
+int
+param_set_deadman_ziotime(SYSCTL_HANDLER_ARGS)
+{
+ unsigned long val;
+ int err;
+
+ val = zfs_deadman_ziotime_ms;
+ err = sysctl_handle_64(oidp, &val, 0, req);
+ if (err != 0 || req->newptr == NULL)
+ return (err);
+ zfs_deadman_ziotime_ms = val;
+
+ spa_set_deadman_ziotime(MSEC2NSEC(zfs_deadman_synctime_ms));
+
+ return (0);
+}
+
+int
+param_set_deadman_failmode(SYSCTL_HANDLER_ARGS)
+{
+ char buf[16];
+ int rc;
+
+ if (req->newptr == NULL)
+ strlcpy(buf, zfs_deadman_failmode, sizeof (buf));
+
+ rc = sysctl_handle_string(oidp, buf, sizeof (buf), req);
+ if (rc || req->newptr == NULL)
+ return (rc);
+ if (strcmp(buf, zfs_deadman_failmode) == 0)
+ return (0);
+ if (strcmp(buf, "wait") == 0)
+ zfs_deadman_failmode = "wait";
+ if (strcmp(buf, "continue") == 0)
+ zfs_deadman_failmode = "continue";
+ if (strcmp(buf, "panic") == 0)
+ zfs_deadman_failmode = "panic";
+
+ return (-param_set_deadman_failmode_common(buf));
+}
+
+int
+param_set_raidz_impl(SYSCTL_HANDLER_ARGS)
+{
+ const size_t bufsize = 128;
+ char *buf;
+ int rc;
+
+ buf = malloc(bufsize, M_SOLARIS, M_WAITOK | M_ZERO);
+ if (req->newptr == NULL)
+ vdev_raidz_impl_get(buf, bufsize);
+
+ rc = sysctl_handle_string(oidp, buf, bufsize, req);
+ if (rc || req->newptr == NULL) {
+ free(buf, M_SOLARIS);
+ return (rc);
+ }
+ rc = vdev_raidz_impl_set(buf);
+ free(buf, M_SOLARIS);
+ return (rc);
+}
+
+int
+param_set_slop_shift(SYSCTL_HANDLER_ARGS)
+{
+ int val;
+ int err;
+
+ val = spa_slop_shift;
+ err = sysctl_handle_int(oidp, &val, 0, req);
+ if (err != 0 || req->newptr == NULL)
+ return (err);
+
+ if (val < 1 || val > 31)
+ return (EINVAL);
+
+ spa_slop_shift = val;
+
+ return (0);
+}
+
+/* spacemap.c */
+
+extern int space_map_ibs;
+
+SYSCTL_INT(_vfs_zfs, OID_AUTO, space_map_ibs, CTLFLAG_RWTUN,
+ &space_map_ibs, 0, "Space map indirect block shift");
+
*** 8387 LINES SKIPPED ***