From nobody Mon Sep 14 12:38:10 2026 X-Original-To: dev-commits-src-all@mlmmj.nyi.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2610:1c1:1:606c::19:1]) by mlmmj.nyi.freebsd.org (Postfix) with ESMTP id 4hk4SS3Qvbz6sWFR for ; Mon, 14 Sep 2026 12:38:16 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from mxrelay.nyi.freebsd.org (mxrelay.nyi.freebsd.org [IPv6:2610:1c1:1:606c::19:3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange x25519 server-signature RSA-PSS (4096 bits) server-digest SHA256 client-signature RSA-PSS (4096 bits) client-digest SHA256) (Client CN "mxrelay.nyi.freebsd.org", Issuer "YR2" (not verified)) by mx1.freebsd.org (Postfix) with ESMTPS id 4hk4SS1Fyhz3NDk for ; Mon, 14 Sep 2026 12:38:16 +0000 (UTC) (envelope-from git@FreeBSD.org) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1789389496; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=mV8yWrHsF7m7Ytq2T4mdC9aIf0qXx13KJrQ1S0lCFxM=; b=eX7gKaKdkNtgDwsp3bz9QE8cT0NE2Wu4vyCv1PZgYiuBC0pCfvOFn30IUfCaFGFirNCTkA qk7H+Ubo+V+ZulL2NxYQIHIDgRQYc2jvdU+nINuOfhemxpR7aKtoJeohotbzZsSqnl3gbD Fh62svWXDi5jNW005V19AU+dJzmaxeGtzod7WsSYE2RsCC7FSUL0fsjwaRP+RxpmFi6U/e un06rFlA281jwAnvRbjlZ2ohjgr0JS/sjussjyNStRfnDYzMaXzXyderXFc7IBSee/EJzV GPLNx7NwuYI56CDuO+QsXX8EAYW+QeCxC4qiuTgiiw9RSAIqObKd/RDIGQ/L1w== ARC-Seal: i=1; a=rsa-sha256; d=freebsd.org; s=dkim; cv=none; t=1789389496; b=mzG+SK9RyWT6ym3vE/B1xj6nwMdP+bg1wCGixkN36GBudDa63OYBY9AkShW1N7pih6SOfc F/qdsDGEix8kJkUXQ67Y5zmQ+2+qVCb9TRNpVO0TRmeIdU9QlkgzV1rt6QL6Id+HXVUpuS s5C48mV+xR4I5cJHrW2aDmJ+/SxD/dNhPm/GXw7IqLZx+96Pzk+cFMs9SN4imaxlfJEC3N QsrB5HVeFmhX2Yo3tySp4yoxcpI8JVmQyZMh2LMTjUefuqfrdXjog03+at/mAgFKhjqkqo 2xjgbE+YBRhuVDoNdtDEE9VKODZ726s0n4QZYVKOz/+r4/JQ5KQCc29xW9BKJQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1789389496; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=mV8yWrHsF7m7Ytq2T4mdC9aIf0qXx13KJrQ1S0lCFxM=; b=xJEKUbIYljzotJOivwyyySImihSP9PTj1qc0fn8iOBqiQbLEXeK1bnW0efb3m26rk8Uu/6 VB292TDLOikl2fJvX9DpQbppBi0SCyPcpRBWeG0TaDzRoL7slHFKpdv84kVP3WnAxg0+4g ZyICPKU1GuU9UkP0KWfV/JSfKW6TryURZm3iJm48MPilXreRLsbJJdv68CsDGdrpcHS386 do9R0QvbzX4XOitxf5KWdmWgzOW6XPaGqyQ0HQ65QkwKCW8l/F3pr5EwG7UargPxc8XEgz 0zc3onGd7zj+y3o7st+8kd+c/rdciU0sXKyx9olnoGfjIKF+v1DFt2/89c4SMQ== ARC-Authentication-Results: i=1; mx1.freebsd.org; none Received: from gitrepo.freebsd.org (gitrepo.freebsd.org [IPv6:2610:1c1:1:6068::e6a:5]) by mxrelay.nyi.freebsd.org (Postfix) with ESMTP id 4hk4SS0M0Vz1SWd for ; Mon, 14 Sep 2026 12:38:16 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from git (uid 1279) (envelope-from git@FreeBSD.org) id 1f48b by gitrepo.freebsd.org (DragonFly Mail Agent v0.13+ on gitrepo.freebsd.org); Mon, 14 Sep 2026 12:38:10 +0000 To: src-committers@FreeBSD.org, dev-commits-src-all@FreeBSD.org, dev-commits-src-main@FreeBSD.org From: Martin Matuska Subject: git: 2f10ffc003be - main - zfs: merge openzfs/zfs@02b5baf13 List-Id: Commit messages for all branches of the src repository List-Archive: https://lists.freebsd.org/archives/dev-commits-src-all List-Help: List-Post: List-Subscribe: List-Unsubscribe: X-BeenThere: dev-commits-src-all@freebsd.org Sender: owner-dev-commits-src-all@FreeBSD.org List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Git-Committer: mm X-Git-Repository: src X-Git-Refname: refs/heads/main X-Git-Reftype: branch X-Git-Commit: 2f10ffc003be396f3fc23cd2888023896560252b Auto-Submitted: auto-generated Date: Mon, 14 Sep 2026 12:38:10 +0000 Message-Id: <6aa7eab2.1f48b.23e90115@gitrepo.freebsd.org> 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 AuthorDate: 2026-09-14 09:54:55 +0000 Commit: Martin Matuska 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 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include + +#include + +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 ***