From 04a710dd9149a9309d8209abd6b416d3c06873eb Mon Sep 17 00:00:00 2001 From: Stoiko Ivanov Date: Wed, 14 Nov 2018 17:48:42 +0100 Subject: [PATCH] update/rebase to zfs-0.7.12 with patches from ZOL Reorder patches, so that the upstream changeset comes last Signed-off-by: Stoiko Ivanov --- ...dd-Breaks-Replaces-to-zfs-initramfs.patch} | 15 +- ...it-scripts-to-support-non-systemd-s.patch} | 21 +- ...between-zfs-umount-snapentry_expire.patch} | 0 ...-Fix-race-in-dnode_check_slots_free.patch} | 9 +- ...and-context-switch-cost-of-zio-pipe.patch} | 118 +- ...activity-test-in-more-zdb-code-paths.patch | 221 ++ ...1-Fix-statfs-2-for-32-bit-user-space.patch | 180 ++ ...-iostat-remove-latency-queue-scaling.patch | 86 + ...-rc3-compat-Remove-refcount_t-compat.patch | 878 ++++++ ...fix-all-refcount-functions-with-zfs_.patch | 2527 +++++++++++++++++ .../0015-Fix-arc_release-refcount.patch | 29 + ...-Allow-use-of-pool-GUID-as-root-pool.patch | 59 + ...7-ZTS-Update-O_TMPFILE-support-check.patch | 67 + ...e8-invalid-escape-sequence-x-warning.patch | 35 + ...uires-gcc-make-elfutils-libelf-devel.patch | 51 + zfs-patches/0020-Tag-zfs-0.7.12.patch | 55 + zfs-patches/series | 21 +- 17 files changed, 4279 insertions(+), 93 deletions(-) rename zfs-patches/{0008-Add-Breaks-Replaces-to-zfs-initramfs.patch => 0004-Add-Breaks-Replaces-to-zfs-initramfs.patch} (81%) rename zfs-patches/{0009-Revert-Install-init-scripts-to-support-non-systemd-s.patch => 0005-Revert-Install-init-scripts-to-support-non-systemd-s.patch} (83%) rename zfs-patches/{0004-Fix-deadlock-between-zfs-umount-snapentry_expire.patch => 0006-Fix-deadlock-between-zfs-umount-snapentry_expire.patch} (100%) rename zfs-patches/{0005-Fix-race-in-dnode_check_slots_free.patch => 0008-Fix-race-in-dnode_check_slots_free.patch} (97%) rename zfs-patches/{0006-Reduce-taskq-and-context-switch-cost-of-zio-pipe.patch => 0009-Reduce-taskq-and-context-switch-cost-of-zio-pipe.patch} (86%) create mode 100644 zfs-patches/0010-Skip-import-activity-test-in-more-zdb-code-paths.patch create mode 100644 zfs-patches/0011-Fix-statfs-2-for-32-bit-user-space.patch create mode 100644 zfs-patches/0012-Zpool-iostat-remove-latency-queue-scaling.patch create mode 100644 zfs-patches/0013-Linux-4.19-rc3-compat-Remove-refcount_t-compat.patch create mode 100644 zfs-patches/0014-Prefix-all-refcount-functions-with-zfs_.patch create mode 100644 zfs-patches/0015-Fix-arc_release-refcount.patch create mode 100644 zfs-patches/0016-Allow-use-of-pool-GUID-as-root-pool.patch create mode 100644 zfs-patches/0017-ZTS-Update-O_TMPFILE-support-check.patch create mode 100644 zfs-patches/0018-Fix-flake8-invalid-escape-sequence-x-warning.patch create mode 100644 zfs-patches/0019-Add-BuildRequires-gcc-make-elfutils-libelf-devel.patch create mode 100644 zfs-patches/0020-Tag-zfs-0.7.12.patch diff --git a/zfs-patches/0008-Add-Breaks-Replaces-to-zfs-initramfs.patch b/zfs-patches/0004-Add-Breaks-Replaces-to-zfs-initramfs.patch similarity index 81% rename from zfs-patches/0008-Add-Breaks-Replaces-to-zfs-initramfs.patch rename to zfs-patches/0004-Add-Breaks-Replaces-to-zfs-initramfs.patch index e1e95ef..b6180b4 100644 --- a/zfs-patches/0008-Add-Breaks-Replaces-to-zfs-initramfs.patch +++ b/zfs-patches/0004-Add-Breaks-Replaces-to-zfs-initramfs.patch @@ -1,4 +1,4 @@ -From 5ac80068e911d3b0935903f713c5f492d518da91 Mon Sep 17 00:00:00 2001 +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: Stoiko Ivanov Date: Mon, 29 Oct 2018 15:49:20 +0100 Subject: [PATCH] Add Breaks/Replaces to zfs-initramfs @@ -13,10 +13,10 @@ Signed-off-by: Stoiko Ivanov 2 files changed, 4 insertions(+) diff --git a/debian/control b/debian/control -index 4d22ff50..a414e449 100644 +index f33008df..d3d1034e 100644 --- a/debian/control +++ b/debian/control -@@ -117,6 +117,8 @@ Depends: busybox-initramfs | busybox-static | busybox, +@@ -116,6 +116,8 @@ Depends: busybox-initramfs | busybox-static | busybox, zfs-modules | zfs-dkms, zfsutils-linux (>= ${binary:Version}), ${misc:Depends} @@ -26,11 +26,11 @@ index 4d22ff50..a414e449 100644 The Z file system is a pooled filesystem designed for maximum data integrity, supporting data snapshots, multiple copies, and data diff --git a/debian/control.in b/debian/control.in -index 96154c5c..b9c34331 100644 +index 0a9ceef6..09ef18cc 100644 --- a/debian/control.in +++ b/debian/control.in -@@ -117,6 +117,8 @@ Depends: busybox-initramfs | busybox-static | busybox, - zfs-modules | zfs-dkms, +@@ -100,6 +100,8 @@ Depends: busybox-initramfs | busybox-static | busybox, + initramfs-tools, zfsutils-linux (>= ${binary:Version}), ${misc:Depends} +Breaks: zfsutils-linux (<= 0.7.11-pve1~bpo1) @@ -38,6 +38,3 @@ index 96154c5c..b9c34331 100644 Description: OpenZFS root filesystem capabilities for Linux - initramfs The Z file system is a pooled filesystem designed for maximum data integrity, supporting data snapshots, multiple copies, and data --- -2.11.0 - diff --git a/zfs-patches/0009-Revert-Install-init-scripts-to-support-non-systemd-s.patch b/zfs-patches/0005-Revert-Install-init-scripts-to-support-non-systemd-s.patch similarity index 83% rename from zfs-patches/0009-Revert-Install-init-scripts-to-support-non-systemd-s.patch rename to zfs-patches/0005-Revert-Install-init-scripts-to-support-non-systemd-s.patch index e305b7d..1a8561a 100644 --- a/zfs-patches/0009-Revert-Install-init-scripts-to-support-non-systemd-s.patch +++ b/zfs-patches/0005-Revert-Install-init-scripts-to-support-non-systemd-s.patch @@ -1,4 +1,4 @@ -From c37a6401469cae16519db06d623d49c6f606f312 Mon Sep 17 00:00:00 2001 +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: Thomas Lamprecht Date: Wed, 31 Oct 2018 15:37:39 +0100 Subject: [PATCH] Revert "Install init scripts to support non-systemd setups. @@ -11,11 +11,11 @@ systems) Signed-off-by: Thomas Lamprecht --- - debian/rules | 8 -------- - debian/zfs-zed.zfs-zed.init | 1 - - debian/zfsutils-linux.zfs-import.init | 1 - - debian/zfsutils-linux.zfs-mount.init | 1 - - debian/zfsutils-linux.zfs-share.init | 1 - + debian/rules | 8 -------- + debian/zfs-zed.zfs-zed.init | 1 - + debian/zfsutils-linux.zfs-import.init | 1 - + debian/zfsutils-linux.zfs-mount.init | 1 - + debian/zfsutils-linux.zfs-share.init | 1 - 5 files changed, 12 deletions(-) delete mode 120000 debian/zfs-zed.zfs-zed.init delete mode 120000 debian/zfsutils-linux.zfs-import.init @@ -23,10 +23,10 @@ Signed-off-by: Thomas Lamprecht delete mode 120000 debian/zfsutils-linux.zfs-share.init diff --git a/debian/rules b/debian/rules -index 5fba58ff..81c301e4 100644 +index 3ba4b99a..d6cf5a56 100755 --- a/debian/rules +++ b/debian/rules -@@ -161,14 +153,6 @@ override_dh_install: +@@ -117,14 +117,6 @@ override_dh_install: find . -name lib*.la -delete dh_install --fail-missing @@ -40,7 +40,7 @@ index 5fba58ff..81c301e4 100644 - # ------------ - override_dh_prep-deb-files: + debian-copyright: diff --git a/debian/zfs-zed.zfs-zed.init b/debian/zfs-zed.zfs-zed.init deleted file mode 120000 index 3f41f681..00000000 @@ -73,6 +73,3 @@ index 3f069f9b..00000000 @@ -1 +0,0 @@ -../etc/init.d/zfs-share \ No newline at end of file --- -2.19.1 - diff --git a/zfs-patches/0004-Fix-deadlock-between-zfs-umount-snapentry_expire.patch b/zfs-patches/0006-Fix-deadlock-between-zfs-umount-snapentry_expire.patch similarity index 100% rename from zfs-patches/0004-Fix-deadlock-between-zfs-umount-snapentry_expire.patch rename to zfs-patches/0006-Fix-deadlock-between-zfs-umount-snapentry_expire.patch diff --git a/zfs-patches/0005-Fix-race-in-dnode_check_slots_free.patch b/zfs-patches/0008-Fix-race-in-dnode_check_slots_free.patch similarity index 97% rename from zfs-patches/0005-Fix-race-in-dnode_check_slots_free.patch rename to zfs-patches/0008-Fix-race-in-dnode_check_slots_free.patch index 9cebd00..1cbabe6 100644 --- a/zfs-patches/0005-Fix-race-in-dnode_check_slots_free.patch +++ b/zfs-patches/0008-Fix-race-in-dnode_check_slots_free.patch @@ -17,13 +17,8 @@ treated as a list_node_t when it is technically a multilist_node_t. Reviewed-by: Brian Behlendorf Signed-off-by: Tom Caputi -Requires-spl: spl-0.7-release -Issue #7147 -Issue #7388 -Issue #7997 - -(cherry-picked from behlendorf/issue-7997 4764f6f3be90be073d2700653dff286371e52583) -Signed-off-by: Stoiko Ivanov +Closes #7147 +Closes #7388 --- include/sys/dmu_impl.h | 1 + include/sys/dnode.h | 4 ++++ diff --git a/zfs-patches/0006-Reduce-taskq-and-context-switch-cost-of-zio-pipe.patch b/zfs-patches/0009-Reduce-taskq-and-context-switch-cost-of-zio-pipe.patch similarity index 86% rename from zfs-patches/0006-Reduce-taskq-and-context-switch-cost-of-zio-pipe.patch rename to zfs-patches/0009-Reduce-taskq-and-context-switch-cost-of-zio-pipe.patch index 92dda45..b17b062 100644 --- a/zfs-patches/0006-Reduce-taskq-and-context-switch-cost-of-zio-pipe.patch +++ b/zfs-patches/0009-Reduce-taskq-and-context-switch-cost-of-zio-pipe.patch @@ -20,15 +20,11 @@ Reviewed-by: Brian Behlendorf Reviewed by: George Wilson Signed-off-by: Matthew Ahrens External-issue: DLPX-59292 -Requires-spl: spl-0.7-release Closes #7736 - -(cherry-picked from behlendorf/issue-7736 496657ab3bcfeb638b1786e1759980ccfcacb08e) -Signed-off-by: Stoiko Ivanov --- include/sys/zio.h | 4 +- - module/zfs/zio.c | 250 +++++++++++++++++++++++++++++------------------------- - 2 files changed, 137 insertions(+), 117 deletions(-) + module/zfs/zio.c | 252 +++++++++++++++++++++++++++++------------------------- + 2 files changed, 139 insertions(+), 117 deletions(-) diff --git a/include/sys/zio.h b/include/sys/zio.h index 4b0eecc2..3618912c 100644 @@ -53,7 +49,7 @@ index 4b0eecc2..3618912c 100644 /* * The io_reexecute flags are distinct from io_flags because the child must diff --git a/module/zfs/zio.c b/module/zfs/zio.c -index 9a465e1b..b08b4747 100644 +index 9a465e1b..dd0dfcdb 100644 --- a/module/zfs/zio.c +++ b/module/zfs/zio.c @@ -75,9 +75,6 @@ uint64_t zio_buf_cache_frees[SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT]; @@ -226,16 +222,18 @@ index 9a465e1b..b08b4747 100644 zio_free_bp_init(zio_t *zio) { blkptr_t *bp = zio->io_bp; -@@ -1472,7 +1490,7 @@ zio_free_bp_init(zio_t *zio) +@@ -1472,7 +1490,9 @@ zio_free_bp_init(zio_t *zio) zio->io_pipeline = ZIO_DDT_FREE_PIPELINE; } - return (ZIO_PIPELINE_CONTINUE); ++ ASSERT3P(zio->io_bp, ==, &zio->io_bp_copy); ++ + return (zio); } /* -@@ -1541,12 +1559,12 @@ zio_taskq_member(zio_t *zio, zio_taskq_type_t q) +@@ -1541,12 +1561,12 @@ zio_taskq_member(zio_t *zio, zio_taskq_type_t q) return (B_FALSE); } @@ -250,7 +248,7 @@ index 9a465e1b..b08b4747 100644 } void -@@ -1687,14 +1705,13 @@ __attribute__((always_inline)) +@@ -1687,14 +1707,13 @@ __attribute__((always_inline)) static inline void __zio_execute(zio_t *zio) { @@ -267,7 +265,7 @@ index 9a465e1b..b08b4747 100644 ASSERT(!MUTEX_HELD(&zio->io_lock)); ASSERT(ISP2(stage)); -@@ -1736,12 +1753,16 @@ __zio_execute(zio_t *zio) +@@ -1736,12 +1755,16 @@ __zio_execute(zio_t *zio) zio->io_stage = stage; zio->io_pipeline_trace |= zio->io_stage; @@ -288,7 +286,7 @@ index 9a465e1b..b08b4747 100644 } } -@@ -2215,7 +2236,7 @@ zio_gang_tree_issue(zio_t *pio, zio_gang_node_t *gn, blkptr_t *bp, abd_t *data, +@@ -2215,7 +2238,7 @@ zio_gang_tree_issue(zio_t *pio, zio_gang_node_t *gn, blkptr_t *bp, abd_t *data, zio_nowait(zio); } @@ -297,7 +295,7 @@ index 9a465e1b..b08b4747 100644 zio_gang_assemble(zio_t *zio) { blkptr_t *bp = zio->io_bp; -@@ -2227,16 +2248,16 @@ zio_gang_assemble(zio_t *zio) +@@ -2227,16 +2250,16 @@ zio_gang_assemble(zio_t *zio) zio_gang_tree_assemble(zio, bp, &zio->io_gang_tree); @@ -317,7 +315,7 @@ index 9a465e1b..b08b4747 100644 } ASSERT(BP_IS_GANG(bp) && zio->io_gang_leader == zio); -@@ -2250,7 +2271,7 @@ zio_gang_issue(zio_t *zio) +@@ -2250,7 +2273,7 @@ zio_gang_issue(zio_t *zio) zio->io_pipeline = ZIO_INTERLOCK_PIPELINE; @@ -326,7 +324,7 @@ index 9a465e1b..b08b4747 100644 } static void -@@ -2290,7 +2311,7 @@ zio_write_gang_done(zio_t *zio) +@@ -2290,7 +2313,7 @@ zio_write_gang_done(zio_t *zio) abd_put(zio->io_abd); } @@ -335,7 +333,7 @@ index 9a465e1b..b08b4747 100644 zio_write_gang_block(zio_t *pio) { spa_t *spa = pio->io_spa; -@@ -2349,7 +2370,7 @@ zio_write_gang_block(zio_t *pio) +@@ -2349,7 +2372,7 @@ zio_write_gang_block(zio_t *pio) } pio->io_error = error; @@ -344,7 +342,7 @@ index 9a465e1b..b08b4747 100644 } if (pio == gio) { -@@ -2423,7 +2444,7 @@ zio_write_gang_block(zio_t *pio) +@@ -2423,7 +2446,7 @@ zio_write_gang_block(zio_t *pio) zio_nowait(zio); @@ -353,7 +351,7 @@ index 9a465e1b..b08b4747 100644 } /* -@@ -2444,7 +2465,7 @@ zio_write_gang_block(zio_t *pio) +@@ -2444,7 +2467,7 @@ zio_write_gang_block(zio_t *pio) * used for nopwrite, assuming that the salt and the checksums * themselves remain secret. */ @@ -362,7 +360,7 @@ index 9a465e1b..b08b4747 100644 zio_nop_write(zio_t *zio) { blkptr_t *bp = zio->io_bp; -@@ -2471,7 +2492,7 @@ zio_nop_write(zio_t *zio) +@@ -2471,7 +2494,7 @@ zio_nop_write(zio_t *zio) BP_GET_COMPRESS(bp) != BP_GET_COMPRESS(bp_orig) || BP_GET_DEDUP(bp) != BP_GET_DEDUP(bp_orig) || zp->zp_copies != BP_GET_NDVAS(bp_orig)) @@ -371,7 +369,7 @@ index 9a465e1b..b08b4747 100644 /* * If the checksums match then reset the pipeline so that we -@@ -2491,7 +2512,7 @@ zio_nop_write(zio_t *zio) +@@ -2491,7 +2514,7 @@ zio_nop_write(zio_t *zio) zio->io_flags |= ZIO_FLAG_NOPWRITE; } @@ -380,7 +378,7 @@ index 9a465e1b..b08b4747 100644 } /* -@@ -2519,7 +2540,7 @@ zio_ddt_child_read_done(zio_t *zio) +@@ -2519,7 +2542,7 @@ zio_ddt_child_read_done(zio_t *zio) mutex_exit(&pio->io_lock); } @@ -389,7 +387,7 @@ index 9a465e1b..b08b4747 100644 zio_ddt_read_start(zio_t *zio) { blkptr_t *bp = zio->io_bp; -@@ -2540,7 +2561,7 @@ zio_ddt_read_start(zio_t *zio) +@@ -2540,7 +2563,7 @@ zio_ddt_read_start(zio_t *zio) zio->io_vsd = dde; if (ddp_self == NULL) @@ -398,7 +396,7 @@ index 9a465e1b..b08b4747 100644 for (p = 0; p < DDT_PHYS_TYPES; p++, ddp++) { if (ddp->ddp_phys_birth == 0 || ddp == ddp_self) -@@ -2553,23 +2574,23 @@ zio_ddt_read_start(zio_t *zio) +@@ -2553,23 +2576,23 @@ zio_ddt_read_start(zio_t *zio) zio->io_priority, ZIO_DDT_CHILD_FLAGS(zio) | ZIO_FLAG_DONT_PROPAGATE, &zio->io_bookmark)); } @@ -426,7 +424,7 @@ index 9a465e1b..b08b4747 100644 } ASSERT(BP_GET_DEDUP(bp)); -@@ -2581,12 +2602,12 @@ zio_ddt_read_done(zio_t *zio) +@@ -2581,12 +2604,12 @@ zio_ddt_read_done(zio_t *zio) ddt_entry_t *dde = zio->io_vsd; if (ddt == NULL) { ASSERT(spa_load_state(zio->io_spa) != SPA_LOAD_NONE); @@ -441,7 +439,7 @@ index 9a465e1b..b08b4747 100644 } if (dde->dde_repair_abd != NULL) { abd_copy(zio->io_abd, dde->dde_repair_abd, -@@ -2599,7 +2620,7 @@ zio_ddt_read_done(zio_t *zio) +@@ -2599,7 +2622,7 @@ zio_ddt_read_done(zio_t *zio) ASSERT(zio->io_vsd == NULL); @@ -450,7 +448,7 @@ index 9a465e1b..b08b4747 100644 } static boolean_t -@@ -2780,7 +2801,7 @@ zio_ddt_ditto_write_done(zio_t *zio) +@@ -2780,7 +2803,7 @@ zio_ddt_ditto_write_done(zio_t *zio) ddt_exit(ddt); } @@ -459,7 +457,7 @@ index 9a465e1b..b08b4747 100644 zio_ddt_write(zio_t *zio) { spa_t *spa = zio->io_spa; -@@ -2822,7 +2843,7 @@ zio_ddt_write(zio_t *zio) +@@ -2822,7 +2845,7 @@ zio_ddt_write(zio_t *zio) } zio->io_pipeline = ZIO_WRITE_PIPELINE; ddt_exit(ddt); @@ -468,7 +466,7 @@ index 9a465e1b..b08b4747 100644 } ditto_copies = ddt_ditto_copies_needed(ddt, dde, ddp); -@@ -2848,7 +2869,7 @@ zio_ddt_write(zio_t *zio) +@@ -2848,7 +2871,7 @@ zio_ddt_write(zio_t *zio) zio->io_bp_override = NULL; BP_ZERO(bp); ddt_exit(ddt); @@ -477,7 +475,7 @@ index 9a465e1b..b08b4747 100644 } dio = zio_write(zio, spa, txg, bp, zio->io_orig_abd, -@@ -2890,12 +2911,12 @@ zio_ddt_write(zio_t *zio) +@@ -2890,12 +2913,12 @@ zio_ddt_write(zio_t *zio) if (dio) zio_nowait(dio); @@ -492,7 +490,7 @@ index 9a465e1b..b08b4747 100644 zio_ddt_free(zio_t *zio) { spa_t *spa = zio->io_spa; -@@ -2916,7 +2937,7 @@ zio_ddt_free(zio_t *zio) +@@ -2916,7 +2939,7 @@ zio_ddt_free(zio_t *zio) } ddt_exit(ddt); @@ -501,7 +499,7 @@ index 9a465e1b..b08b4747 100644 } /* -@@ -2953,7 +2974,7 @@ zio_io_to_allocate(spa_t *spa) +@@ -2953,7 +2976,7 @@ zio_io_to_allocate(spa_t *spa) return (zio); } @@ -510,7 +508,7 @@ index 9a465e1b..b08b4747 100644 zio_dva_throttle(zio_t *zio) { spa_t *spa = zio->io_spa; -@@ -2963,7 +2984,7 @@ zio_dva_throttle(zio_t *zio) +@@ -2963,7 +2986,7 @@ zio_dva_throttle(zio_t *zio) !spa_normal_class(zio->io_spa)->mc_alloc_throttle_enabled || zio->io_child_type == ZIO_CHILD_GANG || zio->io_flags & ZIO_FLAG_NODATA) { @@ -519,7 +517,7 @@ index 9a465e1b..b08b4747 100644 } ASSERT(zio->io_child_type > ZIO_CHILD_GANG); -@@ -2979,22 +3000,7 @@ zio_dva_throttle(zio_t *zio) +@@ -2979,22 +3002,7 @@ zio_dva_throttle(zio_t *zio) nio = zio_io_to_allocate(zio->io_spa); mutex_exit(&spa->spa_alloc_lock); @@ -543,7 +541,7 @@ index 9a465e1b..b08b4747 100644 } void -@@ -3013,7 +3019,7 @@ zio_allocate_dispatch(spa_t *spa) +@@ -3013,7 +3021,7 @@ zio_allocate_dispatch(spa_t *spa) zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_TRUE); } @@ -552,7 +550,7 @@ index 9a465e1b..b08b4747 100644 zio_dva_allocate(zio_t *zio) { spa_t *spa = zio->io_spa; -@@ -3054,18 +3060,18 @@ zio_dva_allocate(zio_t *zio) +@@ -3054,18 +3062,18 @@ zio_dva_allocate(zio_t *zio) zio->io_error = error; } @@ -575,7 +573,7 @@ index 9a465e1b..b08b4747 100644 zio_dva_claim(zio_t *zio) { int error; -@@ -3074,7 +3080,7 @@ zio_dva_claim(zio_t *zio) +@@ -3074,7 +3082,7 @@ zio_dva_claim(zio_t *zio) if (error) zio->io_error = error; @@ -584,7 +582,7 @@ index 9a465e1b..b08b4747 100644 } /* -@@ -3172,7 +3178,7 @@ zio_free_zil(spa_t *spa, uint64_t txg, blkptr_t *bp) +@@ -3172,7 +3180,7 @@ zio_free_zil(spa_t *spa, uint64_t txg, blkptr_t *bp) * force the underlying vdev layers to call either zio_execute() or * zio_interrupt() to ensure that the pipeline continues with the correct I/O. */ @@ -593,7 +591,7 @@ index 9a465e1b..b08b4747 100644 zio_vdev_io_start(zio_t *zio) { vdev_t *vd = zio->io_vd; -@@ -3192,7 +3198,7 @@ zio_vdev_io_start(zio_t *zio) +@@ -3192,7 +3200,7 @@ zio_vdev_io_start(zio_t *zio) * The mirror_ops handle multiple DVAs in a single BP. */ vdev_mirror_ops.vdev_op_io_start(zio); @@ -602,7 +600,7 @@ index 9a465e1b..b08b4747 100644 } ASSERT3P(zio->io_logical, !=, zio); -@@ -3269,31 +3275,31 @@ zio_vdev_io_start(zio_t *zio) +@@ -3269,31 +3277,31 @@ zio_vdev_io_start(zio_t *zio) !vdev_dtl_contains(vd, DTL_PARTIAL, zio->io_txg, 1)) { ASSERT(zio->io_type == ZIO_TYPE_WRITE); zio_vdev_io_bypass(zio); @@ -640,7 +638,7 @@ index 9a465e1b..b08b4747 100644 zio_vdev_io_done(zio_t *zio) { vdev_t *vd = zio->io_vd; -@@ -3301,7 +3307,7 @@ zio_vdev_io_done(zio_t *zio) +@@ -3301,7 +3309,7 @@ zio_vdev_io_done(zio_t *zio) boolean_t unexpected_error = B_FALSE; if (zio_wait_for_children(zio, ZIO_CHILD_VDEV_BIT, ZIO_WAIT_DONE)) { @@ -649,7 +647,7 @@ index 9a465e1b..b08b4747 100644 } ASSERT(zio->io_type == ZIO_TYPE_READ || zio->io_type == ZIO_TYPE_WRITE); -@@ -3337,7 +3343,7 @@ zio_vdev_io_done(zio_t *zio) +@@ -3337,7 +3345,7 @@ zio_vdev_io_done(zio_t *zio) if (unexpected_error) VERIFY(vdev_probe(vd, zio) == NULL); @@ -658,7 +656,7 @@ index 9a465e1b..b08b4747 100644 } /* -@@ -3366,13 +3372,13 @@ zio_vsd_default_cksum_report(zio_t *zio, zio_cksum_report_t *zcr, void *ignored) +@@ -3366,13 +3374,13 @@ zio_vsd_default_cksum_report(zio_t *zio, zio_cksum_report_t *zcr, void *ignored) zcr->zcr_free = zio_abd_free; } @@ -674,7 +672,7 @@ index 9a465e1b..b08b4747 100644 } if (vd == NULL && !(zio->io_flags & ZIO_FLAG_CONFIG_WRITER)) -@@ -3402,7 +3408,7 @@ zio_vdev_io_assess(zio_t *zio) +@@ -3402,7 +3410,7 @@ zio_vdev_io_assess(zio_t *zio) zio->io_stage = ZIO_STAGE_VDEV_IO_START >> 1; zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, zio_requeue_io_start_cut_in_line); @@ -683,7 +681,7 @@ index 9a465e1b..b08b4747 100644 } /* -@@ -3442,7 +3448,7 @@ zio_vdev_io_assess(zio_t *zio) +@@ -3442,7 +3450,7 @@ zio_vdev_io_assess(zio_t *zio) zio->io_physdone(zio->io_logical); } @@ -692,7 +690,7 @@ index 9a465e1b..b08b4747 100644 } void -@@ -3477,7 +3483,7 @@ zio_vdev_io_bypass(zio_t *zio) +@@ -3477,7 +3485,7 @@ zio_vdev_io_bypass(zio_t *zio) * Generate and verify checksums * ========================================================================== */ @@ -701,7 +699,7 @@ index 9a465e1b..b08b4747 100644 zio_checksum_generate(zio_t *zio) { blkptr_t *bp = zio->io_bp; -@@ -3491,7 +3497,7 @@ zio_checksum_generate(zio_t *zio) +@@ -3491,7 +3499,7 @@ zio_checksum_generate(zio_t *zio) checksum = zio->io_prop.zp_checksum; if (checksum == ZIO_CHECKSUM_OFF) @@ -710,7 +708,7 @@ index 9a465e1b..b08b4747 100644 ASSERT(checksum == ZIO_CHECKSUM_LABEL); } else { -@@ -3505,10 +3511,10 @@ zio_checksum_generate(zio_t *zio) +@@ -3505,10 +3513,10 @@ zio_checksum_generate(zio_t *zio) zio_checksum_compute(zio, checksum, zio->io_abd, zio->io_size); @@ -723,7 +721,7 @@ index 9a465e1b..b08b4747 100644 zio_checksum_verify(zio_t *zio) { zio_bad_cksum_t info; -@@ -3523,7 +3529,7 @@ zio_checksum_verify(zio_t *zio) +@@ -3523,7 +3531,7 @@ zio_checksum_verify(zio_t *zio) * We're either verifying a label checksum, or nothing at all. */ if (zio->io_prop.zp_checksum == ZIO_CHECKSUM_OFF) @@ -732,7 +730,7 @@ index 9a465e1b..b08b4747 100644 ASSERT(zio->io_prop.zp_checksum == ZIO_CHECKSUM_LABEL); } -@@ -3538,7 +3544,7 @@ zio_checksum_verify(zio_t *zio) +@@ -3538,7 +3546,7 @@ zio_checksum_verify(zio_t *zio) } } @@ -741,7 +739,7 @@ index 9a465e1b..b08b4747 100644 } /* -@@ -3581,7 +3587,7 @@ zio_worst_error(int e1, int e2) +@@ -3581,7 +3589,7 @@ zio_worst_error(int e1, int e2) * I/O completion * ========================================================================== */ @@ -750,7 +748,7 @@ index 9a465e1b..b08b4747 100644 zio_ready(zio_t *zio) { blkptr_t *bp = zio->io_bp; -@@ -3590,7 +3596,7 @@ zio_ready(zio_t *zio) +@@ -3590,7 +3598,7 @@ zio_ready(zio_t *zio) if (zio_wait_for_children(zio, ZIO_CHILD_GANG_BIT | ZIO_CHILD_DDT_BIT, ZIO_WAIT_READY)) { @@ -759,7 +757,7 @@ index 9a465e1b..b08b4747 100644 } if (zio->io_ready) { -@@ -3636,7 +3642,7 @@ zio_ready(zio_t *zio) +@@ -3636,7 +3644,7 @@ zio_ready(zio_t *zio) */ for (; pio != NULL; pio = pio_next) { pio_next = zio_walk_parents(zio, &zl); @@ -768,7 +766,7 @@ index 9a465e1b..b08b4747 100644 } if (zio->io_flags & ZIO_FLAG_NODATA) { -@@ -3652,7 +3658,7 @@ zio_ready(zio_t *zio) +@@ -3652,7 +3660,7 @@ zio_ready(zio_t *zio) zio->io_spa->spa_syncing_txg == zio->io_txg) zio_handle_ignored_writes(zio); @@ -777,7 +775,7 @@ index 9a465e1b..b08b4747 100644 } /* -@@ -3716,7 +3722,7 @@ zio_dva_throttle_done(zio_t *zio) +@@ -3716,7 +3724,7 @@ zio_dva_throttle_done(zio_t *zio) zio_allocate_dispatch(zio->io_spa); } @@ -786,7 +784,7 @@ index 9a465e1b..b08b4747 100644 zio_done(zio_t *zio) { /* -@@ -3733,7 +3739,7 @@ zio_done(zio_t *zio) +@@ -3733,7 +3741,7 @@ zio_done(zio_t *zio) * wait for them and then repeat this pipeline stage. */ if (zio_wait_for_children(zio, ZIO_CHILD_ALL_BITS, ZIO_WAIT_DONE)) { @@ -795,7 +793,7 @@ index 9a465e1b..b08b4747 100644 } /* -@@ -3957,7 +3963,12 @@ zio_done(zio_t *zio) +@@ -3957,7 +3965,12 @@ zio_done(zio_t *zio) if ((pio->io_flags & ZIO_FLAG_GODFATHER) && (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND)) { zio_remove_child(pio, zio, remove_zl); @@ -809,7 +807,7 @@ index 9a465e1b..b08b4747 100644 } } -@@ -3969,7 +3980,11 @@ zio_done(zio_t *zio) +@@ -3969,7 +3982,11 @@ zio_done(zio_t *zio) */ ASSERT(!(zio->io_flags & ZIO_FLAG_GODFATHER)); zio->io_flags |= ZIO_FLAG_DONT_PROPAGATE; @@ -822,7 +820,7 @@ index 9a465e1b..b08b4747 100644 } else if (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND) { /* * We'd fail again if we reexecuted now, so suspend -@@ -3987,7 +4002,7 @@ zio_done(zio_t *zio) +@@ -3987,7 +4004,7 @@ zio_done(zio_t *zio) (task_func_t *)zio_reexecute, zio, 0, &zio->io_tqent); } @@ -831,7 +829,7 @@ index 9a465e1b..b08b4747 100644 } ASSERT(zio->io_child_count == 0); -@@ -4023,12 +4038,17 @@ zio_done(zio_t *zio) +@@ -4023,12 +4040,17 @@ zio_done(zio_t *zio) zio->io_state[ZIO_WAIT_DONE] = 1; mutex_exit(&zio->io_lock); @@ -850,7 +848,7 @@ index 9a465e1b..b08b4747 100644 } if (zio->io_waiter != NULL) { -@@ -4040,7 +4060,7 @@ zio_done(zio_t *zio) +@@ -4040,7 +4062,7 @@ zio_done(zio_t *zio) zio_destroy(zio); } diff --git a/zfs-patches/0010-Skip-import-activity-test-in-more-zdb-code-paths.patch b/zfs-patches/0010-Skip-import-activity-test-in-more-zdb-code-paths.patch new file mode 100644 index 0000000..b23f828 --- /dev/null +++ b/zfs-patches/0010-Skip-import-activity-test-in-more-zdb-code-paths.patch @@ -0,0 +1,221 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Olaf Faaland +Date: Mon, 20 Aug 2018 10:05:23 -0700 +Subject: [PATCH] Skip import activity test in more zdb code paths + +Since zdb opens the pools read-only, it cannot damage the pool in the +event the pool is already imported either on the same host or on +another one. + +If the pool vdev structure is changing while zdb is importing the +pool, it may cause zdb to crash. However this is unlikely, and in any +case it's a user space process and can simply be run again. + +For this reason, zdb should disable the multihost activity test on +import that is normally run. + +This commit fixes a few zdb code paths where that had been overlooked. +It also adds tests to ensure that several common use cases handle this +properly in the future. + +Reviewed-by: Brian Behlendorf +Reviewed-by: Gu Zheng +Signed-off-by: Olaf Faaland +Closes #7797 +Closes #7801 +--- + cmd/zdb/zdb.c | 39 +++++++----- + tests/runfiles/linux.run | 3 +- + tests/zfs-tests/tests/functional/mmp/Makefile.am | 1 + + .../zfs-tests/tests/functional/mmp/mmp_on_zdb.ksh | 74 ++++++++++++++++++++++ + 4 files changed, 101 insertions(+), 16 deletions(-) + create mode 100755 tests/zfs-tests/tests/functional/mmp/mmp_on_zdb.ksh + +diff --git a/cmd/zdb/zdb.c b/cmd/zdb/zdb.c +index 17a0ae25..bb9fd3f1 100644 +--- a/cmd/zdb/zdb.c ++++ b/cmd/zdb/zdb.c +@@ -24,7 +24,7 @@ + * Copyright (c) 2011, 2016 by Delphix. All rights reserved. + * Copyright (c) 2014 Integros [integros.com] + * Copyright 2016 Nexenta Systems, Inc. +- * Copyright (c) 2017 Lawrence Livermore National Security, LLC. ++ * Copyright (c) 2017, 2018 Lawrence Livermore National Security, LLC. + * Copyright (c) 2015, 2017, Intel Corporation. + */ + +@@ -3660,6 +3660,22 @@ dump_simulated_ddt(spa_t *spa) + } + + static void ++zdb_set_skip_mmp(char *target) ++{ ++ spa_t *spa; ++ ++ /* ++ * Disable the activity check to allow examination of ++ * active pools. ++ */ ++ mutex_enter(&spa_namespace_lock); ++ if ((spa = spa_lookup(target)) != NULL) { ++ spa->spa_import_flags |= ZFS_IMPORT_SKIP_MMP; ++ } ++ mutex_exit(&spa_namespace_lock); ++} ++ ++static void + dump_zpool(spa_t *spa) + { + dsl_pool_t *dp = spa_get_dsl(spa); +@@ -4412,14 +4428,15 @@ main(int argc, char **argv) + target, strerror(ENOMEM)); + } + +- /* +- * Disable the activity check to allow examination of +- * active pools. +- */ + if (dump_opt['C'] > 1) { + (void) printf("\nConfiguration for import:\n"); + dump_nvlist(cfg, 8); + } ++ ++ /* ++ * Disable the activity check to allow examination of ++ * active pools. ++ */ + error = spa_import(target_pool, cfg, NULL, + flags | ZFS_IMPORT_SKIP_MMP); + } +@@ -4430,16 +4447,7 @@ main(int argc, char **argv) + + if (error == 0) { + if (target_is_spa || dump_opt['R']) { +- /* +- * Disable the activity check to allow examination of +- * active pools. +- */ +- mutex_enter(&spa_namespace_lock); +- if ((spa = spa_lookup(target)) != NULL) { +- spa->spa_import_flags |= ZFS_IMPORT_SKIP_MMP; +- } +- mutex_exit(&spa_namespace_lock); +- ++ zdb_set_skip_mmp(target); + error = spa_open_rewind(target, &spa, FTAG, policy, + NULL); + if (error) { +@@ -4462,6 +4470,7 @@ main(int argc, char **argv) + } + } + } else { ++ zdb_set_skip_mmp(target); + error = open_objset(target, DMU_OST_ANY, FTAG, &os); + } + } +diff --git a/tests/runfiles/linux.run b/tests/runfiles/linux.run +index d8fe6f3a..ddf01aaf 100644 +--- a/tests/runfiles/linux.run ++++ b/tests/runfiles/linux.run +@@ -499,7 +499,8 @@ tags = ['functional', 'mmap'] + [tests/functional/mmp] + tests = ['mmp_on_thread', 'mmp_on_uberblocks', 'mmp_on_off', 'mmp_interval', + 'mmp_active_import', 'mmp_inactive_import', 'mmp_exported_import', +- 'mmp_write_uberblocks', 'mmp_reset_interval', 'multihost_history'] ++ 'mmp_write_uberblocks', 'mmp_reset_interval', 'multihost_history', ++ 'mmp_on_zdb'] + tags = ['functional', 'mmp'] + + [tests/functional/mount] +diff --git a/tests/zfs-tests/tests/functional/mmp/Makefile.am b/tests/zfs-tests/tests/functional/mmp/Makefile.am +index ecf16f80..f2d0ad0e 100644 +--- a/tests/zfs-tests/tests/functional/mmp/Makefile.am ++++ b/tests/zfs-tests/tests/functional/mmp/Makefile.am +@@ -10,6 +10,7 @@ dist_pkgdata_SCRIPTS = \ + mmp_exported_import.ksh \ + mmp_write_uberblocks.ksh \ + mmp_reset_interval.ksh \ ++ mmp_on_zdb.ksh \ + setup.ksh \ + cleanup.ksh + +diff --git a/tests/zfs-tests/tests/functional/mmp/mmp_on_zdb.ksh b/tests/zfs-tests/tests/functional/mmp/mmp_on_zdb.ksh +new file mode 100755 +index 00000000..b646475a +--- /dev/null ++++ b/tests/zfs-tests/tests/functional/mmp/mmp_on_zdb.ksh +@@ -0,0 +1,74 @@ ++#!/bin/ksh ++ ++# ++# This file and its contents are supplied under the terms of the ++# Common Development and Distribution License ("CDDL"), version 1.0. ++# You may only use this file in accordance with the terms of version ++# 1.0 of the CDDL. ++# ++# A full copy of the text of the CDDL should have accompanied this ++# source. A copy of the CDDL is also available via the Internet at ++# http://www.illumos.org/license/CDDL. ++# ++ ++# ++# Copyright (c) 2018 Lawrence Livermore National Security, LLC. ++# Copyright (c) 2018 by Nutanix. All rights reserved. ++# ++ ++. $STF_SUITE/include/libtest.shlib ++. $STF_SUITE/tests/functional/mmp/mmp.cfg ++. $STF_SUITE/tests/functional/mmp/mmp.kshlib ++ ++# ++# Description: ++# zdb will work while multihost is enabled. ++# ++# Strategy: ++# 1. Create a pool ++# 2. Enable multihost ++# 3. Run zdb -d with pool and dataset arguments. ++# 4. Create a checkpoint ++# 5. Run zdb -kd with pool and dataset arguments. ++# 6. Discard the checkpoint ++# 7. Export the pool ++# 8. Run zdb -ed with pool and dataset arguments. ++# ++ ++function cleanup ++{ ++ datasetexists $TESTPOOL && destroy_pool $TESTPOOL ++ for DISK in $DISKS; do ++ zpool labelclear -f $DEV_RDSKDIR/$DISK ++ done ++ log_must mmp_clear_hostid ++} ++ ++log_assert "Verify zdb -d works while multihost is enabled" ++log_onexit cleanup ++ ++verify_runnable "global" ++verify_disk_count "$DISKS" 2 ++ ++default_mirror_setup_noexit $DISKS ++log_must mmp_set_hostid $HOSTID1 ++log_must zpool set multihost=on $TESTPOOL ++log_must zfs snap $TESTPOOL/$TESTFS@snap ++ ++log_must zdb -d $TESTPOOL ++log_must zdb -d $TESTPOOL/ ++log_must zdb -d $TESTPOOL/$TESTFS ++log_must zdb -d $TESTPOOL/$TESTFS@snap ++ ++log_must zpool export $TESTPOOL ++ ++log_must zdb -ed $TESTPOOL ++log_must zdb -ed $TESTPOOL/ ++log_must zdb -ed $TESTPOOL/$TESTFS ++log_must zdb -ed $TESTPOOL/$TESTFS@snap ++ ++log_must zpool import $TESTPOOL ++ ++cleanup ++ ++log_pass "zdb -d works while multihost is enabled" diff --git a/zfs-patches/0011-Fix-statfs-2-for-32-bit-user-space.patch b/zfs-patches/0011-Fix-statfs-2-for-32-bit-user-space.patch new file mode 100644 index 0000000..eac6f59 --- /dev/null +++ b/zfs-patches/0011-Fix-statfs-2-for-32-bit-user-space.patch @@ -0,0 +1,180 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Brian Behlendorf +Date: Mon, 24 Sep 2018 17:11:25 -0700 +Subject: [PATCH] Fix statfs(2) for 32-bit user space + +When handling a 32-bit statfs() system call the returned fields, +although 64-bit in the kernel, must be limited to 32-bits or an +EOVERFLOW error will be returned. + +This is less of an issue for block counts since the default +reported block size in 128KiB. But since it is possible to +set a smaller block size, these values will be scaled as +needed to fit in a 32-bit unsigned long. + +Unlike most other filesystems the total possible file counts +are more likely to overflow because they are calculated based +on the available free space in the pool. In order to prevent +this the reported value must be capped at 2^32-1. This is +only for statfs(2) reporting, there are no changes to the +internal ZFS limits. + +Reviewed-by: Andreas Dilger +Reviewed-by: Richard Yao +Signed-off-by: Brian Behlendorf +Issue #7927 +Closes #7122 +Closes #7937 +--- + config/kernel-in-compat-syscall.m4 | 20 ++++++++++++++++++++ + config/kernel.m4 | 1 + + include/linux/vfs_compat.h | 18 ++++++++++++++++++ + module/zfs/zfs_vfsops.c | 8 +++----- + module/zfs/zpl_super.c | 22 ++++++++++++++++++++++ + 5 files changed, 64 insertions(+), 5 deletions(-) + create mode 100644 config/kernel-in-compat-syscall.m4 + +diff --git a/config/kernel-in-compat-syscall.m4 b/config/kernel-in-compat-syscall.m4 +new file mode 100644 +index 00000000..9fca9da2 +--- /dev/null ++++ b/config/kernel-in-compat-syscall.m4 +@@ -0,0 +1,20 @@ ++dnl # ++dnl # 4.5 API change ++dnl # Added in_compat_syscall() which can be overridden on a per- ++dnl # architecture basis. Prior to this is_compat_task() was the ++dnl # provided interface. ++dnl # ++AC_DEFUN([ZFS_AC_KERNEL_IN_COMPAT_SYSCALL], [ ++ AC_MSG_CHECKING([whether in_compat_syscall() is available]) ++ ZFS_LINUX_TRY_COMPILE([ ++ #include ++ ],[ ++ in_compat_syscall(); ++ ],[ ++ AC_MSG_RESULT(yes) ++ AC_DEFINE(HAVE_IN_COMPAT_SYSCALL, 1, ++ [in_compat_syscall() is available]) ++ ],[ ++ AC_MSG_RESULT(no) ++ ]) ++]) +diff --git a/config/kernel.m4 b/config/kernel.m4 +index c7ca260c..3777f45c 100644 +--- a/config/kernel.m4 ++++ b/config/kernel.m4 +@@ -129,6 +129,7 @@ AC_DEFUN([ZFS_AC_CONFIG_KERNEL], [ + ZFS_AC_KERNEL_GLOBAL_PAGE_STATE + ZFS_AC_KERNEL_ACL_HAS_REFCOUNT + ZFS_AC_KERNEL_USERNS_CAPABILITIES ++ ZFS_AC_KERNEL_IN_COMPAT_SYSCALL + + AS_IF([test "$LINUX_OBJ" != "$LINUX"], [ + KERNELMAKE_PARAMS="$KERNELMAKE_PARAMS O=$LINUX_OBJ" +diff --git a/include/linux/vfs_compat.h b/include/linux/vfs_compat.h +index c8203bd5..90b3cca7 100644 +--- a/include/linux/vfs_compat.h ++++ b/include/linux/vfs_compat.h +@@ -30,6 +30,7 @@ + #include + #include + #include ++#include + + /* + * 2.6.28 API change, +@@ -626,4 +627,21 @@ inode_set_iversion(struct inode *ip, u64 val) + } + #endif + ++/* ++ * Returns true when called in the context of a 32-bit system call. ++ */ ++static inline int ++zpl_is_32bit_api(void) ++{ ++#ifdef CONFIG_COMPAT ++#ifdef HAVE_IN_COMPAT_SYSCALL ++ return (in_compat_syscall()); ++#else ++ return (is_compat_task()); ++#endif ++#else ++ return (BITS_PER_LONG == 32); ++#endif ++} ++ + #endif /* _ZFS_VFS_H */ +diff --git a/module/zfs/zfs_vfsops.c b/module/zfs/zfs_vfsops.c +index 76113393..bcdfa26b 100644 +--- a/module/zfs/zfs_vfsops.c ++++ b/module/zfs/zfs_vfsops.c +@@ -1245,15 +1245,13 @@ zfs_statvfs(struct dentry *dentry, struct kstatfs *statp) + { + zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info; + uint64_t refdbytes, availbytes, usedobjs, availobjs; +- uint64_t fsid; +- uint32_t bshift; + + ZFS_ENTER(zfsvfs); + + dmu_objset_space(zfsvfs->z_os, + &refdbytes, &availbytes, &usedobjs, &availobjs); + +- fsid = dmu_objset_fsid_guid(zfsvfs->z_os); ++ uint64_t fsid = dmu_objset_fsid_guid(zfsvfs->z_os); + /* + * The underlying storage pool actually uses multiple block + * size. Under Solaris frsize (fragment size) is reported as +@@ -1265,7 +1263,7 @@ zfs_statvfs(struct dentry *dentry, struct kstatfs *statp) + */ + statp->f_frsize = zfsvfs->z_max_blksz; + statp->f_bsize = zfsvfs->z_max_blksz; +- bshift = fls(statp->f_bsize) - 1; ++ uint32_t bshift = fls(statp->f_bsize) - 1; + + /* + * The following report "total" blocks of various kinds in +@@ -1282,7 +1280,7 @@ zfs_statvfs(struct dentry *dentry, struct kstatfs *statp) + * static metadata. ZFS doesn't preallocate files, so the best + * we can do is report the max that could possibly fit in f_files, + * and that minus the number actually used in f_ffree. +- * For f_ffree, report the smaller of the number of object available ++ * For f_ffree, report the smaller of the number of objects available + * and the number of blocks (each object will take at least a block). + */ + statp->f_ffree = MIN(availobjs, availbytes >> DNODE_SHIFT); +diff --git a/module/zfs/zpl_super.c b/module/zfs/zpl_super.c +index 5c426b0a..216c7940 100644 +--- a/module/zfs/zpl_super.c ++++ b/module/zfs/zpl_super.c +@@ -181,6 +181,28 @@ zpl_statfs(struct dentry *dentry, struct kstatfs *statp) + spl_fstrans_unmark(cookie); + ASSERT3S(error, <=, 0); + ++ /* ++ * If required by a 32-bit system call, dynamically scale the ++ * block size up to 16MiB and decrease the block counts. This ++ * allows for a maximum size of 64EiB to be reported. The file ++ * counts must be artificially capped at 2^32-1. ++ */ ++ if (unlikely(zpl_is_32bit_api())) { ++ while (statp->f_blocks > UINT32_MAX && ++ statp->f_bsize < SPA_MAXBLOCKSIZE) { ++ statp->f_frsize <<= 1; ++ statp->f_bsize <<= 1; ++ ++ statp->f_blocks >>= 1; ++ statp->f_bfree >>= 1; ++ statp->f_bavail >>= 1; ++ } ++ ++ uint64_t usedobjs = statp->f_files - statp->f_ffree; ++ statp->f_ffree = MIN(statp->f_ffree, UINT32_MAX - usedobjs); ++ statp->f_files = statp->f_ffree + usedobjs; ++ } ++ + return (error); + } + diff --git a/zfs-patches/0012-Zpool-iostat-remove-latency-queue-scaling.patch b/zfs-patches/0012-Zpool-iostat-remove-latency-queue-scaling.patch new file mode 100644 index 0000000..88ea5c4 --- /dev/null +++ b/zfs-patches/0012-Zpool-iostat-remove-latency-queue-scaling.patch @@ -0,0 +1,86 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Gregor Kopka +Date: Wed, 26 Sep 2018 01:29:16 +0200 +Subject: [PATCH] Zpool iostat: remove latency/queue scaling + +Bandwidth and iops are average per second while *_wait are averages +per request for latency or, for queue depths, an instantaneous +measurement at the end of an interval (according to man zpool). + +When calculating the first two it makes sense to do +x/interval_duration (x being the increase in total bytes or number of +requests over the duration of the interval, interval_duration in +seconds) to 'scale' from amount/interval_duration to amount/second. + +But applying the same math for the latter (*_wait latencies/queue) is +wrong as there is no interval_duration component in the values (these +are time/requests to get to average_time/request or already an +absulute number). + +This bug leads to the only correct continuous *_wait figures for both +latencies and queue depths from 'zpool iostat -l/q' being with +duration=1 as then the wrong math cancels itself (x/1 is a nop). + +This removes temporal scaling from latency and queue depth figures. + +Reviewed-by: Tony Hutter +Reviewed-by: Brian Behlendorf +Signed-off-by: Gregor Kopka +Closes #7945 +Closes #7694 +--- + cmd/zpool/zpool_main.c | 12 ++++++------ + 1 file changed, 6 insertions(+), 6 deletions(-) + +diff --git a/cmd/zpool/zpool_main.c b/cmd/zpool/zpool_main.c +index a4fd0321..591e2e5c 100644 +--- a/cmd/zpool/zpool_main.c ++++ b/cmd/zpool/zpool_main.c +@@ -3493,7 +3493,7 @@ single_histo_average(uint64_t *histo, unsigned int buckets) + + static void + print_iostat_queues(iostat_cbdata_t *cb, nvlist_t *oldnv, +- nvlist_t *newnv, double scale) ++ nvlist_t *newnv) + { + int i; + uint64_t val; +@@ -3523,7 +3523,7 @@ print_iostat_queues(iostat_cbdata_t *cb, nvlist_t *oldnv, + format = ZFS_NICENUM_1024; + + for (i = 0; i < ARRAY_SIZE(names); i++) { +- val = nva[i].data[0] * scale; ++ val = nva[i].data[0]; + print_one_stat(val, format, column_width, cb->cb_scripted); + } + +@@ -3532,7 +3532,7 @@ print_iostat_queues(iostat_cbdata_t *cb, nvlist_t *oldnv, + + static void + print_iostat_latency(iostat_cbdata_t *cb, nvlist_t *oldnv, +- nvlist_t *newnv, double scale) ++ nvlist_t *newnv) + { + int i; + uint64_t val; +@@ -3562,7 +3562,7 @@ print_iostat_latency(iostat_cbdata_t *cb, nvlist_t *oldnv, + /* Print our avg latencies on the line */ + for (i = 0; i < ARRAY_SIZE(names); i++) { + /* Compute average latency for a latency histo */ +- val = single_histo_average(nva[i].data, nva[i].count) * scale; ++ val = single_histo_average(nva[i].data, nva[i].count); + print_one_stat(val, format, column_width, cb->cb_scripted); + } + free_calc_stats(nva, ARRAY_SIZE(names)); +@@ -3701,9 +3701,9 @@ print_vdev_stats(zpool_handle_t *zhp, const char *name, nvlist_t *oldnv, + print_iostat_default(calcvs, cb, scale); + } + if (cb->cb_flags & IOS_LATENCY_M) +- print_iostat_latency(cb, oldnv, newnv, scale); ++ print_iostat_latency(cb, oldnv, newnv); + if (cb->cb_flags & IOS_QUEUES_M) +- print_iostat_queues(cb, oldnv, newnv, scale); ++ print_iostat_queues(cb, oldnv, newnv); + if (cb->cb_flags & IOS_ANYHISTO_M) { + printf("\n"); + print_iostat_histos(cb, oldnv, newnv, scale, name); diff --git a/zfs-patches/0013-Linux-4.19-rc3-compat-Remove-refcount_t-compat.patch b/zfs-patches/0013-Linux-4.19-rc3-compat-Remove-refcount_t-compat.patch new file mode 100644 index 0000000..bc142a0 --- /dev/null +++ b/zfs-patches/0013-Linux-4.19-rc3-compat-Remove-refcount_t-compat.patch @@ -0,0 +1,878 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Tim Schumacher +Date: Wed, 26 Sep 2018 19:29:26 +0200 +Subject: [PATCH] Linux 4.19-rc3+ compat: Remove refcount_t compat + +torvalds/linux@59b57717f ("blkcg: delay blkg destruction until +after writeback has finished") added a refcount_t to the blkcg +structure. Due to the refcount_t compatibility code, zfs_refcount_t +was used by mistake. + +Resolve this by removing the compatibility code and replacing the +occurrences of refcount_t with zfs_refcount_t. + +Reviewed-by: Franz Pletz +Reviewed-by: Brian Behlendorf +Signed-off-by: Tim Schumacher +Closes #7885 +Closes #7932 +--- + cmd/ztest/ztest.c | 6 +++--- + include/linux/vfs_compat.h | 5 ----- + include/sys/abd.h | 2 +- + include/sys/arc.h | 2 +- + include/sys/arc_impl.h | 8 +++---- + include/sys/dbuf.h | 2 +- + include/sys/dmu_tx.h | 4 ++-- + include/sys/dnode.h | 4 ++-- + include/sys/dsl_dataset.h | 2 +- + include/sys/metaslab_impl.h | 5 ++--- + include/sys/refcount.h | 52 ++++++++++++++++++++------------------------- + include/sys/rrwlock.h | 4 ++-- + include/sys/sa_impl.h | 2 +- + include/sys/spa_impl.h | 6 +++--- + include/sys/zap.h | 2 +- + include/sys/zfs_znode.h | 2 +- + module/zfs/arc.c | 12 +++++------ + module/zfs/dbuf.c | 10 ++++----- + module/zfs/dmu.c | 2 +- + module/zfs/dmu_tx.c | 6 +++--- + module/zfs/dnode.c | 6 +++--- + module/zfs/dsl_dataset.c | 2 +- + module/zfs/metaslab.c | 4 ++-- + module/zfs/refcount.c | 30 +++++++++++++------------- + module/zfs/rrwlock.c | 4 ++-- + module/zfs/sa.c | 2 +- + module/zfs/spa_misc.c | 8 +++---- + module/zfs/zfs_ctldir.c | 10 ++++----- + module/zfs/zfs_znode.c | 2 +- + 29 files changed, 97 insertions(+), 109 deletions(-) + +diff --git a/cmd/ztest/ztest.c b/cmd/ztest/ztest.c +index a410eeef..24967a76 100644 +--- a/cmd/ztest/ztest.c ++++ b/cmd/ztest/ztest.c +@@ -1189,7 +1189,7 @@ ztest_spa_prop_set_uint64(zpool_prop_t prop, uint64_t value) + */ + typedef struct { + list_node_t z_lnode; +- refcount_t z_refcnt; ++ zfs_refcount_t z_refcnt; + uint64_t z_object; + zfs_rlock_t z_range_lock; + } ztest_znode_t; +@@ -1248,13 +1248,13 @@ ztest_znode_get(ztest_ds_t *zd, uint64_t object) + for (zp = list_head(&zll->z_list); (zp); + zp = list_next(&zll->z_list, zp)) { + if (zp->z_object == object) { +- refcount_add(&zp->z_refcnt, RL_TAG); ++ zfs_refcount_add(&zp->z_refcnt, RL_TAG); + break; + } + } + if (zp == NULL) { + zp = ztest_znode_init(object); +- refcount_add(&zp->z_refcnt, RL_TAG); ++ zfs_refcount_add(&zp->z_refcnt, RL_TAG); + list_insert_head(&zll->z_list, zp); + } + mutex_exit(&zll->z_lock); +diff --git a/include/linux/vfs_compat.h b/include/linux/vfs_compat.h +index 90b3cca7..c01f5850 100644 +--- a/include/linux/vfs_compat.h ++++ b/include/linux/vfs_compat.h +@@ -297,9 +297,6 @@ lseek_execute( + * This is several orders of magnitude larger than expected grace period. + * At 60 seconds the kernel will also begin issuing RCU stall warnings. + */ +-#ifdef refcount_t +-#undef refcount_t +-#endif + + #include + +@@ -430,8 +427,6 @@ typedef mode_t zpl_equivmode_t; + #define zpl_posix_acl_valid(ip, acl) posix_acl_valid(acl) + #endif + +-#define refcount_t zfs_refcount_t +- + #endif /* CONFIG_FS_POSIX_ACL */ + + /* +diff --git a/include/sys/abd.h b/include/sys/abd.h +index cd710501..4898606a 100644 +--- a/include/sys/abd.h ++++ b/include/sys/abd.h +@@ -52,7 +52,7 @@ typedef struct abd { + abd_flags_t abd_flags; + uint_t abd_size; /* excludes scattered abd_offset */ + struct abd *abd_parent; +- refcount_t abd_children; ++ zfs_refcount_t abd_children; + union { + struct abd_scatter { + uint_t abd_offset; +diff --git a/include/sys/arc.h b/include/sys/arc.h +index 1ea4937b..943ebfb5 100644 +--- a/include/sys/arc.h ++++ b/include/sys/arc.h +@@ -76,7 +76,7 @@ struct arc_prune { + void *p_private; + uint64_t p_adjust; + list_node_t p_node; +- refcount_t p_refcnt; ++ zfs_refcount_t p_refcnt; + }; + + typedef enum arc_strategy { +diff --git a/include/sys/arc_impl.h b/include/sys/arc_impl.h +index c6363f2a..ed2b0abe 100644 +--- a/include/sys/arc_impl.h ++++ b/include/sys/arc_impl.h +@@ -74,12 +74,12 @@ typedef struct arc_state { + /* + * total amount of evictable data in this state + */ +- refcount_t arcs_esize[ARC_BUFC_NUMTYPES]; ++ zfs_refcount_t arcs_esize[ARC_BUFC_NUMTYPES]; + /* + * total amount of data in this state; this includes: evictable, + * non-evictable, ARC_BUFC_DATA, and ARC_BUFC_METADATA. + */ +- refcount_t arcs_size; ++ zfs_refcount_t arcs_size; + /* + * supports the "dbufs" kstat + */ +@@ -163,7 +163,7 @@ typedef struct l1arc_buf_hdr { + uint32_t b_l2_hits; + + /* self protecting */ +- refcount_t b_refcnt; ++ zfs_refcount_t b_refcnt; + + arc_callback_t *b_acb; + abd_t *b_pabd; +@@ -180,7 +180,7 @@ typedef struct l2arc_dev { + kmutex_t l2ad_mtx; /* lock for buffer list */ + list_t l2ad_buflist; /* buffer list */ + list_node_t l2ad_node; /* device list node */ +- refcount_t l2ad_alloc; /* allocated bytes */ ++ zfs_refcount_t l2ad_alloc; /* allocated bytes */ + } l2arc_dev_t; + + typedef struct l2arc_buf_hdr { +diff --git a/include/sys/dbuf.h b/include/sys/dbuf.h +index f3f2007d..127acad3 100644 +--- a/include/sys/dbuf.h ++++ b/include/sys/dbuf.h +@@ -212,7 +212,7 @@ typedef struct dmu_buf_impl { + * If nonzero, the buffer can't be destroyed. + * Protected by db_mtx. + */ +- refcount_t db_holds; ++ zfs_refcount_t db_holds; + + /* buffer holding our data */ + arc_buf_t *db_buf; +diff --git a/include/sys/dmu_tx.h b/include/sys/dmu_tx.h +index 74b7e111..96bbcb05 100644 +--- a/include/sys/dmu_tx.h ++++ b/include/sys/dmu_tx.h +@@ -97,8 +97,8 @@ typedef struct dmu_tx_hold { + dmu_tx_t *txh_tx; + list_node_t txh_node; + struct dnode *txh_dnode; +- refcount_t txh_space_towrite; +- refcount_t txh_memory_tohold; ++ zfs_refcount_t txh_space_towrite; ++ zfs_refcount_t txh_memory_tohold; + enum dmu_tx_hold_type txh_type; + uint64_t txh_arg1; + uint64_t txh_arg2; +diff --git a/include/sys/dnode.h b/include/sys/dnode.h +index 2dd087b3..1e77e0a3 100644 +--- a/include/sys/dnode.h ++++ b/include/sys/dnode.h +@@ -266,8 +266,8 @@ struct dnode { + uint8_t *dn_dirtyctx_firstset; /* dbg: contents meaningless */ + + /* protected by own devices */ +- refcount_t dn_tx_holds; +- refcount_t dn_holds; ++ zfs_refcount_t dn_tx_holds; ++ zfs_refcount_t dn_holds; + + kmutex_t dn_dbufs_mtx; + /* +diff --git a/include/sys/dsl_dataset.h b/include/sys/dsl_dataset.h +index 1281674b..d96f526d 100644 +--- a/include/sys/dsl_dataset.h ++++ b/include/sys/dsl_dataset.h +@@ -186,7 +186,7 @@ typedef struct dsl_dataset { + * Owning counts as a long hold. See the comments above + * dsl_pool_hold() for details. + */ +- refcount_t ds_longholds; ++ zfs_refcount_t ds_longholds; + + /* no locking; only for making guesses */ + uint64_t ds_trysnap_txg; +diff --git a/include/sys/metaslab_impl.h b/include/sys/metaslab_impl.h +index f8a713a4..60151937 100644 +--- a/include/sys/metaslab_impl.h ++++ b/include/sys/metaslab_impl.h +@@ -179,8 +179,7 @@ struct metaslab_class { + * number of allocations allowed. + */ + uint64_t mc_alloc_max_slots; +- refcount_t mc_alloc_slots; +- ++ zfs_refcount_t mc_alloc_slots; + uint64_t mc_alloc_groups; /* # of allocatable groups */ + + uint64_t mc_alloc; /* total allocated space */ +@@ -230,7 +229,7 @@ struct metaslab_group { + * are unable to handle their share of allocations. + */ + uint64_t mg_max_alloc_queue_depth; +- refcount_t mg_alloc_queue_depth; ++ zfs_refcount_t mg_alloc_queue_depth; + + /* + * A metalab group that can no longer allocate the minimum block +diff --git a/include/sys/refcount.h b/include/sys/refcount.h +index a96220b2..5c5198d8 100644 +--- a/include/sys/refcount.h ++++ b/include/sys/refcount.h +@@ -41,17 +41,6 @@ extern "C" { + */ + #define FTAG ((char *)__func__) + +-/* +- * Starting with 4.11, torvalds/linux@f405df5, the linux kernel defines a +- * refcount_t type of its own. The macro below effectively changes references +- * in the ZFS code from refcount_t to zfs_refcount_t at compile time, so that +- * existing code need not be altered, reducing conflicts when landing openZFS +- * patches. +- */ +- +-#define refcount_t zfs_refcount_t +-#define refcount_add zfs_refcount_add +- + #ifdef ZFS_DEBUG + typedef struct reference { + list_node_t ref_link; +@@ -69,23 +58,28 @@ typedef struct refcount { + uint64_t rc_removed_count; + } zfs_refcount_t; + +-/* Note: refcount_t must be initialized with refcount_create[_untracked]() */ +- +-void refcount_create(refcount_t *rc); +-void refcount_create_untracked(refcount_t *rc); +-void refcount_create_tracked(refcount_t *rc); +-void refcount_destroy(refcount_t *rc); +-void refcount_destroy_many(refcount_t *rc, uint64_t number); +-int refcount_is_zero(refcount_t *rc); +-int64_t refcount_count(refcount_t *rc); +-int64_t zfs_refcount_add(refcount_t *rc, void *holder_tag); +-int64_t refcount_remove(refcount_t *rc, void *holder_tag); +-int64_t refcount_add_many(refcount_t *rc, uint64_t number, void *holder_tag); +-int64_t refcount_remove_many(refcount_t *rc, uint64_t number, void *holder_tag); +-void refcount_transfer(refcount_t *dst, refcount_t *src); +-void refcount_transfer_ownership(refcount_t *, void *, void *); +-boolean_t refcount_held(refcount_t *, void *); +-boolean_t refcount_not_held(refcount_t *, void *); ++/* ++ * Note: zfs_refcount_t must be initialized with ++ * refcount_create[_untracked]() ++ */ ++ ++void refcount_create(zfs_refcount_t *rc); ++void refcount_create_untracked(zfs_refcount_t *rc); ++void refcount_create_tracked(zfs_refcount_t *rc); ++void refcount_destroy(zfs_refcount_t *rc); ++void refcount_destroy_many(zfs_refcount_t *rc, uint64_t number); ++int refcount_is_zero(zfs_refcount_t *rc); ++int64_t refcount_count(zfs_refcount_t *rc); ++int64_t zfs_refcount_add(zfs_refcount_t *rc, void *holder_tag); ++int64_t refcount_remove(zfs_refcount_t *rc, void *holder_tag); ++int64_t refcount_add_many(zfs_refcount_t *rc, uint64_t number, ++ void *holder_tag); ++int64_t refcount_remove_many(zfs_refcount_t *rc, uint64_t number, ++ void *holder_tag); ++void refcount_transfer(zfs_refcount_t *dst, zfs_refcount_t *src); ++void refcount_transfer_ownership(zfs_refcount_t *, void *, void *); ++boolean_t refcount_held(zfs_refcount_t *, void *); ++boolean_t refcount_not_held(zfs_refcount_t *, void *); + + void refcount_init(void); + void refcount_fini(void); +@@ -94,7 +88,7 @@ void refcount_fini(void); + + typedef struct refcount { + uint64_t rc_count; +-} refcount_t; ++} zfs_refcount_t; + + #define refcount_create(rc) ((rc)->rc_count = 0) + #define refcount_create_untracked(rc) ((rc)->rc_count = 0) +diff --git a/include/sys/rrwlock.h b/include/sys/rrwlock.h +index 7a328fd6..e1c1756c 100644 +--- a/include/sys/rrwlock.h ++++ b/include/sys/rrwlock.h +@@ -57,8 +57,8 @@ typedef struct rrwlock { + kmutex_t rr_lock; + kcondvar_t rr_cv; + kthread_t *rr_writer; +- refcount_t rr_anon_rcount; +- refcount_t rr_linked_rcount; ++ zfs_refcount_t rr_anon_rcount; ++ zfs_refcount_t rr_linked_rcount; + boolean_t rr_writer_wanted; + boolean_t rr_track_all; + } rrwlock_t; +diff --git a/include/sys/sa_impl.h b/include/sys/sa_impl.h +index b68b7610..7eddd875 100644 +--- a/include/sys/sa_impl.h ++++ b/include/sys/sa_impl.h +@@ -110,7 +110,7 @@ typedef struct sa_idx_tab { + list_node_t sa_next; + sa_lot_t *sa_layout; + uint16_t *sa_variable_lengths; +- refcount_t sa_refcount; ++ zfs_refcount_t sa_refcount; + uint32_t *sa_idx_tab; /* array of offsets */ + } sa_idx_tab_t; + +diff --git a/include/sys/spa_impl.h b/include/sys/spa_impl.h +index fa7490ac..62ac8f67 100644 +--- a/include/sys/spa_impl.h ++++ b/include/sys/spa_impl.h +@@ -78,7 +78,7 @@ typedef struct spa_config_lock { + kthread_t *scl_writer; + int scl_write_wanted; + kcondvar_t scl_cv; +- refcount_t scl_count; ++ zfs_refcount_t scl_count; + } spa_config_lock_t; + + typedef struct spa_config_dirent { +@@ -281,12 +281,12 @@ struct spa { + + /* + * spa_refcount & spa_config_lock must be the last elements +- * because refcount_t changes size based on compilation options. ++ * because zfs_refcount_t changes size based on compilation options. + * In order for the MDB module to function correctly, the other + * fields must remain in the same location. + */ + spa_config_lock_t spa_config_lock[SCL_LOCKS]; /* config changes */ +- refcount_t spa_refcount; /* number of opens */ ++ zfs_refcount_t spa_refcount; /* number of opens */ + + taskq_t *spa_upgrade_taskq; /* taskq for upgrade jobs */ + }; +diff --git a/include/sys/zap.h b/include/sys/zap.h +index 43b7fbd2..7acc3bec 100644 +--- a/include/sys/zap.h ++++ b/include/sys/zap.h +@@ -226,7 +226,7 @@ int zap_lookup_norm_by_dnode(dnode_t *dn, const char *name, + boolean_t *ncp); + + int zap_count_write_by_dnode(dnode_t *dn, const char *name, +- int add, refcount_t *towrite, refcount_t *tooverwrite); ++ int add, zfs_refcount_t *towrite, zfs_refcount_t *tooverwrite); + + /* + * Create an attribute with the given name and value. +diff --git a/include/sys/zfs_znode.h b/include/sys/zfs_znode.h +index 26d1eb37..33bc20d1 100644 +--- a/include/sys/zfs_znode.h ++++ b/include/sys/zfs_znode.h +@@ -209,7 +209,7 @@ typedef struct znode_hold { + uint64_t zh_obj; /* object id */ + kmutex_t zh_lock; /* lock serializing object access */ + avl_node_t zh_node; /* avl tree linkage */ +- refcount_t zh_refcount; /* active consumer reference count */ ++ zfs_refcount_t zh_refcount; /* active consumer reference count */ + } znode_hold_t; + + /* +diff --git a/module/zfs/arc.c b/module/zfs/arc.c +index bcf74dd6..7518d5c8 100644 +--- a/module/zfs/arc.c ++++ b/module/zfs/arc.c +@@ -1966,7 +1966,7 @@ add_reference(arc_buf_hdr_t *hdr, void *tag) + + state = hdr->b_l1hdr.b_state; + +- if ((refcount_add(&hdr->b_l1hdr.b_refcnt, tag) == 1) && ++ if ((zfs_refcount_add(&hdr->b_l1hdr.b_refcnt, tag) == 1) && + (state != arc_anon)) { + /* We don't use the L2-only state list. */ + if (state != arc_l2c_only) { +@@ -2505,7 +2505,7 @@ arc_return_buf(arc_buf_t *buf, void *tag) + + ASSERT3P(buf->b_data, !=, NULL); + ASSERT(HDR_HAS_L1HDR(hdr)); +- (void) refcount_add(&hdr->b_l1hdr.b_refcnt, tag); ++ (void) zfs_refcount_add(&hdr->b_l1hdr.b_refcnt, tag); + (void) refcount_remove(&hdr->b_l1hdr.b_refcnt, arc_onloan_tag); + + arc_loaned_bytes_update(-arc_buf_size(buf)); +@@ -2519,7 +2519,7 @@ arc_loan_inuse_buf(arc_buf_t *buf, void *tag) + + ASSERT3P(buf->b_data, !=, NULL); + ASSERT(HDR_HAS_L1HDR(hdr)); +- (void) refcount_add(&hdr->b_l1hdr.b_refcnt, arc_onloan_tag); ++ (void) zfs_refcount_add(&hdr->b_l1hdr.b_refcnt, arc_onloan_tag); + (void) refcount_remove(&hdr->b_l1hdr.b_refcnt, tag); + + arc_loaned_bytes_update(arc_buf_size(buf)); +@@ -3533,7 +3533,7 @@ arc_prune_async(int64_t adjust) + if (refcount_count(&ap->p_refcnt) >= 2) + continue; + +- refcount_add(&ap->p_refcnt, ap->p_pfunc); ++ zfs_refcount_add(&ap->p_refcnt, ap->p_pfunc); + ap->p_adjust = adjust; + if (taskq_dispatch(arc_prune_taskq, arc_prune_task, + ap, TQ_SLEEP) == TASKQID_INVALID) { +@@ -5549,7 +5549,7 @@ arc_add_prune_callback(arc_prune_func_t *func, void *private) + refcount_create(&p->p_refcnt); + + mutex_enter(&arc_prune_mtx); +- refcount_add(&p->p_refcnt, &arc_prune_list); ++ zfs_refcount_add(&p->p_refcnt, &arc_prune_list); + list_insert_head(&arc_prune_list, p); + mutex_exit(&arc_prune_mtx); + +@@ -5815,7 +5815,7 @@ arc_release(arc_buf_t *buf, void *tag) + nhdr->b_l1hdr.b_mfu_hits = 0; + nhdr->b_l1hdr.b_mfu_ghost_hits = 0; + nhdr->b_l1hdr.b_l2_hits = 0; +- (void) refcount_add(&nhdr->b_l1hdr.b_refcnt, tag); ++ (void) zfs_refcount_add(&nhdr->b_l1hdr.b_refcnt, tag); + buf->b_hdr = nhdr; + + mutex_exit(&buf->b_evict_lock); +diff --git a/module/zfs/dbuf.c b/module/zfs/dbuf.c +index 6edb39d6..5101c848 100644 +--- a/module/zfs/dbuf.c ++++ b/module/zfs/dbuf.c +@@ -104,7 +104,7 @@ static boolean_t dbuf_evict_thread_exit; + * become eligible for arc eviction. + */ + static multilist_t *dbuf_cache; +-static refcount_t dbuf_cache_size; ++static zfs_refcount_t dbuf_cache_size; + unsigned long dbuf_cache_max_bytes = 100 * 1024 * 1024; + + /* Cap the size of the dbuf cache to log2 fraction of arc size. */ +@@ -2384,7 +2384,7 @@ dbuf_create(dnode_t *dn, uint8_t level, uint64_t blkid, + + ASSERT(dn->dn_object == DMU_META_DNODE_OBJECT || + refcount_count(&dn->dn_holds) > 0); +- (void) refcount_add(&dn->dn_holds, db); ++ (void) zfs_refcount_add(&dn->dn_holds, db); + atomic_inc_32(&dn->dn_dbufs_count); + + dprintf_dbuf(db, "db=%p\n", db); +@@ -2749,7 +2749,7 @@ __dbuf_hold_impl(struct dbuf_hold_impl_data *dh) + (void) refcount_remove_many(&dbuf_cache_size, + dh->dh_db->db.db_size, dh->dh_db); + } +- (void) refcount_add(&dh->dh_db->db_holds, dh->dh_tag); ++ (void) zfs_refcount_add(&dh->dh_db->db_holds, dh->dh_tag); + DBUF_VERIFY(dh->dh_db); + mutex_exit(&dh->dh_db->db_mtx); + +@@ -2873,7 +2873,7 @@ dbuf_rm_spill(dnode_t *dn, dmu_tx_t *tx) + void + dbuf_add_ref(dmu_buf_impl_t *db, void *tag) + { +- int64_t holds = refcount_add(&db->db_holds, tag); ++ int64_t holds = zfs_refcount_add(&db->db_holds, tag); + VERIFY3S(holds, >, 1); + } + +@@ -2893,7 +2893,7 @@ dbuf_try_add_ref(dmu_buf_t *db_fake, objset_t *os, uint64_t obj, uint64_t blkid, + + if (found_db != NULL) { + if (db == found_db && dbuf_refcount(db) > db->db_dirtycnt) { +- (void) refcount_add(&db->db_holds, tag); ++ (void) zfs_refcount_add(&db->db_holds, tag); + result = B_TRUE; + } + mutex_exit(&found_db->db_mtx); +diff --git a/module/zfs/dmu.c b/module/zfs/dmu.c +index a09ac4f9..a76cdd9f 100644 +--- a/module/zfs/dmu.c ++++ b/module/zfs/dmu.c +@@ -342,7 +342,7 @@ dmu_bonus_hold(objset_t *os, uint64_t object, void *tag, dmu_buf_t **dbp) + db = dn->dn_bonus; + + /* as long as the bonus buf is held, the dnode will be held */ +- if (refcount_add(&db->db_holds, tag) == 1) { ++ if (zfs_refcount_add(&db->db_holds, tag) == 1) { + VERIFY(dnode_add_ref(dn, db)); + atomic_inc_32(&dn->dn_dbufs_count); + } +diff --git a/module/zfs/dmu_tx.c b/module/zfs/dmu_tx.c +index 6ebff267..b1508ffa 100644 +--- a/module/zfs/dmu_tx.c ++++ b/module/zfs/dmu_tx.c +@@ -114,7 +114,7 @@ dmu_tx_hold_dnode_impl(dmu_tx_t *tx, dnode_t *dn, enum dmu_tx_hold_type type, + dmu_tx_hold_t *txh; + + if (dn != NULL) { +- (void) refcount_add(&dn->dn_holds, tx); ++ (void) zfs_refcount_add(&dn->dn_holds, tx); + if (tx->tx_txg != 0) { + mutex_enter(&dn->dn_mtx); + /* +@@ -124,7 +124,7 @@ dmu_tx_hold_dnode_impl(dmu_tx_t *tx, dnode_t *dn, enum dmu_tx_hold_type type, + */ + ASSERT(dn->dn_assigned_txg == 0); + dn->dn_assigned_txg = tx->tx_txg; +- (void) refcount_add(&dn->dn_tx_holds, tx); ++ (void) zfs_refcount_add(&dn->dn_tx_holds, tx); + mutex_exit(&dn->dn_mtx); + } + } +@@ -916,7 +916,7 @@ dmu_tx_try_assign(dmu_tx_t *tx, uint64_t txg_how) + if (dn->dn_assigned_txg == 0) + dn->dn_assigned_txg = tx->tx_txg; + ASSERT3U(dn->dn_assigned_txg, ==, tx->tx_txg); +- (void) refcount_add(&dn->dn_tx_holds, tx); ++ (void) zfs_refcount_add(&dn->dn_tx_holds, tx); + mutex_exit(&dn->dn_mtx); + } + towrite += refcount_count(&txh->txh_space_towrite); +diff --git a/module/zfs/dnode.c b/module/zfs/dnode.c +index 4a169c49..77d38c36 100644 +--- a/module/zfs/dnode.c ++++ b/module/zfs/dnode.c +@@ -1267,7 +1267,7 @@ dnode_hold_impl(objset_t *os, uint64_t object, int flag, int slots, + if ((flag & DNODE_MUST_BE_FREE) && type != DMU_OT_NONE) + return (SET_ERROR(EEXIST)); + DNODE_VERIFY(dn); +- (void) refcount_add(&dn->dn_holds, tag); ++ (void) zfs_refcount_add(&dn->dn_holds, tag); + *dnp = dn; + return (0); + } +@@ -1484,7 +1484,7 @@ dnode_hold_impl(objset_t *os, uint64_t object, int flag, int slots, + return (type == DMU_OT_NONE ? ENOENT : EEXIST); + } + +- if (refcount_add(&dn->dn_holds, tag) == 1) ++ if (zfs_refcount_add(&dn->dn_holds, tag) == 1) + dbuf_add_ref(db, dnh); + + mutex_exit(&dn->dn_mtx); +@@ -1524,7 +1524,7 @@ dnode_add_ref(dnode_t *dn, void *tag) + mutex_exit(&dn->dn_mtx); + return (FALSE); + } +- VERIFY(1 < refcount_add(&dn->dn_holds, tag)); ++ VERIFY(1 < zfs_refcount_add(&dn->dn_holds, tag)); + mutex_exit(&dn->dn_mtx); + return (TRUE); + } +diff --git a/module/zfs/dsl_dataset.c b/module/zfs/dsl_dataset.c +index bd03b486..b7562bcd 100644 +--- a/module/zfs/dsl_dataset.c ++++ b/module/zfs/dsl_dataset.c +@@ -645,7 +645,7 @@ void + dsl_dataset_long_hold(dsl_dataset_t *ds, void *tag) + { + ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool)); +- (void) refcount_add(&ds->ds_longholds, tag); ++ (void) zfs_refcount_add(&ds->ds_longholds, tag); + } + + void +diff --git a/module/zfs/metaslab.c b/module/zfs/metaslab.c +index ee24850d..40658d51 100644 +--- a/module/zfs/metaslab.c ++++ b/module/zfs/metaslab.c +@@ -2663,7 +2663,7 @@ metaslab_group_alloc_increment(spa_t *spa, uint64_t vdev, void *tag, int flags) + if (!mg->mg_class->mc_alloc_throttle_enabled) + return; + +- (void) refcount_add(&mg->mg_alloc_queue_depth, tag); ++ (void) zfs_refcount_add(&mg->mg_alloc_queue_depth, tag); + } + + void +@@ -3360,7 +3360,7 @@ metaslab_class_throttle_reserve(metaslab_class_t *mc, int slots, zio_t *zio, + * them individually when an I/O completes. + */ + for (d = 0; d < slots; d++) { +- reserved_slots = refcount_add(&mc->mc_alloc_slots, zio); ++ reserved_slots = zfs_refcount_add(&mc->mc_alloc_slots, zio); + } + zio->io_flags |= ZIO_FLAG_IO_ALLOCATING; + slot_reserved = B_TRUE; +diff --git a/module/zfs/refcount.c b/module/zfs/refcount.c +index a151acea..13f9bb6b 100644 +--- a/module/zfs/refcount.c ++++ b/module/zfs/refcount.c +@@ -55,7 +55,7 @@ refcount_fini(void) + } + + void +-refcount_create(refcount_t *rc) ++refcount_create(zfs_refcount_t *rc) + { + mutex_init(&rc->rc_mtx, NULL, MUTEX_DEFAULT, NULL); + list_create(&rc->rc_list, sizeof (reference_t), +@@ -68,21 +68,21 @@ refcount_create(refcount_t *rc) + } + + void +-refcount_create_tracked(refcount_t *rc) ++refcount_create_tracked(zfs_refcount_t *rc) + { + refcount_create(rc); + rc->rc_tracked = B_TRUE; + } + + void +-refcount_create_untracked(refcount_t *rc) ++refcount_create_untracked(zfs_refcount_t *rc) + { + refcount_create(rc); + rc->rc_tracked = B_FALSE; + } + + void +-refcount_destroy_many(refcount_t *rc, uint64_t number) ++refcount_destroy_many(zfs_refcount_t *rc, uint64_t number) + { + reference_t *ref; + +@@ -103,25 +103,25 @@ refcount_destroy_many(refcount_t *rc, uint64_t number) + } + + void +-refcount_destroy(refcount_t *rc) ++refcount_destroy(zfs_refcount_t *rc) + { + refcount_destroy_many(rc, 0); + } + + int +-refcount_is_zero(refcount_t *rc) ++refcount_is_zero(zfs_refcount_t *rc) + { + return (rc->rc_count == 0); + } + + int64_t +-refcount_count(refcount_t *rc) ++refcount_count(zfs_refcount_t *rc) + { + return (rc->rc_count); + } + + int64_t +-refcount_add_many(refcount_t *rc, uint64_t number, void *holder) ++refcount_add_many(zfs_refcount_t *rc, uint64_t number, void *holder) + { + reference_t *ref = NULL; + int64_t count; +@@ -143,13 +143,13 @@ refcount_add_many(refcount_t *rc, uint64_t number, void *holder) + } + + int64_t +-zfs_refcount_add(refcount_t *rc, void *holder) ++zfs_refcount_add(zfs_refcount_t *rc, void *holder) + { + return (refcount_add_many(rc, 1, holder)); + } + + int64_t +-refcount_remove_many(refcount_t *rc, uint64_t number, void *holder) ++refcount_remove_many(zfs_refcount_t *rc, uint64_t number, void *holder) + { + reference_t *ref; + int64_t count; +@@ -197,13 +197,13 @@ refcount_remove_many(refcount_t *rc, uint64_t number, void *holder) + } + + int64_t +-refcount_remove(refcount_t *rc, void *holder) ++refcount_remove(zfs_refcount_t *rc, void *holder) + { + return (refcount_remove_many(rc, 1, holder)); + } + + void +-refcount_transfer(refcount_t *dst, refcount_t *src) ++refcount_transfer(zfs_refcount_t *dst, zfs_refcount_t *src) + { + int64_t count, removed_count; + list_t list, removed; +@@ -234,7 +234,7 @@ refcount_transfer(refcount_t *dst, refcount_t *src) + } + + void +-refcount_transfer_ownership(refcount_t *rc, void *current_holder, ++refcount_transfer_ownership(zfs_refcount_t *rc, void *current_holder, + void *new_holder) + { + reference_t *ref; +@@ -264,7 +264,7 @@ refcount_transfer_ownership(refcount_t *rc, void *current_holder, + * might be held. + */ + boolean_t +-refcount_held(refcount_t *rc, void *holder) ++refcount_held(zfs_refcount_t *rc, void *holder) + { + reference_t *ref; + +@@ -292,7 +292,7 @@ refcount_held(refcount_t *rc, void *holder) + * since the reference might not be held. + */ + boolean_t +-refcount_not_held(refcount_t *rc, void *holder) ++refcount_not_held(zfs_refcount_t *rc, void *holder) + { + reference_t *ref; + +diff --git a/module/zfs/rrwlock.c b/module/zfs/rrwlock.c +index 704f7606..effff330 100644 +--- a/module/zfs/rrwlock.c ++++ b/module/zfs/rrwlock.c +@@ -183,9 +183,9 @@ rrw_enter_read_impl(rrwlock_t *rrl, boolean_t prio, void *tag) + if (rrl->rr_writer_wanted || rrl->rr_track_all) { + /* may or may not be a re-entrant enter */ + rrn_add(rrl, tag); +- (void) refcount_add(&rrl->rr_linked_rcount, tag); ++ (void) zfs_refcount_add(&rrl->rr_linked_rcount, tag); + } else { +- (void) refcount_add(&rrl->rr_anon_rcount, tag); ++ (void) zfs_refcount_add(&rrl->rr_anon_rcount, tag); + } + ASSERT(rrl->rr_writer == NULL); + mutex_exit(&rrl->rr_lock); +diff --git a/module/zfs/sa.c b/module/zfs/sa.c +index 1fb1a8b5..df4f6fd8 100644 +--- a/module/zfs/sa.c ++++ b/module/zfs/sa.c +@@ -1337,7 +1337,7 @@ sa_idx_tab_hold(objset_t *os, sa_idx_tab_t *idx_tab) + ASSERTV(sa_os_t *sa = os->os_sa); + + ASSERT(MUTEX_HELD(&sa->sa_lock)); +- (void) refcount_add(&idx_tab->sa_refcount, NULL); ++ (void) zfs_refcount_add(&idx_tab->sa_refcount, NULL); + } + + void +diff --git a/module/zfs/spa_misc.c b/module/zfs/spa_misc.c +index cc1c641d..f6c9b40b 100644 +--- a/module/zfs/spa_misc.c ++++ b/module/zfs/spa_misc.c +@@ -80,7 +80,7 @@ + * definition they must have an existing reference, and will never need + * to lookup a spa_t by name. + * +- * spa_refcount (per-spa refcount_t protected by mutex) ++ * spa_refcount (per-spa zfs_refcount_t protected by mutex) + * + * This reference count keep track of any active users of the spa_t. The + * spa_t cannot be destroyed or freed while this is non-zero. Internally, +@@ -414,7 +414,7 @@ spa_config_tryenter(spa_t *spa, int locks, void *tag, krw_t rw) + } + scl->scl_writer = curthread; + } +- (void) refcount_add(&scl->scl_count, tag); ++ (void) zfs_refcount_add(&scl->scl_count, tag); + mutex_exit(&scl->scl_lock); + } + return (1); +@@ -448,7 +448,7 @@ spa_config_enter(spa_t *spa, int locks, void *tag, krw_t rw) + } + scl->scl_writer = curthread; + } +- (void) refcount_add(&scl->scl_count, tag); ++ (void) zfs_refcount_add(&scl->scl_count, tag); + mutex_exit(&scl->scl_lock); + } + ASSERT(wlocks_held <= locks); +@@ -768,7 +768,7 @@ spa_open_ref(spa_t *spa, void *tag) + { + ASSERT(refcount_count(&spa->spa_refcount) >= spa->spa_minref || + MUTEX_HELD(&spa_namespace_lock)); +- (void) refcount_add(&spa->spa_refcount, tag); ++ (void) zfs_refcount_add(&spa->spa_refcount, tag); + } + + /* +diff --git a/module/zfs/zfs_ctldir.c b/module/zfs/zfs_ctldir.c +index 0ab5b4f0..de3c5a41 100644 +--- a/module/zfs/zfs_ctldir.c ++++ b/module/zfs/zfs_ctldir.c +@@ -120,7 +120,7 @@ typedef struct { + taskqid_t se_taskqid; /* scheduled unmount taskqid */ + avl_node_t se_node_name; /* zfs_snapshots_by_name link */ + avl_node_t se_node_objsetid; /* zfs_snapshots_by_objsetid link */ +- refcount_t se_refcount; /* reference count */ ++ zfs_refcount_t se_refcount; /* reference count */ + } zfs_snapentry_t; + + static void zfsctl_snapshot_unmount_delay_impl(zfs_snapentry_t *se, int delay); +@@ -169,7 +169,7 @@ zfsctl_snapshot_free(zfs_snapentry_t *se) + static void + zfsctl_snapshot_hold(zfs_snapentry_t *se) + { +- refcount_add(&se->se_refcount, NULL); ++ zfs_refcount_add(&se->se_refcount, NULL); + } + + /* +@@ -192,7 +192,7 @@ static void + zfsctl_snapshot_add(zfs_snapentry_t *se) + { + ASSERT(RW_WRITE_HELD(&zfs_snapshot_lock)); +- refcount_add(&se->se_refcount, NULL); ++ zfs_refcount_add(&se->se_refcount, NULL); + avl_add(&zfs_snapshots_by_name, se); + avl_add(&zfs_snapshots_by_objsetid, se); + } +@@ -269,7 +269,7 @@ zfsctl_snapshot_find_by_name(char *snapname) + search.se_name = snapname; + se = avl_find(&zfs_snapshots_by_name, &search, NULL); + if (se) +- refcount_add(&se->se_refcount, NULL); ++ zfs_refcount_add(&se->se_refcount, NULL); + + return (se); + } +@@ -290,7 +290,7 @@ zfsctl_snapshot_find_by_objsetid(spa_t *spa, uint64_t objsetid) + search.se_objsetid = objsetid; + se = avl_find(&zfs_snapshots_by_objsetid, &search, NULL); + if (se) +- refcount_add(&se->se_refcount, NULL); ++ zfs_refcount_add(&se->se_refcount, NULL); + + return (se); + } +diff --git a/module/zfs/zfs_znode.c b/module/zfs/zfs_znode.c +index e222c791..0ca10f82 100644 +--- a/module/zfs/zfs_znode.c ++++ b/module/zfs/zfs_znode.c +@@ -272,7 +272,7 @@ zfs_znode_hold_enter(zfsvfs_t *zfsvfs, uint64_t obj) + ASSERT3U(zh->zh_obj, ==, obj); + found = B_TRUE; + } +- refcount_add(&zh->zh_refcount, NULL); ++ zfs_refcount_add(&zh->zh_refcount, NULL); + mutex_exit(&zfsvfs->z_hold_locks[i]); + + if (found == B_TRUE) diff --git a/zfs-patches/0014-Prefix-all-refcount-functions-with-zfs_.patch b/zfs-patches/0014-Prefix-all-refcount-functions-with-zfs_.patch new file mode 100644 index 0000000..55efcb8 --- /dev/null +++ b/zfs-patches/0014-Prefix-all-refcount-functions-with-zfs_.patch @@ -0,0 +1,2527 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Tim Schumacher +Date: Mon, 1 Oct 2018 19:42:05 +0200 +Subject: [PATCH] Prefix all refcount functions with zfs_ + +Recent changes in the Linux kernel made it necessary to prefix +the refcount_add() function with zfs_ due to a name collision. + +To bring the other functions in line with that and to avoid future +collisions, prefix the other refcount functions as well. + +Reviewed by: Matthew Ahrens +Reviewed-by: Brian Behlendorf +Signed-off-by: Tim Schumacher +Closes #7963 +--- + cmd/ztest/ztest.c | 10 +- + include/sys/refcount.h | 70 ++++++----- + include/sys/trace_dbuf.h | 2 +- + module/zfs/abd.c | 22 ++-- + module/zfs/arc.c | 301 ++++++++++++++++++++++++----------------------- + module/zfs/dbuf.c | 66 +++++------ + module/zfs/dbuf_stats.c | 4 +- + module/zfs/dmu_tx.c | 36 +++--- + module/zfs/dnode.c | 40 +++---- + module/zfs/dnode_sync.c | 6 +- + module/zfs/dsl_dataset.c | 12 +- + module/zfs/dsl_destroy.c | 6 +- + module/zfs/metaslab.c | 23 ++-- + module/zfs/refcount.c | 42 +++---- + module/zfs/rrwlock.c | 35 +++--- + module/zfs/sa.c | 8 +- + module/zfs/spa.c | 8 +- + module/zfs/spa_misc.c | 35 +++--- + module/zfs/zfs_ctldir.c | 6 +- + module/zfs/zfs_znode.c | 10 +- + module/zfs/zio.c | 4 +- + 21 files changed, 381 insertions(+), 365 deletions(-) + +diff --git a/cmd/ztest/ztest.c b/cmd/ztest/ztest.c +index 24967a76..5868d60a 100644 +--- a/cmd/ztest/ztest.c ++++ b/cmd/ztest/ztest.c +@@ -1205,7 +1205,7 @@ ztest_znode_init(uint64_t object) + ztest_znode_t *zp = umem_alloc(sizeof (*zp), UMEM_NOFAIL); + + list_link_init(&zp->z_lnode); +- refcount_create(&zp->z_refcnt); ++ zfs_refcount_create(&zp->z_refcnt); + zp->z_object = object; + zfs_rlock_init(&zp->z_range_lock); + +@@ -1215,10 +1215,10 @@ ztest_znode_init(uint64_t object) + static void + ztest_znode_fini(ztest_znode_t *zp) + { +- ASSERT(refcount_is_zero(&zp->z_refcnt)); ++ ASSERT(zfs_refcount_is_zero(&zp->z_refcnt)); + zfs_rlock_destroy(&zp->z_range_lock); + zp->z_object = 0; +- refcount_destroy(&zp->z_refcnt); ++ zfs_refcount_destroy(&zp->z_refcnt); + list_link_init(&zp->z_lnode); + umem_free(zp, sizeof (*zp)); + } +@@ -1268,8 +1268,8 @@ ztest_znode_put(ztest_ds_t *zd, ztest_znode_t *zp) + ASSERT3U(zp->z_object, !=, 0); + zll = &zd->zd_range_lock[zp->z_object & (ZTEST_OBJECT_LOCKS - 1)]; + mutex_enter(&zll->z_lock); +- refcount_remove(&zp->z_refcnt, RL_TAG); +- if (refcount_is_zero(&zp->z_refcnt)) { ++ zfs_refcount_remove(&zp->z_refcnt, RL_TAG); ++ if (zfs_refcount_is_zero(&zp->z_refcnt)) { + list_remove(&zll->z_list, zp); + ztest_znode_fini(zp); + } +diff --git a/include/sys/refcount.h b/include/sys/refcount.h +index 5c5198d8..7eeb1366 100644 +--- a/include/sys/refcount.h ++++ b/include/sys/refcount.h +@@ -63,26 +63,24 @@ typedef struct refcount { + * refcount_create[_untracked]() + */ + +-void refcount_create(zfs_refcount_t *rc); +-void refcount_create_untracked(zfs_refcount_t *rc); +-void refcount_create_tracked(zfs_refcount_t *rc); +-void refcount_destroy(zfs_refcount_t *rc); +-void refcount_destroy_many(zfs_refcount_t *rc, uint64_t number); +-int refcount_is_zero(zfs_refcount_t *rc); +-int64_t refcount_count(zfs_refcount_t *rc); +-int64_t zfs_refcount_add(zfs_refcount_t *rc, void *holder_tag); +-int64_t refcount_remove(zfs_refcount_t *rc, void *holder_tag); +-int64_t refcount_add_many(zfs_refcount_t *rc, uint64_t number, +- void *holder_tag); +-int64_t refcount_remove_many(zfs_refcount_t *rc, uint64_t number, +- void *holder_tag); +-void refcount_transfer(zfs_refcount_t *dst, zfs_refcount_t *src); +-void refcount_transfer_ownership(zfs_refcount_t *, void *, void *); +-boolean_t refcount_held(zfs_refcount_t *, void *); +-boolean_t refcount_not_held(zfs_refcount_t *, void *); +- +-void refcount_init(void); +-void refcount_fini(void); ++void zfs_refcount_create(zfs_refcount_t *); ++void zfs_refcount_create_untracked(zfs_refcount_t *); ++void zfs_refcount_create_tracked(zfs_refcount_t *); ++void zfs_refcount_destroy(zfs_refcount_t *); ++void zfs_refcount_destroy_many(zfs_refcount_t *, uint64_t); ++int zfs_refcount_is_zero(zfs_refcount_t *); ++int64_t zfs_refcount_count(zfs_refcount_t *); ++int64_t zfs_refcount_add(zfs_refcount_t *, void *); ++int64_t zfs_refcount_remove(zfs_refcount_t *, void *); ++int64_t zfs_refcount_add_many(zfs_refcount_t *, uint64_t, void *); ++int64_t zfs_refcount_remove_many(zfs_refcount_t *, uint64_t, void *); ++void zfs_refcount_transfer(zfs_refcount_t *, zfs_refcount_t *); ++void zfs_refcount_transfer_ownership(zfs_refcount_t *, void *, void *); ++boolean_t zfs_refcount_held(zfs_refcount_t *, void *); ++boolean_t zfs_refcount_not_held(zfs_refcount_t *, void *); ++ ++void zfs_refcount_init(void); ++void zfs_refcount_fini(void); + + #else /* ZFS_DEBUG */ + +@@ -90,30 +88,30 @@ typedef struct refcount { + uint64_t rc_count; + } zfs_refcount_t; + +-#define refcount_create(rc) ((rc)->rc_count = 0) +-#define refcount_create_untracked(rc) ((rc)->rc_count = 0) +-#define refcount_create_tracked(rc) ((rc)->rc_count = 0) +-#define refcount_destroy(rc) ((rc)->rc_count = 0) +-#define refcount_destroy_many(rc, number) ((rc)->rc_count = 0) +-#define refcount_is_zero(rc) ((rc)->rc_count == 0) +-#define refcount_count(rc) ((rc)->rc_count) ++#define zfs_refcount_create(rc) ((rc)->rc_count = 0) ++#define zfs_refcount_create_untracked(rc) ((rc)->rc_count = 0) ++#define zfs_refcount_create_tracked(rc) ((rc)->rc_count = 0) ++#define zfs_refcount_destroy(rc) ((rc)->rc_count = 0) ++#define zfs_refcount_destroy_many(rc, number) ((rc)->rc_count = 0) ++#define zfs_refcount_is_zero(rc) ((rc)->rc_count == 0) ++#define zfs_refcount_count(rc) ((rc)->rc_count) + #define zfs_refcount_add(rc, holder) atomic_inc_64_nv(&(rc)->rc_count) +-#define refcount_remove(rc, holder) atomic_dec_64_nv(&(rc)->rc_count) +-#define refcount_add_many(rc, number, holder) \ ++#define zfs_refcount_remove(rc, holder) atomic_dec_64_nv(&(rc)->rc_count) ++#define zfs_refcount_add_many(rc, number, holder) \ + atomic_add_64_nv(&(rc)->rc_count, number) +-#define refcount_remove_many(rc, number, holder) \ ++#define zfs_refcount_remove_many(rc, number, holder) \ + atomic_add_64_nv(&(rc)->rc_count, -number) +-#define refcount_transfer(dst, src) { \ ++#define zfs_refcount_transfer(dst, src) { \ + uint64_t __tmp = (src)->rc_count; \ + atomic_add_64(&(src)->rc_count, -__tmp); \ + atomic_add_64(&(dst)->rc_count, __tmp); \ + } +-#define refcount_transfer_ownership(rc, current_holder, new_holder) (void)0 +-#define refcount_held(rc, holder) ((rc)->rc_count > 0) +-#define refcount_not_held(rc, holder) (B_TRUE) ++#define zfs_refcount_transfer_ownership(rc, current_holder, new_holder) (void)0 ++#define zfs_refcount_held(rc, holder) ((rc)->rc_count > 0) ++#define zfs_refcount_not_held(rc, holder) (B_TRUE) + +-#define refcount_init() +-#define refcount_fini() ++#define zfs_refcount_init() ++#define zfs_refcount_fini() + + #endif /* ZFS_DEBUG */ + +diff --git a/include/sys/trace_dbuf.h b/include/sys/trace_dbuf.h +index c3e70c37..e97b6113 100644 +--- a/include/sys/trace_dbuf.h ++++ b/include/sys/trace_dbuf.h +@@ -71,7 +71,7 @@ + __entry->db_offset = db->db.db_offset; \ + __entry->db_size = db->db.db_size; \ + __entry->db_state = db->db_state; \ +- __entry->db_holds = refcount_count(&db->db_holds); \ ++ __entry->db_holds = zfs_refcount_count(&db->db_holds); \ + snprintf(__get_str(msg), TRACE_DBUF_MSG_MAX, \ + DBUF_TP_PRINTK_FMT, DBUF_TP_PRINTK_ARGS); \ + } else { \ +diff --git a/module/zfs/abd.c b/module/zfs/abd.c +index 138b041c..5a6a8158 100644 +--- a/module/zfs/abd.c ++++ b/module/zfs/abd.c +@@ -597,7 +597,7 @@ abd_alloc(size_t size, boolean_t is_metadata) + } + abd->abd_size = size; + abd->abd_parent = NULL; +- refcount_create(&abd->abd_children); ++ zfs_refcount_create(&abd->abd_children); + + abd->abd_u.abd_scatter.abd_offset = 0; + +@@ -614,7 +614,7 @@ abd_free_scatter(abd_t *abd) + { + abd_free_pages(abd); + +- refcount_destroy(&abd->abd_children); ++ zfs_refcount_destroy(&abd->abd_children); + ABDSTAT_BUMPDOWN(abdstat_scatter_cnt); + ABDSTAT_INCR(abdstat_scatter_data_size, -(int)abd->abd_size); + ABDSTAT_INCR(abdstat_scatter_chunk_waste, +@@ -641,7 +641,7 @@ abd_alloc_linear(size_t size, boolean_t is_metadata) + } + abd->abd_size = size; + abd->abd_parent = NULL; +- refcount_create(&abd->abd_children); ++ zfs_refcount_create(&abd->abd_children); + + if (is_metadata) { + abd->abd_u.abd_linear.abd_buf = zio_buf_alloc(size); +@@ -664,7 +664,7 @@ abd_free_linear(abd_t *abd) + zio_data_buf_free(abd->abd_u.abd_linear.abd_buf, abd->abd_size); + } + +- refcount_destroy(&abd->abd_children); ++ zfs_refcount_destroy(&abd->abd_children); + ABDSTAT_BUMPDOWN(abdstat_linear_cnt); + ABDSTAT_INCR(abdstat_linear_data_size, -(int)abd->abd_size); + +@@ -775,8 +775,8 @@ abd_get_offset_impl(abd_t *sabd, size_t off, size_t size) + + abd->abd_size = size; + abd->abd_parent = sabd; +- refcount_create(&abd->abd_children); +- (void) refcount_add_many(&sabd->abd_children, abd->abd_size, abd); ++ zfs_refcount_create(&abd->abd_children); ++ (void) zfs_refcount_add_many(&sabd->abd_children, abd->abd_size, abd); + + return (abd); + } +@@ -818,7 +818,7 @@ abd_get_from_buf(void *buf, size_t size) + abd->abd_flags = ABD_FLAG_LINEAR; + abd->abd_size = size; + abd->abd_parent = NULL; +- refcount_create(&abd->abd_children); ++ zfs_refcount_create(&abd->abd_children); + + abd->abd_u.abd_linear.abd_buf = buf; + +@@ -836,11 +836,11 @@ abd_put(abd_t *abd) + ASSERT(!(abd->abd_flags & ABD_FLAG_OWNER)); + + if (abd->abd_parent != NULL) { +- (void) refcount_remove_many(&abd->abd_parent->abd_children, ++ (void) zfs_refcount_remove_many(&abd->abd_parent->abd_children, + abd->abd_size, abd); + } + +- refcount_destroy(&abd->abd_children); ++ zfs_refcount_destroy(&abd->abd_children); + abd_free_struct(abd); + } + +@@ -872,7 +872,7 @@ abd_borrow_buf(abd_t *abd, size_t n) + } else { + buf = zio_buf_alloc(n); + } +- (void) refcount_add_many(&abd->abd_children, n, buf); ++ (void) zfs_refcount_add_many(&abd->abd_children, n, buf); + + return (buf); + } +@@ -904,7 +904,7 @@ abd_return_buf(abd_t *abd, void *buf, size_t n) + ASSERT0(abd_cmp_buf(abd, buf, n)); + zio_buf_free(buf, n); + } +- (void) refcount_remove_many(&abd->abd_children, n, buf); ++ (void) zfs_refcount_remove_many(&abd->abd_children, n, buf); + } + + void +diff --git a/module/zfs/arc.c b/module/zfs/arc.c +index 7518d5c8..32ac0837 100644 +--- a/module/zfs/arc.c ++++ b/module/zfs/arc.c +@@ -1181,7 +1181,7 @@ hdr_full_cons(void *vbuf, void *unused, int kmflag) + + bzero(hdr, HDR_FULL_SIZE); + cv_init(&hdr->b_l1hdr.b_cv, NULL, CV_DEFAULT, NULL); +- refcount_create(&hdr->b_l1hdr.b_refcnt); ++ zfs_refcount_create(&hdr->b_l1hdr.b_refcnt); + mutex_init(&hdr->b_l1hdr.b_freeze_lock, NULL, MUTEX_DEFAULT, NULL); + list_link_init(&hdr->b_l1hdr.b_arc_node); + list_link_init(&hdr->b_l2hdr.b_l2node); +@@ -1228,7 +1228,7 @@ hdr_full_dest(void *vbuf, void *unused) + + ASSERT(HDR_EMPTY(hdr)); + cv_destroy(&hdr->b_l1hdr.b_cv); +- refcount_destroy(&hdr->b_l1hdr.b_refcnt); ++ zfs_refcount_destroy(&hdr->b_l1hdr.b_refcnt); + mutex_destroy(&hdr->b_l1hdr.b_freeze_lock); + ASSERT(!multilist_link_active(&hdr->b_l1hdr.b_arc_node)); + arc_space_return(HDR_FULL_SIZE, ARC_SPACE_HDRS); +@@ -1893,20 +1893,20 @@ arc_evictable_space_increment(arc_buf_hdr_t *hdr, arc_state_t *state) + ASSERT0(hdr->b_l1hdr.b_bufcnt); + ASSERT3P(hdr->b_l1hdr.b_buf, ==, NULL); + ASSERT3P(hdr->b_l1hdr.b_pabd, ==, NULL); +- (void) refcount_add_many(&state->arcs_esize[type], ++ (void) zfs_refcount_add_many(&state->arcs_esize[type], + HDR_GET_LSIZE(hdr), hdr); + return; + } + + ASSERT(!GHOST_STATE(state)); + if (hdr->b_l1hdr.b_pabd != NULL) { +- (void) refcount_add_many(&state->arcs_esize[type], ++ (void) zfs_refcount_add_many(&state->arcs_esize[type], + arc_hdr_size(hdr), hdr); + } + for (buf = hdr->b_l1hdr.b_buf; buf != NULL; buf = buf->b_next) { + if (arc_buf_is_shared(buf)) + continue; +- (void) refcount_add_many(&state->arcs_esize[type], ++ (void) zfs_refcount_add_many(&state->arcs_esize[type], + arc_buf_size(buf), buf); + } + } +@@ -1928,20 +1928,20 @@ arc_evictable_space_decrement(arc_buf_hdr_t *hdr, arc_state_t *state) + ASSERT0(hdr->b_l1hdr.b_bufcnt); + ASSERT3P(hdr->b_l1hdr.b_buf, ==, NULL); + ASSERT3P(hdr->b_l1hdr.b_pabd, ==, NULL); +- (void) refcount_remove_many(&state->arcs_esize[type], ++ (void) zfs_refcount_remove_many(&state->arcs_esize[type], + HDR_GET_LSIZE(hdr), hdr); + return; + } + + ASSERT(!GHOST_STATE(state)); + if (hdr->b_l1hdr.b_pabd != NULL) { +- (void) refcount_remove_many(&state->arcs_esize[type], ++ (void) zfs_refcount_remove_many(&state->arcs_esize[type], + arc_hdr_size(hdr), hdr); + } + for (buf = hdr->b_l1hdr.b_buf; buf != NULL; buf = buf->b_next) { + if (arc_buf_is_shared(buf)) + continue; +- (void) refcount_remove_many(&state->arcs_esize[type], ++ (void) zfs_refcount_remove_many(&state->arcs_esize[type], + arc_buf_size(buf), buf); + } + } +@@ -1960,7 +1960,7 @@ add_reference(arc_buf_hdr_t *hdr, void *tag) + ASSERT(HDR_HAS_L1HDR(hdr)); + if (!MUTEX_HELD(HDR_LOCK(hdr))) { + ASSERT(hdr->b_l1hdr.b_state == arc_anon); +- ASSERT(refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); ++ ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); + ASSERT3P(hdr->b_l1hdr.b_buf, ==, NULL); + } + +@@ -1998,7 +1998,7 @@ remove_reference(arc_buf_hdr_t *hdr, kmutex_t *hash_lock, void *tag) + * arc_l2c_only counts as a ghost state so we don't need to explicitly + * check to prevent usage of the arc_l2c_only list. + */ +- if (((cnt = refcount_remove(&hdr->b_l1hdr.b_refcnt, tag)) == 0) && ++ if (((cnt = zfs_refcount_remove(&hdr->b_l1hdr.b_refcnt, tag)) == 0) && + (state != arc_anon)) { + multilist_insert(state->arcs_list[arc_buf_type(hdr)], hdr); + ASSERT3U(hdr->b_l1hdr.b_bufcnt, >, 0); +@@ -2043,7 +2043,7 @@ arc_buf_info(arc_buf_t *ab, arc_buf_info_t *abi, int state_index) + abi->abi_mru_ghost_hits = l1hdr->b_mru_ghost_hits; + abi->abi_mfu_hits = l1hdr->b_mfu_hits; + abi->abi_mfu_ghost_hits = l1hdr->b_mfu_ghost_hits; +- abi->abi_holds = refcount_count(&l1hdr->b_refcnt); ++ abi->abi_holds = zfs_refcount_count(&l1hdr->b_refcnt); + } + + if (l2hdr) { +@@ -2079,7 +2079,7 @@ arc_change_state(arc_state_t *new_state, arc_buf_hdr_t *hdr, + */ + if (HDR_HAS_L1HDR(hdr)) { + old_state = hdr->b_l1hdr.b_state; +- refcnt = refcount_count(&hdr->b_l1hdr.b_refcnt); ++ refcnt = zfs_refcount_count(&hdr->b_l1hdr.b_refcnt); + bufcnt = hdr->b_l1hdr.b_bufcnt; + update_old = (bufcnt > 0 || hdr->b_l1hdr.b_pabd != NULL); + } else { +@@ -2148,7 +2148,7 @@ arc_change_state(arc_state_t *new_state, arc_buf_hdr_t *hdr, + * the reference. As a result, we use the arc + * header pointer for the reference. + */ +- (void) refcount_add_many(&new_state->arcs_size, ++ (void) zfs_refcount_add_many(&new_state->arcs_size, + HDR_GET_LSIZE(hdr), hdr); + ASSERT3P(hdr->b_l1hdr.b_pabd, ==, NULL); + } else { +@@ -2175,13 +2175,15 @@ arc_change_state(arc_state_t *new_state, arc_buf_hdr_t *hdr, + if (arc_buf_is_shared(buf)) + continue; + +- (void) refcount_add_many(&new_state->arcs_size, ++ (void) zfs_refcount_add_many( ++ &new_state->arcs_size, + arc_buf_size(buf), buf); + } + ASSERT3U(bufcnt, ==, buffers); + + if (hdr->b_l1hdr.b_pabd != NULL) { +- (void) refcount_add_many(&new_state->arcs_size, ++ (void) zfs_refcount_add_many( ++ &new_state->arcs_size, + arc_hdr_size(hdr), hdr); + } else { + ASSERT(GHOST_STATE(old_state)); +@@ -2203,7 +2205,7 @@ arc_change_state(arc_state_t *new_state, arc_buf_hdr_t *hdr, + * header on the ghost state. + */ + +- (void) refcount_remove_many(&old_state->arcs_size, ++ (void) zfs_refcount_remove_many(&old_state->arcs_size, + HDR_GET_LSIZE(hdr), hdr); + } else { + arc_buf_t *buf; +@@ -2229,13 +2231,13 @@ arc_change_state(arc_state_t *new_state, arc_buf_hdr_t *hdr, + if (arc_buf_is_shared(buf)) + continue; + +- (void) refcount_remove_many( ++ (void) zfs_refcount_remove_many( + &old_state->arcs_size, arc_buf_size(buf), + buf); + } + ASSERT3U(bufcnt, ==, buffers); + ASSERT3P(hdr->b_l1hdr.b_pabd, !=, NULL); +- (void) refcount_remove_many( ++ (void) zfs_refcount_remove_many( + &old_state->arcs_size, arc_hdr_size(hdr), hdr); + } + } +@@ -2506,7 +2508,7 @@ arc_return_buf(arc_buf_t *buf, void *tag) + ASSERT3P(buf->b_data, !=, NULL); + ASSERT(HDR_HAS_L1HDR(hdr)); + (void) zfs_refcount_add(&hdr->b_l1hdr.b_refcnt, tag); +- (void) refcount_remove(&hdr->b_l1hdr.b_refcnt, arc_onloan_tag); ++ (void) zfs_refcount_remove(&hdr->b_l1hdr.b_refcnt, arc_onloan_tag); + + arc_loaned_bytes_update(-arc_buf_size(buf)); + } +@@ -2520,7 +2522,7 @@ arc_loan_inuse_buf(arc_buf_t *buf, void *tag) + ASSERT3P(buf->b_data, !=, NULL); + ASSERT(HDR_HAS_L1HDR(hdr)); + (void) zfs_refcount_add(&hdr->b_l1hdr.b_refcnt, arc_onloan_tag); +- (void) refcount_remove(&hdr->b_l1hdr.b_refcnt, tag); ++ (void) zfs_refcount_remove(&hdr->b_l1hdr.b_refcnt, tag); + + arc_loaned_bytes_update(arc_buf_size(buf)); + } +@@ -2547,13 +2549,13 @@ arc_hdr_free_on_write(arc_buf_hdr_t *hdr) + + /* protected by hash lock, if in the hash table */ + if (multilist_link_active(&hdr->b_l1hdr.b_arc_node)) { +- ASSERT(refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); ++ ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); + ASSERT(state != arc_anon && state != arc_l2c_only); + +- (void) refcount_remove_many(&state->arcs_esize[type], ++ (void) zfs_refcount_remove_many(&state->arcs_esize[type], + size, hdr); + } +- (void) refcount_remove_many(&state->arcs_size, size, hdr); ++ (void) zfs_refcount_remove_many(&state->arcs_size, size, hdr); + if (type == ARC_BUFC_METADATA) { + arc_space_return(size, ARC_SPACE_META); + } else { +@@ -2581,7 +2583,8 @@ arc_share_buf(arc_buf_hdr_t *hdr, arc_buf_t *buf) + * refcount ownership to the hdr since it always owns + * the refcount whenever an arc_buf_t is shared. + */ +- refcount_transfer_ownership(&hdr->b_l1hdr.b_state->arcs_size, buf, hdr); ++ zfs_refcount_transfer_ownership(&hdr->b_l1hdr.b_state->arcs_size, buf, ++ hdr); + hdr->b_l1hdr.b_pabd = abd_get_from_buf(buf->b_data, arc_buf_size(buf)); + abd_take_ownership_of_buf(hdr->b_l1hdr.b_pabd, + HDR_ISTYPE_METADATA(hdr)); +@@ -2609,7 +2612,8 @@ arc_unshare_buf(arc_buf_hdr_t *hdr, arc_buf_t *buf) + * We are no longer sharing this buffer so we need + * to transfer its ownership to the rightful owner. + */ +- refcount_transfer_ownership(&hdr->b_l1hdr.b_state->arcs_size, hdr, buf); ++ zfs_refcount_transfer_ownership(&hdr->b_l1hdr.b_state->arcs_size, hdr, ++ buf); + arc_hdr_clear_flags(hdr, ARC_FLAG_SHARED_DATA); + abd_release_ownership_of_buf(hdr->b_l1hdr.b_pabd); + abd_put(hdr->b_l1hdr.b_pabd); +@@ -2833,7 +2837,7 @@ arc_hdr_alloc(uint64_t spa, int32_t psize, int32_t lsize, + * it references and compressed arc enablement. + */ + arc_hdr_alloc_pabd(hdr); +- ASSERT(refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); ++ ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); + + return (hdr); + } +@@ -2927,8 +2931,10 @@ arc_hdr_realloc(arc_buf_hdr_t *hdr, kmem_cache_t *old, kmem_cache_t *new) + * the wrong pointer address when calling arc_hdr_destroy() later. + */ + +- (void) refcount_remove_many(&dev->l2ad_alloc, arc_hdr_size(hdr), hdr); +- (void) refcount_add_many(&dev->l2ad_alloc, arc_hdr_size(nhdr), nhdr); ++ (void) zfs_refcount_remove_many(&dev->l2ad_alloc, arc_hdr_size(hdr), ++ hdr); ++ (void) zfs_refcount_add_many(&dev->l2ad_alloc, arc_hdr_size(nhdr), ++ nhdr); + + buf_discard_identity(hdr); + kmem_cache_free(old, hdr); +@@ -3008,7 +3014,7 @@ arc_hdr_l2hdr_destroy(arc_buf_hdr_t *hdr) + + vdev_space_update(dev->l2ad_vdev, -psize, 0, 0); + +- (void) refcount_remove_many(&dev->l2ad_alloc, psize, hdr); ++ (void) zfs_refcount_remove_many(&dev->l2ad_alloc, psize, hdr); + arc_hdr_clear_flags(hdr, ARC_FLAG_HAS_L2HDR); + } + +@@ -3018,7 +3024,7 @@ arc_hdr_destroy(arc_buf_hdr_t *hdr) + if (HDR_HAS_L1HDR(hdr)) { + ASSERT(hdr->b_l1hdr.b_buf == NULL || + hdr->b_l1hdr.b_bufcnt > 0); +- ASSERT(refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); ++ ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); + ASSERT3P(hdr->b_l1hdr.b_state, ==, arc_anon); + } + ASSERT(!HDR_IO_IN_PROGRESS(hdr)); +@@ -3171,7 +3177,7 @@ arc_evict_hdr(arc_buf_hdr_t *hdr, kmutex_t *hash_lock) + return (bytes_evicted); + } + +- ASSERT0(refcount_count(&hdr->b_l1hdr.b_refcnt)); ++ ASSERT0(zfs_refcount_count(&hdr->b_l1hdr.b_refcnt)); + while (hdr->b_l1hdr.b_buf) { + arc_buf_t *buf = hdr->b_l1hdr.b_buf; + if (!mutex_tryenter(&buf->b_evict_lock)) { +@@ -3484,7 +3490,7 @@ arc_flush_state(arc_state_t *state, uint64_t spa, arc_buf_contents_t type, + { + uint64_t evicted = 0; + +- while (refcount_count(&state->arcs_esize[type]) != 0) { ++ while (zfs_refcount_count(&state->arcs_esize[type]) != 0) { + evicted += arc_evict_state(state, spa, ARC_EVICT_ALL, type); + + if (!retry) +@@ -3507,7 +3513,7 @@ arc_prune_task(void *ptr) + if (func != NULL) + func(ap->p_adjust, ap->p_private); + +- refcount_remove(&ap->p_refcnt, func); ++ zfs_refcount_remove(&ap->p_refcnt, func); + } + + /* +@@ -3530,14 +3536,14 @@ arc_prune_async(int64_t adjust) + for (ap = list_head(&arc_prune_list); ap != NULL; + ap = list_next(&arc_prune_list, ap)) { + +- if (refcount_count(&ap->p_refcnt) >= 2) ++ if (zfs_refcount_count(&ap->p_refcnt) >= 2) + continue; + + zfs_refcount_add(&ap->p_refcnt, ap->p_pfunc); + ap->p_adjust = adjust; + if (taskq_dispatch(arc_prune_taskq, arc_prune_task, + ap, TQ_SLEEP) == TASKQID_INVALID) { +- refcount_remove(&ap->p_refcnt, ap->p_pfunc); ++ zfs_refcount_remove(&ap->p_refcnt, ap->p_pfunc); + continue; + } + ARCSTAT_BUMP(arcstat_prune); +@@ -3559,8 +3565,9 @@ arc_adjust_impl(arc_state_t *state, uint64_t spa, int64_t bytes, + { + int64_t delta; + +- if (bytes > 0 && refcount_count(&state->arcs_esize[type]) > 0) { +- delta = MIN(refcount_count(&state->arcs_esize[type]), bytes); ++ if (bytes > 0 && zfs_refcount_count(&state->arcs_esize[type]) > 0) { ++ delta = MIN(zfs_refcount_count(&state->arcs_esize[type]), ++ bytes); + return (arc_evict_state(state, spa, delta, type)); + } + +@@ -3603,8 +3610,9 @@ restart: + */ + adjustmnt = arc_meta_used - arc_meta_limit; + +- if (adjustmnt > 0 && refcount_count(&arc_mru->arcs_esize[type]) > 0) { +- delta = MIN(refcount_count(&arc_mru->arcs_esize[type]), ++ if (adjustmnt > 0 && ++ zfs_refcount_count(&arc_mru->arcs_esize[type]) > 0) { ++ delta = MIN(zfs_refcount_count(&arc_mru->arcs_esize[type]), + adjustmnt); + total_evicted += arc_adjust_impl(arc_mru, 0, delta, type); + adjustmnt -= delta; +@@ -3620,8 +3628,9 @@ restart: + * simply decrement the amount of data evicted from the MRU. + */ + +- if (adjustmnt > 0 && refcount_count(&arc_mfu->arcs_esize[type]) > 0) { +- delta = MIN(refcount_count(&arc_mfu->arcs_esize[type]), ++ if (adjustmnt > 0 && ++ zfs_refcount_count(&arc_mfu->arcs_esize[type]) > 0) { ++ delta = MIN(zfs_refcount_count(&arc_mfu->arcs_esize[type]), + adjustmnt); + total_evicted += arc_adjust_impl(arc_mfu, 0, delta, type); + } +@@ -3629,17 +3638,17 @@ restart: + adjustmnt = arc_meta_used - arc_meta_limit; + + if (adjustmnt > 0 && +- refcount_count(&arc_mru_ghost->arcs_esize[type]) > 0) { ++ zfs_refcount_count(&arc_mru_ghost->arcs_esize[type]) > 0) { + delta = MIN(adjustmnt, +- refcount_count(&arc_mru_ghost->arcs_esize[type])); ++ zfs_refcount_count(&arc_mru_ghost->arcs_esize[type])); + total_evicted += arc_adjust_impl(arc_mru_ghost, 0, delta, type); + adjustmnt -= delta; + } + + if (adjustmnt > 0 && +- refcount_count(&arc_mfu_ghost->arcs_esize[type]) > 0) { ++ zfs_refcount_count(&arc_mfu_ghost->arcs_esize[type]) > 0) { + delta = MIN(adjustmnt, +- refcount_count(&arc_mfu_ghost->arcs_esize[type])); ++ zfs_refcount_count(&arc_mfu_ghost->arcs_esize[type])); + total_evicted += arc_adjust_impl(arc_mfu_ghost, 0, delta, type); + } + +@@ -3688,8 +3697,8 @@ arc_adjust_meta_only(void) + * evict some from the MRU here, and some from the MFU below. + */ + target = MIN((int64_t)(arc_meta_used - arc_meta_limit), +- (int64_t)(refcount_count(&arc_anon->arcs_size) + +- refcount_count(&arc_mru->arcs_size) - arc_p)); ++ (int64_t)(zfs_refcount_count(&arc_anon->arcs_size) + ++ zfs_refcount_count(&arc_mru->arcs_size) - arc_p)); + + total_evicted += arc_adjust_impl(arc_mru, 0, target, ARC_BUFC_METADATA); + +@@ -3699,7 +3708,8 @@ arc_adjust_meta_only(void) + * space allotted to the MFU (which is defined as arc_c - arc_p). + */ + target = MIN((int64_t)(arc_meta_used - arc_meta_limit), +- (int64_t)(refcount_count(&arc_mfu->arcs_size) - (arc_c - arc_p))); ++ (int64_t)(zfs_refcount_count(&arc_mfu->arcs_size) - (arc_c - ++ arc_p))); + + total_evicted += arc_adjust_impl(arc_mfu, 0, target, ARC_BUFC_METADATA); + +@@ -3817,8 +3827,8 @@ arc_adjust(void) + * arc_p here, and then evict more from the MFU below. + */ + target = MIN((int64_t)(arc_size - arc_c), +- (int64_t)(refcount_count(&arc_anon->arcs_size) + +- refcount_count(&arc_mru->arcs_size) + arc_meta_used - arc_p)); ++ (int64_t)(zfs_refcount_count(&arc_anon->arcs_size) + ++ zfs_refcount_count(&arc_mru->arcs_size) + arc_meta_used - arc_p)); + + /* + * If we're below arc_meta_min, always prefer to evict data. +@@ -3902,8 +3912,8 @@ arc_adjust(void) + * cache. The following logic enforces these limits on the ghost + * caches, and evicts from them as needed. + */ +- target = refcount_count(&arc_mru->arcs_size) + +- refcount_count(&arc_mru_ghost->arcs_size) - arc_c; ++ target = zfs_refcount_count(&arc_mru->arcs_size) + ++ zfs_refcount_count(&arc_mru_ghost->arcs_size) - arc_c; + + bytes = arc_adjust_impl(arc_mru_ghost, 0, target, ARC_BUFC_DATA); + total_evicted += bytes; +@@ -3921,8 +3931,8 @@ arc_adjust(void) + * mru + mfu + mru ghost + mfu ghost <= 2 * arc_c + * mru ghost + mfu ghost <= arc_c + */ +- target = refcount_count(&arc_mru_ghost->arcs_size) + +- refcount_count(&arc_mfu_ghost->arcs_size) - arc_c; ++ target = zfs_refcount_count(&arc_mru_ghost->arcs_size) + ++ zfs_refcount_count(&arc_mfu_ghost->arcs_size) - arc_c; + + bytes = arc_adjust_impl(arc_mfu_ghost, 0, target, ARC_BUFC_DATA); + total_evicted += bytes; +@@ -4422,10 +4432,10 @@ static uint64_t + arc_evictable_memory(void) + { + uint64_t arc_clean = +- refcount_count(&arc_mru->arcs_esize[ARC_BUFC_DATA]) + +- refcount_count(&arc_mru->arcs_esize[ARC_BUFC_METADATA]) + +- refcount_count(&arc_mfu->arcs_esize[ARC_BUFC_DATA]) + +- refcount_count(&arc_mfu->arcs_esize[ARC_BUFC_METADATA]); ++ zfs_refcount_count(&arc_mru->arcs_esize[ARC_BUFC_DATA]) + ++ zfs_refcount_count(&arc_mru->arcs_esize[ARC_BUFC_METADATA]) + ++ zfs_refcount_count(&arc_mfu->arcs_esize[ARC_BUFC_DATA]) + ++ zfs_refcount_count(&arc_mfu->arcs_esize[ARC_BUFC_METADATA]); + uint64_t arc_dirty = MAX((int64_t)arc_size - (int64_t)arc_clean, 0); + + /* +@@ -4532,8 +4542,8 @@ arc_adapt(int bytes, arc_state_t *state) + { + int mult; + uint64_t arc_p_min = (arc_c >> arc_p_min_shift); +- int64_t mrug_size = refcount_count(&arc_mru_ghost->arcs_size); +- int64_t mfug_size = refcount_count(&arc_mfu_ghost->arcs_size); ++ int64_t mrug_size = zfs_refcount_count(&arc_mru_ghost->arcs_size); ++ int64_t mfug_size = zfs_refcount_count(&arc_mfu_ghost->arcs_size); + + if (state == arc_l2c_only) + return; +@@ -4698,7 +4708,7 @@ arc_get_data_impl(arc_buf_hdr_t *hdr, uint64_t size, void *tag) + */ + if (!GHOST_STATE(state)) { + +- (void) refcount_add_many(&state->arcs_size, size, tag); ++ (void) zfs_refcount_add_many(&state->arcs_size, size, tag); + + /* + * If this is reached via arc_read, the link is +@@ -4710,8 +4720,8 @@ arc_get_data_impl(arc_buf_hdr_t *hdr, uint64_t size, void *tag) + * trying to [add|remove]_reference it. + */ + if (multilist_link_active(&hdr->b_l1hdr.b_arc_node)) { +- ASSERT(refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); +- (void) refcount_add_many(&state->arcs_esize[type], ++ ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); ++ (void) zfs_refcount_add_many(&state->arcs_esize[type], + size, tag); + } + +@@ -4720,8 +4730,8 @@ arc_get_data_impl(arc_buf_hdr_t *hdr, uint64_t size, void *tag) + * data, and we have outgrown arc_p, update arc_p + */ + if (arc_size < arc_c && hdr->b_l1hdr.b_state == arc_anon && +- (refcount_count(&arc_anon->arcs_size) + +- refcount_count(&arc_mru->arcs_size) > arc_p)) ++ (zfs_refcount_count(&arc_anon->arcs_size) + ++ zfs_refcount_count(&arc_mru->arcs_size) > arc_p)) + arc_p = MIN(arc_c, arc_p + size); + } + } +@@ -4758,13 +4768,13 @@ arc_free_data_impl(arc_buf_hdr_t *hdr, uint64_t size, void *tag) + + /* protected by hash lock, if in the hash table */ + if (multilist_link_active(&hdr->b_l1hdr.b_arc_node)) { +- ASSERT(refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); ++ ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); + ASSERT(state != arc_anon && state != arc_l2c_only); + +- (void) refcount_remove_many(&state->arcs_esize[type], ++ (void) zfs_refcount_remove_many(&state->arcs_esize[type], + size, tag); + } +- (void) refcount_remove_many(&state->arcs_size, size, tag); ++ (void) zfs_refcount_remove_many(&state->arcs_size, size, tag); + + VERIFY3U(hdr->b_type, ==, type); + if (type == ARC_BUFC_METADATA) { +@@ -4811,7 +4821,7 @@ arc_access(arc_buf_hdr_t *hdr, kmutex_t *hash_lock) + * another prefetch (to make it less likely to be evicted). + */ + if (HDR_PREFETCH(hdr)) { +- if (refcount_count(&hdr->b_l1hdr.b_refcnt) == 0) { ++ if (zfs_refcount_count(&hdr->b_l1hdr.b_refcnt) == 0) { + /* link protected by hash lock */ + ASSERT(multilist_link_active( + &hdr->b_l1hdr.b_arc_node)); +@@ -4852,7 +4862,7 @@ arc_access(arc_buf_hdr_t *hdr, kmutex_t *hash_lock) + + if (HDR_PREFETCH(hdr)) { + new_state = arc_mru; +- if (refcount_count(&hdr->b_l1hdr.b_refcnt) > 0) ++ if (zfs_refcount_count(&hdr->b_l1hdr.b_refcnt) > 0) + arc_hdr_clear_flags(hdr, ARC_FLAG_PREFETCH); + DTRACE_PROBE1(new_state__mru, arc_buf_hdr_t *, hdr); + } else { +@@ -4876,7 +4886,7 @@ arc_access(arc_buf_hdr_t *hdr, kmutex_t *hash_lock) + * the head of the list now. + */ + if ((HDR_PREFETCH(hdr)) != 0) { +- ASSERT(refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); ++ ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); + /* link protected by hash_lock */ + ASSERT(multilist_link_active(&hdr->b_l1hdr.b_arc_node)); + } +@@ -4896,7 +4906,7 @@ arc_access(arc_buf_hdr_t *hdr, kmutex_t *hash_lock) + * This is a prefetch access... + * move this block back to the MRU state. + */ +- ASSERT0(refcount_count(&hdr->b_l1hdr.b_refcnt)); ++ ASSERT0(zfs_refcount_count(&hdr->b_l1hdr.b_refcnt)); + new_state = arc_mru; + } + +@@ -5098,7 +5108,7 @@ arc_read_done(zio_t *zio) + ASSERT3P(hdr->b_l1hdr.b_pabd, !=, NULL); + } + +- ASSERT(refcount_is_zero(&hdr->b_l1hdr.b_refcnt) || ++ ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt) || + callback_list != NULL); + + if (no_zio_error) { +@@ -5109,7 +5119,7 @@ arc_read_done(zio_t *zio) + arc_change_state(arc_anon, hdr, hash_lock); + if (HDR_IN_HASH_TABLE(hdr)) + buf_hash_remove(hdr); +- freeable = refcount_is_zero(&hdr->b_l1hdr.b_refcnt); ++ freeable = zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt); + } + + /* +@@ -5129,7 +5139,7 @@ arc_read_done(zio_t *zio) + * in the cache). + */ + ASSERT3P(hdr->b_l1hdr.b_state, ==, arc_anon); +- freeable = refcount_is_zero(&hdr->b_l1hdr.b_refcnt); ++ freeable = zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt); + } + + /* execute each callback and free its structure */ +@@ -5282,7 +5292,7 @@ top: + VERIFY0(arc_buf_alloc_impl(hdr, private, + compressed_read, B_TRUE, &buf)); + } else if (*arc_flags & ARC_FLAG_PREFETCH && +- refcount_count(&hdr->b_l1hdr.b_refcnt) == 0) { ++ zfs_refcount_count(&hdr->b_l1hdr.b_refcnt) == 0) { + arc_hdr_set_flags(hdr, ARC_FLAG_PREFETCH); + } + DTRACE_PROBE1(arc__hit, arc_buf_hdr_t *, hdr); +@@ -5348,7 +5358,7 @@ top: + ASSERT3P(hdr->b_l1hdr.b_pabd, ==, NULL); + ASSERT(GHOST_STATE(hdr->b_l1hdr.b_state)); + ASSERT(!HDR_IO_IN_PROGRESS(hdr)); +- ASSERT(refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); ++ ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); + ASSERT3P(hdr->b_l1hdr.b_buf, ==, NULL); + ASSERT3P(hdr->b_l1hdr.b_freeze_cksum, ==, NULL); + +@@ -5546,7 +5556,7 @@ arc_add_prune_callback(arc_prune_func_t *func, void *private) + p->p_pfunc = func; + p->p_private = private; + list_link_init(&p->p_node); +- refcount_create(&p->p_refcnt); ++ zfs_refcount_create(&p->p_refcnt); + + mutex_enter(&arc_prune_mtx); + zfs_refcount_add(&p->p_refcnt, &arc_prune_list); +@@ -5562,15 +5572,15 @@ arc_remove_prune_callback(arc_prune_t *p) + boolean_t wait = B_FALSE; + mutex_enter(&arc_prune_mtx); + list_remove(&arc_prune_list, p); +- if (refcount_remove(&p->p_refcnt, &arc_prune_list) > 0) ++ if (zfs_refcount_remove(&p->p_refcnt, &arc_prune_list) > 0) + wait = B_TRUE; + mutex_exit(&arc_prune_mtx); + + /* wait for arc_prune_task to finish */ + if (wait) + taskq_wait_outstanding(arc_prune_taskq, 0); +- ASSERT0(refcount_count(&p->p_refcnt)); +- refcount_destroy(&p->p_refcnt); ++ ASSERT0(zfs_refcount_count(&p->p_refcnt)); ++ zfs_refcount_destroy(&p->p_refcnt); + kmem_free(p, sizeof (*p)); + } + +@@ -5613,7 +5623,7 @@ arc_freed(spa_t *spa, const blkptr_t *bp) + * this hdr, then we don't destroy the hdr. + */ + if (!HDR_HAS_L1HDR(hdr) || (!HDR_IO_IN_PROGRESS(hdr) && +- refcount_is_zero(&hdr->b_l1hdr.b_refcnt))) { ++ zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt))) { + arc_change_state(arc_anon, hdr, hash_lock); + arc_hdr_destroy(hdr); + mutex_exit(hash_lock); +@@ -5659,7 +5669,7 @@ arc_release(arc_buf_t *buf, void *tag) + ASSERT(HDR_EMPTY(hdr)); + + ASSERT3U(hdr->b_l1hdr.b_bufcnt, ==, 1); +- ASSERT3S(refcount_count(&hdr->b_l1hdr.b_refcnt), ==, 1); ++ ASSERT3S(zfs_refcount_count(&hdr->b_l1hdr.b_refcnt), ==, 1); + ASSERT(!list_link_active(&hdr->b_l1hdr.b_arc_node)); + + hdr->b_l1hdr.b_arc_access = 0; +@@ -5687,7 +5697,7 @@ arc_release(arc_buf_t *buf, void *tag) + ASSERT3P(state, !=, arc_anon); + + /* this buffer is not on any list */ +- ASSERT3S(refcount_count(&hdr->b_l1hdr.b_refcnt), >, 0); ++ ASSERT3S(zfs_refcount_count(&hdr->b_l1hdr.b_refcnt), >, 0); + + if (HDR_HAS_L2HDR(hdr)) { + mutex_enter(&hdr->b_l2hdr.b_dev->l2ad_mtx); +@@ -5778,12 +5788,13 @@ arc_release(arc_buf_t *buf, void *tag) + ASSERT3P(hdr->b_l1hdr.b_pabd, !=, NULL); + ASSERT3P(state, !=, arc_l2c_only); + +- (void) refcount_remove_many(&state->arcs_size, ++ (void) zfs_refcount_remove_many(&state->arcs_size, + arc_buf_size(buf), buf); + +- if (refcount_is_zero(&hdr->b_l1hdr.b_refcnt)) { ++ if (zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)) { + ASSERT3P(state, !=, arc_l2c_only); +- (void) refcount_remove_many(&state->arcs_esize[type], ++ (void) zfs_refcount_remove_many( ++ &state->arcs_esize[type], + arc_buf_size(buf), buf); + } + +@@ -5804,7 +5815,7 @@ arc_release(arc_buf_t *buf, void *tag) + nhdr = arc_hdr_alloc(spa, psize, lsize, compress, type); + ASSERT3P(nhdr->b_l1hdr.b_buf, ==, NULL); + ASSERT0(nhdr->b_l1hdr.b_bufcnt); +- ASSERT0(refcount_count(&nhdr->b_l1hdr.b_refcnt)); ++ ASSERT0(zfs_refcount_count(&nhdr->b_l1hdr.b_refcnt)); + VERIFY3U(nhdr->b_type, ==, type); + ASSERT(!HDR_SHARED_DATA(nhdr)); + +@@ -5819,11 +5830,11 @@ arc_release(arc_buf_t *buf, void *tag) + buf->b_hdr = nhdr; + + mutex_exit(&buf->b_evict_lock); +- (void) refcount_add_many(&arc_anon->arcs_size, ++ (void) zfs_refcount_add_many(&arc_anon->arcs_size, + HDR_GET_LSIZE(nhdr), buf); + } else { + mutex_exit(&buf->b_evict_lock); +- ASSERT(refcount_count(&hdr->b_l1hdr.b_refcnt) == 1); ++ ASSERT(zfs_refcount_count(&hdr->b_l1hdr.b_refcnt) == 1); + /* protected by hash lock, or hdr is on arc_anon */ + ASSERT(!multilist_link_active(&hdr->b_l1hdr.b_arc_node)); + ASSERT(!HDR_IO_IN_PROGRESS(hdr)); +@@ -5860,7 +5871,7 @@ arc_referenced(arc_buf_t *buf) + int referenced; + + mutex_enter(&buf->b_evict_lock); +- referenced = (refcount_count(&buf->b_hdr->b_l1hdr.b_refcnt)); ++ referenced = (zfs_refcount_count(&buf->b_hdr->b_l1hdr.b_refcnt)); + mutex_exit(&buf->b_evict_lock); + return (referenced); + } +@@ -5877,7 +5888,7 @@ arc_write_ready(zio_t *zio) + fstrans_cookie_t cookie = spl_fstrans_mark(); + + ASSERT(HDR_HAS_L1HDR(hdr)); +- ASSERT(!refcount_is_zero(&buf->b_hdr->b_l1hdr.b_refcnt)); ++ ASSERT(!zfs_refcount_is_zero(&buf->b_hdr->b_l1hdr.b_refcnt)); + ASSERT(hdr->b_l1hdr.b_bufcnt > 0); + + /* +@@ -6029,7 +6040,7 @@ arc_write_done(zio_t *zio) + if (!BP_EQUAL(&zio->io_bp_orig, zio->io_bp)) + panic("bad overwrite, hdr=%p exists=%p", + (void *)hdr, (void *)exists); +- ASSERT(refcount_is_zero( ++ ASSERT(zfs_refcount_is_zero( + &exists->b_l1hdr.b_refcnt)); + arc_change_state(arc_anon, exists, hash_lock); + mutex_exit(hash_lock); +@@ -6059,7 +6070,7 @@ arc_write_done(zio_t *zio) + arc_hdr_clear_flags(hdr, ARC_FLAG_IO_IN_PROGRESS); + } + +- ASSERT(!refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); ++ ASSERT(!zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); + callback->awcb_done(zio, buf, callback->awcb_private); + + abd_put(zio->io_abd); +@@ -6222,7 +6233,7 @@ arc_tempreserve_space(uint64_t reserve, uint64_t txg) + /* assert that it has not wrapped around */ + ASSERT3S(atomic_add_64_nv(&arc_loaned_bytes, 0), >=, 0); + +- anon_size = MAX((int64_t)(refcount_count(&arc_anon->arcs_size) - ++ anon_size = MAX((int64_t)(zfs_refcount_count(&arc_anon->arcs_size) - + arc_loaned_bytes), 0); + + /* +@@ -6245,9 +6256,10 @@ arc_tempreserve_space(uint64_t reserve, uint64_t txg) + if (reserve + arc_tempreserve + anon_size > arc_c / 2 && + anon_size > arc_c / 4) { + uint64_t meta_esize = +- refcount_count(&arc_anon->arcs_esize[ARC_BUFC_METADATA]); ++ zfs_refcount_count( ++ &arc_anon->arcs_esize[ARC_BUFC_METADATA]); + uint64_t data_esize = +- refcount_count(&arc_anon->arcs_esize[ARC_BUFC_DATA]); ++ zfs_refcount_count(&arc_anon->arcs_esize[ARC_BUFC_DATA]); + dprintf("failing, arc_tempreserve=%lluK anon_meta=%lluK " + "anon_data=%lluK tempreserve=%lluK arc_c=%lluK\n", + arc_tempreserve >> 10, meta_esize >> 10, +@@ -6263,11 +6275,11 @@ static void + arc_kstat_update_state(arc_state_t *state, kstat_named_t *size, + kstat_named_t *evict_data, kstat_named_t *evict_metadata) + { +- size->value.ui64 = refcount_count(&state->arcs_size); ++ size->value.ui64 = zfs_refcount_count(&state->arcs_size); + evict_data->value.ui64 = +- refcount_count(&state->arcs_esize[ARC_BUFC_DATA]); ++ zfs_refcount_count(&state->arcs_esize[ARC_BUFC_DATA]); + evict_metadata->value.ui64 = +- refcount_count(&state->arcs_esize[ARC_BUFC_METADATA]); ++ zfs_refcount_count(&state->arcs_esize[ARC_BUFC_METADATA]); + } + + static int +@@ -6484,25 +6496,25 @@ arc_state_init(void) + offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node), + arc_state_multilist_index_func); + +- refcount_create(&arc_anon->arcs_esize[ARC_BUFC_METADATA]); +- refcount_create(&arc_anon->arcs_esize[ARC_BUFC_DATA]); +- refcount_create(&arc_mru->arcs_esize[ARC_BUFC_METADATA]); +- refcount_create(&arc_mru->arcs_esize[ARC_BUFC_DATA]); +- refcount_create(&arc_mru_ghost->arcs_esize[ARC_BUFC_METADATA]); +- refcount_create(&arc_mru_ghost->arcs_esize[ARC_BUFC_DATA]); +- refcount_create(&arc_mfu->arcs_esize[ARC_BUFC_METADATA]); +- refcount_create(&arc_mfu->arcs_esize[ARC_BUFC_DATA]); +- refcount_create(&arc_mfu_ghost->arcs_esize[ARC_BUFC_METADATA]); +- refcount_create(&arc_mfu_ghost->arcs_esize[ARC_BUFC_DATA]); +- refcount_create(&arc_l2c_only->arcs_esize[ARC_BUFC_METADATA]); +- refcount_create(&arc_l2c_only->arcs_esize[ARC_BUFC_DATA]); +- +- refcount_create(&arc_anon->arcs_size); +- refcount_create(&arc_mru->arcs_size); +- refcount_create(&arc_mru_ghost->arcs_size); +- refcount_create(&arc_mfu->arcs_size); +- refcount_create(&arc_mfu_ghost->arcs_size); +- refcount_create(&arc_l2c_only->arcs_size); ++ zfs_refcount_create(&arc_anon->arcs_esize[ARC_BUFC_METADATA]); ++ zfs_refcount_create(&arc_anon->arcs_esize[ARC_BUFC_DATA]); ++ zfs_refcount_create(&arc_mru->arcs_esize[ARC_BUFC_METADATA]); ++ zfs_refcount_create(&arc_mru->arcs_esize[ARC_BUFC_DATA]); ++ zfs_refcount_create(&arc_mru_ghost->arcs_esize[ARC_BUFC_METADATA]); ++ zfs_refcount_create(&arc_mru_ghost->arcs_esize[ARC_BUFC_DATA]); ++ zfs_refcount_create(&arc_mfu->arcs_esize[ARC_BUFC_METADATA]); ++ zfs_refcount_create(&arc_mfu->arcs_esize[ARC_BUFC_DATA]); ++ zfs_refcount_create(&arc_mfu_ghost->arcs_esize[ARC_BUFC_METADATA]); ++ zfs_refcount_create(&arc_mfu_ghost->arcs_esize[ARC_BUFC_DATA]); ++ zfs_refcount_create(&arc_l2c_only->arcs_esize[ARC_BUFC_METADATA]); ++ zfs_refcount_create(&arc_l2c_only->arcs_esize[ARC_BUFC_DATA]); ++ ++ zfs_refcount_create(&arc_anon->arcs_size); ++ zfs_refcount_create(&arc_mru->arcs_size); ++ zfs_refcount_create(&arc_mru_ghost->arcs_size); ++ zfs_refcount_create(&arc_mfu->arcs_size); ++ zfs_refcount_create(&arc_mfu_ghost->arcs_size); ++ zfs_refcount_create(&arc_l2c_only->arcs_size); + + arc_anon->arcs_state = ARC_STATE_ANON; + arc_mru->arcs_state = ARC_STATE_MRU; +@@ -6515,25 +6527,25 @@ arc_state_init(void) + static void + arc_state_fini(void) + { +- refcount_destroy(&arc_anon->arcs_esize[ARC_BUFC_METADATA]); +- refcount_destroy(&arc_anon->arcs_esize[ARC_BUFC_DATA]); +- refcount_destroy(&arc_mru->arcs_esize[ARC_BUFC_METADATA]); +- refcount_destroy(&arc_mru->arcs_esize[ARC_BUFC_DATA]); +- refcount_destroy(&arc_mru_ghost->arcs_esize[ARC_BUFC_METADATA]); +- refcount_destroy(&arc_mru_ghost->arcs_esize[ARC_BUFC_DATA]); +- refcount_destroy(&arc_mfu->arcs_esize[ARC_BUFC_METADATA]); +- refcount_destroy(&arc_mfu->arcs_esize[ARC_BUFC_DATA]); +- refcount_destroy(&arc_mfu_ghost->arcs_esize[ARC_BUFC_METADATA]); +- refcount_destroy(&arc_mfu_ghost->arcs_esize[ARC_BUFC_DATA]); +- refcount_destroy(&arc_l2c_only->arcs_esize[ARC_BUFC_METADATA]); +- refcount_destroy(&arc_l2c_only->arcs_esize[ARC_BUFC_DATA]); +- +- refcount_destroy(&arc_anon->arcs_size); +- refcount_destroy(&arc_mru->arcs_size); +- refcount_destroy(&arc_mru_ghost->arcs_size); +- refcount_destroy(&arc_mfu->arcs_size); +- refcount_destroy(&arc_mfu_ghost->arcs_size); +- refcount_destroy(&arc_l2c_only->arcs_size); ++ zfs_refcount_destroy(&arc_anon->arcs_esize[ARC_BUFC_METADATA]); ++ zfs_refcount_destroy(&arc_anon->arcs_esize[ARC_BUFC_DATA]); ++ zfs_refcount_destroy(&arc_mru->arcs_esize[ARC_BUFC_METADATA]); ++ zfs_refcount_destroy(&arc_mru->arcs_esize[ARC_BUFC_DATA]); ++ zfs_refcount_destroy(&arc_mru_ghost->arcs_esize[ARC_BUFC_METADATA]); ++ zfs_refcount_destroy(&arc_mru_ghost->arcs_esize[ARC_BUFC_DATA]); ++ zfs_refcount_destroy(&arc_mfu->arcs_esize[ARC_BUFC_METADATA]); ++ zfs_refcount_destroy(&arc_mfu->arcs_esize[ARC_BUFC_DATA]); ++ zfs_refcount_destroy(&arc_mfu_ghost->arcs_esize[ARC_BUFC_METADATA]); ++ zfs_refcount_destroy(&arc_mfu_ghost->arcs_esize[ARC_BUFC_DATA]); ++ zfs_refcount_destroy(&arc_l2c_only->arcs_esize[ARC_BUFC_METADATA]); ++ zfs_refcount_destroy(&arc_l2c_only->arcs_esize[ARC_BUFC_DATA]); ++ ++ zfs_refcount_destroy(&arc_anon->arcs_size); ++ zfs_refcount_destroy(&arc_mru->arcs_size); ++ zfs_refcount_destroy(&arc_mru_ghost->arcs_size); ++ zfs_refcount_destroy(&arc_mfu->arcs_size); ++ zfs_refcount_destroy(&arc_mfu_ghost->arcs_size); ++ zfs_refcount_destroy(&arc_l2c_only->arcs_size); + + multilist_destroy(arc_mru->arcs_list[ARC_BUFC_METADATA]); + multilist_destroy(arc_mru_ghost->arcs_list[ARC_BUFC_METADATA]); +@@ -6704,8 +6716,8 @@ arc_fini(void) + mutex_enter(&arc_prune_mtx); + while ((p = list_head(&arc_prune_list)) != NULL) { + list_remove(&arc_prune_list, p); +- refcount_remove(&p->p_refcnt, &arc_prune_list); +- refcount_destroy(&p->p_refcnt); ++ zfs_refcount_remove(&p->p_refcnt, &arc_prune_list); ++ zfs_refcount_destroy(&p->p_refcnt); + kmem_free(p, sizeof (*p)); + } + mutex_exit(&arc_prune_mtx); +@@ -7108,7 +7120,7 @@ top: + ARCSTAT_INCR(arcstat_l2_lsize, -HDR_GET_LSIZE(hdr)); + + bytes_dropped += arc_hdr_size(hdr); +- (void) refcount_remove_many(&dev->l2ad_alloc, ++ (void) zfs_refcount_remove_many(&dev->l2ad_alloc, + arc_hdr_size(hdr), hdr); + } + +@@ -7527,7 +7539,8 @@ l2arc_write_buffers(spa_t *spa, l2arc_dev_t *dev, uint64_t target_sz) + list_insert_head(&dev->l2ad_buflist, hdr); + mutex_exit(&dev->l2ad_mtx); + +- (void) refcount_add_many(&dev->l2ad_alloc, psize, hdr); ++ (void) zfs_refcount_add_many(&dev->l2ad_alloc, psize, ++ hdr); + + /* + * Normally the L2ARC can use the hdr's data, but if +@@ -7762,7 +7775,7 @@ l2arc_add_vdev(spa_t *spa, vdev_t *vd) + offsetof(arc_buf_hdr_t, b_l2hdr.b_l2node)); + + vdev_space_update(vd, 0, 0, adddev->l2ad_end - adddev->l2ad_hand); +- refcount_create(&adddev->l2ad_alloc); ++ zfs_refcount_create(&adddev->l2ad_alloc); + + /* + * Add device to global list +@@ -7808,7 +7821,7 @@ l2arc_remove_vdev(vdev_t *vd) + l2arc_evict(remdev, 0, B_TRUE); + list_destroy(&remdev->l2ad_buflist); + mutex_destroy(&remdev->l2ad_mtx); +- refcount_destroy(&remdev->l2ad_alloc); ++ zfs_refcount_destroy(&remdev->l2ad_alloc); + kmem_free(remdev, sizeof (l2arc_dev_t)); + } + +diff --git a/module/zfs/dbuf.c b/module/zfs/dbuf.c +index 5101c848..62b77bb0 100644 +--- a/module/zfs/dbuf.c ++++ b/module/zfs/dbuf.c +@@ -165,7 +165,7 @@ dbuf_cons(void *vdb, void *unused, int kmflag) + mutex_init(&db->db_mtx, NULL, MUTEX_DEFAULT, NULL); + cv_init(&db->db_changed, NULL, CV_DEFAULT, NULL); + multilist_link_init(&db->db_cache_link); +- refcount_create(&db->db_holds); ++ zfs_refcount_create(&db->db_holds); + multilist_link_init(&db->db_cache_link); + + return (0); +@@ -179,7 +179,7 @@ dbuf_dest(void *vdb, void *unused) + mutex_destroy(&db->db_mtx); + cv_destroy(&db->db_changed); + ASSERT(!multilist_link_active(&db->db_cache_link)); +- refcount_destroy(&db->db_holds); ++ zfs_refcount_destroy(&db->db_holds); + } + + /* +@@ -317,7 +317,7 @@ dbuf_hash_remove(dmu_buf_impl_t *db) + * We mustn't hold db_mtx to maintain lock ordering: + * DBUF_HASH_MUTEX > db_mtx. + */ +- ASSERT(refcount_is_zero(&db->db_holds)); ++ ASSERT(zfs_refcount_is_zero(&db->db_holds)); + ASSERT(db->db_state == DB_EVICTING); + ASSERT(!MUTEX_HELD(&db->db_mtx)); + +@@ -354,7 +354,7 @@ dbuf_verify_user(dmu_buf_impl_t *db, dbvu_verify_type_t verify_type) + ASSERT(db->db.db_data != NULL); + ASSERT3U(db->db_state, ==, DB_CACHED); + +- holds = refcount_count(&db->db_holds); ++ holds = zfs_refcount_count(&db->db_holds); + if (verify_type == DBVU_EVICTING) { + /* + * Immediate eviction occurs when holds == dirtycnt. +@@ -478,7 +478,7 @@ dbuf_cache_above_hiwater(void) + uint64_t dbuf_cache_hiwater_bytes = + (dbuf_cache_target * dbuf_cache_hiwater_pct) / 100; + +- return (refcount_count(&dbuf_cache_size) > ++ return (zfs_refcount_count(&dbuf_cache_size) > + dbuf_cache_target + dbuf_cache_hiwater_bytes); + } + +@@ -490,7 +490,7 @@ dbuf_cache_above_lowater(void) + uint64_t dbuf_cache_lowater_bytes = + (dbuf_cache_target * dbuf_cache_lowater_pct) / 100; + +- return (refcount_count(&dbuf_cache_size) > ++ return (zfs_refcount_count(&dbuf_cache_size) > + dbuf_cache_target - dbuf_cache_lowater_bytes); + } + +@@ -524,7 +524,7 @@ dbuf_evict_one(void) + if (db != NULL) { + multilist_sublist_remove(mls, db); + multilist_sublist_unlock(mls); +- (void) refcount_remove_many(&dbuf_cache_size, ++ (void) zfs_refcount_remove_many(&dbuf_cache_size, + db->db.db_size, db); + dbuf_destroy(db); + } else { +@@ -611,7 +611,7 @@ dbuf_evict_notify(void) + * because it's OK to occasionally make the wrong decision here, + * and grabbing the lock results in massive lock contention. + */ +- if (refcount_count(&dbuf_cache_size) > dbuf_cache_target_bytes()) { ++ if (zfs_refcount_count(&dbuf_cache_size) > dbuf_cache_target_bytes()) { + if (dbuf_cache_above_hiwater()) + dbuf_evict_one(); + cv_signal(&dbuf_evict_cv); +@@ -679,7 +679,7 @@ retry: + dbuf_cache = multilist_create(sizeof (dmu_buf_impl_t), + offsetof(dmu_buf_impl_t, db_cache_link), + dbuf_cache_multilist_index_func); +- refcount_create(&dbuf_cache_size); ++ zfs_refcount_create(&dbuf_cache_size); + + tsd_create(&zfs_dbuf_evict_key, NULL); + dbuf_evict_thread_exit = B_FALSE; +@@ -723,7 +723,7 @@ dbuf_fini(void) + mutex_destroy(&dbuf_evict_lock); + cv_destroy(&dbuf_evict_cv); + +- refcount_destroy(&dbuf_cache_size); ++ zfs_refcount_destroy(&dbuf_cache_size); + multilist_destroy(dbuf_cache); + } + +@@ -910,7 +910,7 @@ dbuf_loan_arcbuf(dmu_buf_impl_t *db) + + ASSERT(db->db_blkid != DMU_BONUS_BLKID); + mutex_enter(&db->db_mtx); +- if (arc_released(db->db_buf) || refcount_count(&db->db_holds) > 1) { ++ if (arc_released(db->db_buf) || zfs_refcount_count(&db->db_holds) > 1) { + int blksz = db->db.db_size; + spa_t *spa = db->db_objset->os_spa; + +@@ -983,7 +983,7 @@ dbuf_read_done(zio_t *zio, arc_buf_t *buf, void *vdb) + /* + * All reads are synchronous, so we must have a hold on the dbuf + */ +- ASSERT(refcount_count(&db->db_holds) > 0); ++ ASSERT(zfs_refcount_count(&db->db_holds) > 0); + ASSERT(db->db_buf == NULL); + ASSERT(db->db.db_data == NULL); + if (db->db_level == 0 && db->db_freed_in_flight) { +@@ -1017,7 +1017,7 @@ dbuf_read_impl(dmu_buf_impl_t *db, zio_t *zio, uint32_t flags) + + DB_DNODE_ENTER(db); + dn = DB_DNODE(db); +- ASSERT(!refcount_is_zero(&db->db_holds)); ++ ASSERT(!zfs_refcount_is_zero(&db->db_holds)); + /* We need the struct_rwlock to prevent db_blkptr from changing. */ + ASSERT(RW_LOCK_HELD(&dn->dn_struct_rwlock)); + ASSERT(MUTEX_HELD(&db->db_mtx)); +@@ -1150,7 +1150,7 @@ dbuf_fix_old_data(dmu_buf_impl_t *db, uint64_t txg) + dr->dt.dl.dr_data = kmem_alloc(bonuslen, KM_SLEEP); + arc_space_consume(bonuslen, ARC_SPACE_BONUS); + bcopy(db->db.db_data, dr->dt.dl.dr_data, bonuslen); +- } else if (refcount_count(&db->db_holds) > db->db_dirtycnt) { ++ } else if (zfs_refcount_count(&db->db_holds) > db->db_dirtycnt) { + int size = arc_buf_size(db->db_buf); + arc_buf_contents_t type = DBUF_GET_BUFC_TYPE(db); + spa_t *spa = db->db_objset->os_spa; +@@ -1182,7 +1182,7 @@ dbuf_read(dmu_buf_impl_t *db, zio_t *zio, uint32_t flags) + * We don't have to hold the mutex to check db_state because it + * can't be freed while we have a hold on the buffer. + */ +- ASSERT(!refcount_is_zero(&db->db_holds)); ++ ASSERT(!zfs_refcount_is_zero(&db->db_holds)); + + if (db->db_state == DB_NOFILL) + return (SET_ERROR(EIO)); +@@ -1277,7 +1277,7 @@ dbuf_read(dmu_buf_impl_t *db, zio_t *zio, uint32_t flags) + static void + dbuf_noread(dmu_buf_impl_t *db) + { +- ASSERT(!refcount_is_zero(&db->db_holds)); ++ ASSERT(!zfs_refcount_is_zero(&db->db_holds)); + ASSERT(db->db_blkid != DMU_BONUS_BLKID); + mutex_enter(&db->db_mtx); + while (db->db_state == DB_READ || db->db_state == DB_FILL) +@@ -1397,7 +1397,7 @@ dbuf_free_range(dnode_t *dn, uint64_t start_blkid, uint64_t end_blkid, + mutex_exit(&db->db_mtx); + continue; + } +- if (refcount_count(&db->db_holds) == 0) { ++ if (zfs_refcount_count(&db->db_holds) == 0) { + ASSERT(db->db_buf); + dbuf_destroy(db); + continue; +@@ -1544,7 +1544,7 @@ dbuf_dirty(dmu_buf_impl_t *db, dmu_tx_t *tx) + int txgoff = tx->tx_txg & TXG_MASK; + + ASSERT(tx->tx_txg != 0); +- ASSERT(!refcount_is_zero(&db->db_holds)); ++ ASSERT(!zfs_refcount_is_zero(&db->db_holds)); + DMU_TX_DIRTY_BUF(tx, db); + + DB_DNODE_ENTER(db); +@@ -1912,7 +1912,7 @@ dbuf_undirty(dmu_buf_impl_t *db, dmu_tx_t *tx) + ASSERT(db->db_dirtycnt > 0); + db->db_dirtycnt -= 1; + +- if (refcount_remove(&db->db_holds, (void *)(uintptr_t)txg) == 0) { ++ if (zfs_refcount_remove(&db->db_holds, (void *)(uintptr_t)txg) == 0) { + ASSERT(db->db_state == DB_NOFILL || arc_released(db->db_buf)); + dbuf_destroy(db); + return (B_TRUE); +@@ -1929,7 +1929,7 @@ dmu_buf_will_dirty(dmu_buf_t *db_fake, dmu_tx_t *tx) + dbuf_dirty_record_t *dr; + + ASSERT(tx->tx_txg != 0); +- ASSERT(!refcount_is_zero(&db->db_holds)); ++ ASSERT(!zfs_refcount_is_zero(&db->db_holds)); + + /* + * Quick check for dirtyness. For already dirty blocks, this +@@ -1981,7 +1981,7 @@ dmu_buf_will_fill(dmu_buf_t *db_fake, dmu_tx_t *tx) + ASSERT(db->db_blkid != DMU_BONUS_BLKID); + ASSERT(tx->tx_txg != 0); + ASSERT(db->db_level == 0); +- ASSERT(!refcount_is_zero(&db->db_holds)); ++ ASSERT(!zfs_refcount_is_zero(&db->db_holds)); + + ASSERT(db->db.db_object != DMU_META_DNODE_OBJECT || + dmu_tx_private_ok(tx)); +@@ -2056,7 +2056,7 @@ dmu_buf_write_embedded(dmu_buf_t *dbuf, void *data, + void + dbuf_assign_arcbuf(dmu_buf_impl_t *db, arc_buf_t *buf, dmu_tx_t *tx) + { +- ASSERT(!refcount_is_zero(&db->db_holds)); ++ ASSERT(!zfs_refcount_is_zero(&db->db_holds)); + ASSERT(db->db_blkid != DMU_BONUS_BLKID); + ASSERT(db->db_level == 0); + ASSERT3U(dbuf_is_metadata(db), ==, arc_is_metadata(buf)); +@@ -2075,7 +2075,7 @@ dbuf_assign_arcbuf(dmu_buf_impl_t *db, arc_buf_t *buf, dmu_tx_t *tx) + ASSERT(db->db_state == DB_CACHED || db->db_state == DB_UNCACHED); + + if (db->db_state == DB_CACHED && +- refcount_count(&db->db_holds) - 1 > db->db_dirtycnt) { ++ zfs_refcount_count(&db->db_holds) - 1 > db->db_dirtycnt) { + mutex_exit(&db->db_mtx); + (void) dbuf_dirty(db, tx); + bcopy(buf->b_data, db->db.db_data, db->db.db_size); +@@ -2120,7 +2120,7 @@ dbuf_destroy(dmu_buf_impl_t *db) + dmu_buf_impl_t *dndb; + + ASSERT(MUTEX_HELD(&db->db_mtx)); +- ASSERT(refcount_is_zero(&db->db_holds)); ++ ASSERT(zfs_refcount_is_zero(&db->db_holds)); + + if (db->db_buf != NULL) { + arc_buf_destroy(db->db_buf, db); +@@ -2140,7 +2140,7 @@ dbuf_destroy(dmu_buf_impl_t *db) + + if (multilist_link_active(&db->db_cache_link)) { + multilist_remove(dbuf_cache, db); +- (void) refcount_remove_many(&dbuf_cache_size, ++ (void) zfs_refcount_remove_many(&dbuf_cache_size, + db->db.db_size, db); + } + +@@ -2186,7 +2186,7 @@ dbuf_destroy(dmu_buf_impl_t *db) + DB_DNODE_EXIT(db); + } + +- ASSERT(refcount_is_zero(&db->db_holds)); ++ ASSERT(zfs_refcount_is_zero(&db->db_holds)); + + db->db_parent = NULL; + +@@ -2383,7 +2383,7 @@ dbuf_create(dnode_t *dn, uint8_t level, uint64_t blkid, + dbuf_add_ref(parent, db); + + ASSERT(dn->dn_object == DMU_META_DNODE_OBJECT || +- refcount_count(&dn->dn_holds) > 0); ++ zfs_refcount_count(&dn->dn_holds) > 0); + (void) zfs_refcount_add(&dn->dn_holds, db); + atomic_inc_32(&dn->dn_dbufs_count); + +@@ -2744,9 +2744,9 @@ __dbuf_hold_impl(struct dbuf_hold_impl_data *dh) + } + + if (multilist_link_active(&dh->dh_db->db_cache_link)) { +- ASSERT(refcount_is_zero(&dh->dh_db->db_holds)); ++ ASSERT(zfs_refcount_is_zero(&dh->dh_db->db_holds)); + multilist_remove(dbuf_cache, dh->dh_db); +- (void) refcount_remove_many(&dbuf_cache_size, ++ (void) zfs_refcount_remove_many(&dbuf_cache_size, + dh->dh_db->db.db_size, dh->dh_db); + } + (void) zfs_refcount_add(&dh->dh_db->db_holds, dh->dh_tag); +@@ -2938,7 +2938,7 @@ dbuf_rele_and_unlock(dmu_buf_impl_t *db, void *tag) + * dnode so we can guarantee in dnode_move() that a referenced bonus + * buffer has a corresponding dnode hold. + */ +- holds = refcount_remove(&db->db_holds, tag); ++ holds = zfs_refcount_remove(&db->db_holds, tag); + ASSERT(holds >= 0); + + /* +@@ -3017,7 +3017,7 @@ dbuf_rele_and_unlock(dmu_buf_impl_t *db, void *tag) + dbuf_destroy(db); + } else if (!multilist_link_active(&db->db_cache_link)) { + multilist_insert(dbuf_cache, db); +- (void) refcount_add_many(&dbuf_cache_size, ++ (void) zfs_refcount_add_many(&dbuf_cache_size, + db->db.db_size, db); + mutex_exit(&db->db_mtx); + +@@ -3037,7 +3037,7 @@ dbuf_rele_and_unlock(dmu_buf_impl_t *db, void *tag) + uint64_t + dbuf_refcount(dmu_buf_impl_t *db) + { +- return (refcount_count(&db->db_holds)); ++ return (zfs_refcount_count(&db->db_holds)); + } + + void * +@@ -3340,7 +3340,7 @@ dbuf_sync_leaf(dbuf_dirty_record_t *dr, dmu_tx_t *tx) + + if (db->db_state != DB_NOFILL && + dn->dn_object != DMU_META_DNODE_OBJECT && +- refcount_count(&db->db_holds) > 1 && ++ zfs_refcount_count(&db->db_holds) > 1 && + dr->dt.dl.dr_override_state != DR_OVERRIDDEN && + *datap == db->db_buf) { + /* +diff --git a/module/zfs/dbuf_stats.c b/module/zfs/dbuf_stats.c +index 1712c9c1..7afc9ddc 100644 +--- a/module/zfs/dbuf_stats.c ++++ b/module/zfs/dbuf_stats.c +@@ -89,7 +89,7 @@ __dbuf_stats_hash_table_data(char *buf, size_t size, dmu_buf_impl_t *db) + (u_longlong_t)db->db.db_size, + !!dbuf_is_metadata(db), + db->db_state, +- (ulong_t)refcount_count(&db->db_holds), ++ (ulong_t)zfs_refcount_count(&db->db_holds), + /* arc_buf_info_t */ + abi.abi_state_type, + abi.abi_state_contents, +@@ -113,7 +113,7 @@ __dbuf_stats_hash_table_data(char *buf, size_t size, dmu_buf_impl_t *db) + (ulong_t)doi.doi_metadata_block_size, + (u_longlong_t)doi.doi_bonus_size, + (ulong_t)doi.doi_indirection, +- (ulong_t)refcount_count(&dn->dn_holds), ++ (ulong_t)zfs_refcount_count(&dn->dn_holds), + (u_longlong_t)doi.doi_fill_count, + (u_longlong_t)doi.doi_max_offset); + +diff --git a/module/zfs/dmu_tx.c b/module/zfs/dmu_tx.c +index b1508ffa..135743e9 100644 +--- a/module/zfs/dmu_tx.c ++++ b/module/zfs/dmu_tx.c +@@ -132,8 +132,8 @@ dmu_tx_hold_dnode_impl(dmu_tx_t *tx, dnode_t *dn, enum dmu_tx_hold_type type, + txh = kmem_zalloc(sizeof (dmu_tx_hold_t), KM_SLEEP); + txh->txh_tx = tx; + txh->txh_dnode = dn; +- refcount_create(&txh->txh_space_towrite); +- refcount_create(&txh->txh_memory_tohold); ++ zfs_refcount_create(&txh->txh_space_towrite); ++ zfs_refcount_create(&txh->txh_memory_tohold); + txh->txh_type = type; + txh->txh_arg1 = arg1; + txh->txh_arg2 = arg2; +@@ -228,9 +228,9 @@ dmu_tx_count_write(dmu_tx_hold_t *txh, uint64_t off, uint64_t len) + if (len == 0) + return; + +- (void) refcount_add_many(&txh->txh_space_towrite, len, FTAG); ++ (void) zfs_refcount_add_many(&txh->txh_space_towrite, len, FTAG); + +- if (refcount_count(&txh->txh_space_towrite) > 2 * DMU_MAX_ACCESS) ++ if (zfs_refcount_count(&txh->txh_space_towrite) > 2 * DMU_MAX_ACCESS) + err = SET_ERROR(EFBIG); + + if (dn == NULL) +@@ -295,7 +295,8 @@ dmu_tx_count_write(dmu_tx_hold_t *txh, uint64_t off, uint64_t len) + static void + dmu_tx_count_dnode(dmu_tx_hold_t *txh) + { +- (void) refcount_add_many(&txh->txh_space_towrite, DNODE_MIN_SIZE, FTAG); ++ (void) zfs_refcount_add_many(&txh->txh_space_towrite, DNODE_MIN_SIZE, ++ FTAG); + } + + void +@@ -418,7 +419,7 @@ dmu_tx_hold_free_impl(dmu_tx_hold_t *txh, uint64_t off, uint64_t len) + return; + } + +- (void) refcount_add_many(&txh->txh_memory_tohold, ++ (void) zfs_refcount_add_many(&txh->txh_memory_tohold, + 1 << dn->dn_indblkshift, FTAG); + + err = dmu_tx_check_ioerr(zio, dn, 1, i); +@@ -477,7 +478,7 @@ dmu_tx_hold_zap_impl(dmu_tx_hold_t *txh, const char *name) + * - 2 blocks for possibly split leaves, + * - 2 grown ptrtbl blocks + */ +- (void) refcount_add_many(&txh->txh_space_towrite, ++ (void) zfs_refcount_add_many(&txh->txh_space_towrite, + MZAP_MAX_BLKSZ, FTAG); + + if (dn == NULL) +@@ -568,7 +569,8 @@ dmu_tx_hold_space(dmu_tx_t *tx, uint64_t space) + txh = dmu_tx_hold_object_impl(tx, tx->tx_objset, + DMU_NEW_OBJECT, THT_SPACE, space, 0); + if (txh) +- (void) refcount_add_many(&txh->txh_space_towrite, space, FTAG); ++ (void) zfs_refcount_add_many(&txh->txh_space_towrite, space, ++ FTAG); + } + + #ifdef ZFS_DEBUG +@@ -919,8 +921,8 @@ dmu_tx_try_assign(dmu_tx_t *tx, uint64_t txg_how) + (void) zfs_refcount_add(&dn->dn_tx_holds, tx); + mutex_exit(&dn->dn_mtx); + } +- towrite += refcount_count(&txh->txh_space_towrite); +- tohold += refcount_count(&txh->txh_memory_tohold); ++ towrite += zfs_refcount_count(&txh->txh_space_towrite); ++ tohold += zfs_refcount_count(&txh->txh_memory_tohold); + } + + /* needed allocation: worst-case estimate of write space */ +@@ -962,7 +964,7 @@ dmu_tx_unassign(dmu_tx_t *tx) + mutex_enter(&dn->dn_mtx); + ASSERT3U(dn->dn_assigned_txg, ==, tx->tx_txg); + +- if (refcount_remove(&dn->dn_tx_holds, tx) == 0) { ++ if (zfs_refcount_remove(&dn->dn_tx_holds, tx) == 0) { + dn->dn_assigned_txg = 0; + cv_broadcast(&dn->dn_notxholds); + } +@@ -1100,10 +1102,10 @@ dmu_tx_destroy(dmu_tx_t *tx) + dnode_t *dn = txh->txh_dnode; + + list_remove(&tx->tx_holds, txh); +- refcount_destroy_many(&txh->txh_space_towrite, +- refcount_count(&txh->txh_space_towrite)); +- refcount_destroy_many(&txh->txh_memory_tohold, +- refcount_count(&txh->txh_memory_tohold)); ++ zfs_refcount_destroy_many(&txh->txh_space_towrite, ++ zfs_refcount_count(&txh->txh_space_towrite)); ++ zfs_refcount_destroy_many(&txh->txh_memory_tohold, ++ zfs_refcount_count(&txh->txh_memory_tohold)); + kmem_free(txh, sizeof (dmu_tx_hold_t)); + if (dn != NULL) + dnode_rele(dn, tx); +@@ -1135,7 +1137,7 @@ dmu_tx_commit(dmu_tx_t *tx) + mutex_enter(&dn->dn_mtx); + ASSERT3U(dn->dn_assigned_txg, ==, tx->tx_txg); + +- if (refcount_remove(&dn->dn_tx_holds, tx) == 0) { ++ if (zfs_refcount_remove(&dn->dn_tx_holds, tx) == 0) { + dn->dn_assigned_txg = 0; + cv_broadcast(&dn->dn_notxholds); + } +@@ -1250,7 +1252,7 @@ dmu_tx_hold_spill(dmu_tx_t *tx, uint64_t object) + txh = dmu_tx_hold_object_impl(tx, tx->tx_objset, object, + THT_SPILL, 0, 0); + if (txh != NULL) +- (void) refcount_add_many(&txh->txh_space_towrite, ++ (void) zfs_refcount_add_many(&txh->txh_space_towrite, + SPA_OLD_MAXBLOCKSIZE, FTAG); + } + +diff --git a/module/zfs/dnode.c b/module/zfs/dnode.c +index 77d38c36..989a8ec7 100644 +--- a/module/zfs/dnode.c ++++ b/module/zfs/dnode.c +@@ -124,8 +124,8 @@ dnode_cons(void *arg, void *unused, int kmflag) + * Every dbuf has a reference, and dropping a tracked reference is + * O(number of references), so don't track dn_holds. + */ +- refcount_create_untracked(&dn->dn_holds); +- refcount_create(&dn->dn_tx_holds); ++ zfs_refcount_create_untracked(&dn->dn_holds); ++ zfs_refcount_create(&dn->dn_tx_holds); + list_link_init(&dn->dn_link); + + bzero(&dn->dn_next_nblkptr[0], sizeof (dn->dn_next_nblkptr)); +@@ -180,8 +180,8 @@ dnode_dest(void *arg, void *unused) + mutex_destroy(&dn->dn_mtx); + mutex_destroy(&dn->dn_dbufs_mtx); + cv_destroy(&dn->dn_notxholds); +- refcount_destroy(&dn->dn_holds); +- refcount_destroy(&dn->dn_tx_holds); ++ zfs_refcount_destroy(&dn->dn_holds); ++ zfs_refcount_destroy(&dn->dn_tx_holds); + ASSERT(!list_link_active(&dn->dn_link)); + + for (i = 0; i < TXG_SIZE; i++) { +@@ -377,7 +377,7 @@ dnode_buf_byteswap(void *vbuf, size_t size) + void + dnode_setbonuslen(dnode_t *dn, int newsize, dmu_tx_t *tx) + { +- ASSERT3U(refcount_count(&dn->dn_holds), >=, 1); ++ ASSERT3U(zfs_refcount_count(&dn->dn_holds), >=, 1); + + dnode_setdirty(dn, tx); + rw_enter(&dn->dn_struct_rwlock, RW_WRITER); +@@ -394,7 +394,7 @@ dnode_setbonuslen(dnode_t *dn, int newsize, dmu_tx_t *tx) + void + dnode_setbonus_type(dnode_t *dn, dmu_object_type_t newtype, dmu_tx_t *tx) + { +- ASSERT3U(refcount_count(&dn->dn_holds), >=, 1); ++ ASSERT3U(zfs_refcount_count(&dn->dn_holds), >=, 1); + dnode_setdirty(dn, tx); + rw_enter(&dn->dn_struct_rwlock, RW_WRITER); + dn->dn_bonustype = newtype; +@@ -405,7 +405,7 @@ dnode_setbonus_type(dnode_t *dn, dmu_object_type_t newtype, dmu_tx_t *tx) + void + dnode_rm_spill(dnode_t *dn, dmu_tx_t *tx) + { +- ASSERT3U(refcount_count(&dn->dn_holds), >=, 1); ++ ASSERT3U(zfs_refcount_count(&dn->dn_holds), >=, 1); + ASSERT(RW_WRITE_HELD(&dn->dn_struct_rwlock)); + dnode_setdirty(dn, tx); + dn->dn_rm_spillblk[tx->tx_txg&TXG_MASK] = DN_KILL_SPILLBLK; +@@ -596,8 +596,8 @@ dnode_allocate(dnode_t *dn, dmu_object_type_t ot, int blocksize, int ibs, + ASSERT0(dn->dn_allocated_txg); + ASSERT0(dn->dn_assigned_txg); + ASSERT0(dn->dn_dirty_txg); +- ASSERT(refcount_is_zero(&dn->dn_tx_holds)); +- ASSERT3U(refcount_count(&dn->dn_holds), <=, 1); ++ ASSERT(zfs_refcount_is_zero(&dn->dn_tx_holds)); ++ ASSERT3U(zfs_refcount_count(&dn->dn_holds), <=, 1); + ASSERT(avl_is_empty(&dn->dn_dbufs)); + + for (i = 0; i < TXG_SIZE; i++) { +@@ -786,8 +786,8 @@ dnode_move_impl(dnode_t *odn, dnode_t *ndn) + ndn->dn_dirty_txg = odn->dn_dirty_txg; + ndn->dn_dirtyctx = odn->dn_dirtyctx; + ndn->dn_dirtyctx_firstset = odn->dn_dirtyctx_firstset; +- ASSERT(refcount_count(&odn->dn_tx_holds) == 0); +- refcount_transfer(&ndn->dn_holds, &odn->dn_holds); ++ ASSERT(zfs_refcount_count(&odn->dn_tx_holds) == 0); ++ zfs_refcount_transfer(&ndn->dn_holds, &odn->dn_holds); + ASSERT(avl_is_empty(&ndn->dn_dbufs)); + avl_swap(&ndn->dn_dbufs, &odn->dn_dbufs); + ndn->dn_dbufs_count = odn->dn_dbufs_count; +@@ -975,7 +975,7 @@ dnode_move(void *buf, void *newbuf, size_t size, void *arg) + * hold before the dbuf is removed, the hold is discounted, and the + * removal is blocked until the move completes. + */ +- refcount = refcount_count(&odn->dn_holds); ++ refcount = zfs_refcount_count(&odn->dn_holds); + ASSERT(refcount >= 0); + dbufs = odn->dn_dbufs_count; + +@@ -1003,7 +1003,7 @@ dnode_move(void *buf, void *newbuf, size_t size, void *arg) + + list_link_replace(&odn->dn_link, &ndn->dn_link); + /* If the dnode was safe to move, the refcount cannot have changed. */ +- ASSERT(refcount == refcount_count(&ndn->dn_holds)); ++ ASSERT(refcount == zfs_refcount_count(&ndn->dn_holds)); + ASSERT(dbufs == ndn->dn_dbufs_count); + zrl_exit(&ndn->dn_handle->dnh_zrlock); /* handle has moved */ + mutex_exit(&os->os_lock); +@@ -1152,7 +1152,7 @@ dnode_special_close(dnode_handle_t *dnh) + * has a hold on this dnode while we are trying to evict this + * dnode. + */ +- while (refcount_count(&dn->dn_holds) > 0) ++ while (zfs_refcount_count(&dn->dn_holds) > 0) + delay(1); + ASSERT(dn->dn_dbuf == NULL || + dmu_buf_get_user(&dn->dn_dbuf->db) == NULL); +@@ -1207,8 +1207,8 @@ dnode_buf_evict_async(void *dbu) + * it wouldn't be eligible for eviction and this function + * would not have been called. + */ +- ASSERT(refcount_is_zero(&dn->dn_holds)); +- ASSERT(refcount_is_zero(&dn->dn_tx_holds)); ++ ASSERT(zfs_refcount_is_zero(&dn->dn_holds)); ++ ASSERT(zfs_refcount_is_zero(&dn->dn_tx_holds)); + + dnode_destroy(dn); /* implicit zrl_remove() for first slot */ + zrl_destroy(&dnh->dnh_zrlock); +@@ -1460,7 +1460,7 @@ dnode_hold_impl(objset_t *os, uint64_t object, int flag, int slots, + } + + mutex_enter(&dn->dn_mtx); +- if (!refcount_is_zero(&dn->dn_holds)) { ++ if (!zfs_refcount_is_zero(&dn->dn_holds)) { + DNODE_STAT_BUMP(dnode_hold_free_refcount); + mutex_exit(&dn->dn_mtx); + dnode_slots_rele(dnc, idx, slots); +@@ -1520,7 +1520,7 @@ boolean_t + dnode_add_ref(dnode_t *dn, void *tag) + { + mutex_enter(&dn->dn_mtx); +- if (refcount_is_zero(&dn->dn_holds)) { ++ if (zfs_refcount_is_zero(&dn->dn_holds)) { + mutex_exit(&dn->dn_mtx); + return (FALSE); + } +@@ -1544,7 +1544,7 @@ dnode_rele_and_unlock(dnode_t *dn, void *tag) + dmu_buf_impl_t *db = dn->dn_dbuf; + dnode_handle_t *dnh = dn->dn_handle; + +- refs = refcount_remove(&dn->dn_holds, tag); ++ refs = zfs_refcount_remove(&dn->dn_holds, tag); + mutex_exit(&dn->dn_mtx); + + /* +@@ -1608,7 +1608,7 @@ dnode_setdirty(dnode_t *dn, dmu_tx_t *tx) + return; + } + +- ASSERT(!refcount_is_zero(&dn->dn_holds) || ++ ASSERT(!zfs_refcount_is_zero(&dn->dn_holds) || + !avl_is_empty(&dn->dn_dbufs)); + ASSERT(dn->dn_datablksz != 0); + ASSERT0(dn->dn_next_bonuslen[txg&TXG_MASK]); +diff --git a/module/zfs/dnode_sync.c b/module/zfs/dnode_sync.c +index 8d65e385..2febb520 100644 +--- a/module/zfs/dnode_sync.c ++++ b/module/zfs/dnode_sync.c +@@ -422,7 +422,7 @@ dnode_evict_dbufs(dnode_t *dn) + + mutex_enter(&db->db_mtx); + if (db->db_state != DB_EVICTING && +- refcount_is_zero(&db->db_holds)) { ++ zfs_refcount_is_zero(&db->db_holds)) { + db_marker->db_level = db->db_level; + db_marker->db_blkid = db->db_blkid; + db_marker->db_state = DB_SEARCH; +@@ -451,7 +451,7 @@ dnode_evict_bonus(dnode_t *dn) + { + rw_enter(&dn->dn_struct_rwlock, RW_WRITER); + if (dn->dn_bonus != NULL) { +- if (refcount_is_zero(&dn->dn_bonus->db_holds)) { ++ if (zfs_refcount_is_zero(&dn->dn_bonus->db_holds)) { + mutex_enter(&dn->dn_bonus->db_mtx); + dbuf_destroy(dn->dn_bonus); + dn->dn_bonus = NULL; +@@ -517,7 +517,7 @@ dnode_sync_free(dnode_t *dn, dmu_tx_t *tx) + * zfs_obj_to_path() also depends on this being + * commented out. + * +- * ASSERT3U(refcount_count(&dn->dn_holds), ==, 1); ++ * ASSERT3U(zfs_refcount_count(&dn->dn_holds), ==, 1); + */ + + /* Undirty next bits */ +diff --git a/module/zfs/dsl_dataset.c b/module/zfs/dsl_dataset.c +index b7562bcd..2e79c489 100644 +--- a/module/zfs/dsl_dataset.c ++++ b/module/zfs/dsl_dataset.c +@@ -287,7 +287,7 @@ dsl_dataset_evict_async(void *dbu) + mutex_destroy(&ds->ds_lock); + mutex_destroy(&ds->ds_opening_lock); + mutex_destroy(&ds->ds_sendstream_lock); +- refcount_destroy(&ds->ds_longholds); ++ zfs_refcount_destroy(&ds->ds_longholds); + rrw_destroy(&ds->ds_bp_rwlock); + + kmem_free(ds, sizeof (dsl_dataset_t)); +@@ -422,7 +422,7 @@ dsl_dataset_hold_obj(dsl_pool_t *dp, uint64_t dsobj, void *tag, + mutex_init(&ds->ds_opening_lock, NULL, MUTEX_DEFAULT, NULL); + mutex_init(&ds->ds_sendstream_lock, NULL, MUTEX_DEFAULT, NULL); + rrw_init(&ds->ds_bp_rwlock, B_FALSE); +- refcount_create(&ds->ds_longholds); ++ zfs_refcount_create(&ds->ds_longholds); + + bplist_create(&ds->ds_pending_deadlist); + dsl_deadlist_open(&ds->ds_deadlist, +@@ -458,7 +458,7 @@ dsl_dataset_hold_obj(dsl_pool_t *dp, uint64_t dsobj, void *tag, + mutex_destroy(&ds->ds_lock); + mutex_destroy(&ds->ds_opening_lock); + mutex_destroy(&ds->ds_sendstream_lock); +- refcount_destroy(&ds->ds_longholds); ++ zfs_refcount_destroy(&ds->ds_longholds); + bplist_destroy(&ds->ds_pending_deadlist); + dsl_deadlist_close(&ds->ds_deadlist); + kmem_free(ds, sizeof (dsl_dataset_t)); +@@ -520,7 +520,7 @@ dsl_dataset_hold_obj(dsl_pool_t *dp, uint64_t dsobj, void *tag, + mutex_destroy(&ds->ds_lock); + mutex_destroy(&ds->ds_opening_lock); + mutex_destroy(&ds->ds_sendstream_lock); +- refcount_destroy(&ds->ds_longholds); ++ zfs_refcount_destroy(&ds->ds_longholds); + kmem_free(ds, sizeof (dsl_dataset_t)); + if (err != 0) { + dmu_buf_rele(dbuf, tag); +@@ -651,14 +651,14 @@ dsl_dataset_long_hold(dsl_dataset_t *ds, void *tag) + void + dsl_dataset_long_rele(dsl_dataset_t *ds, void *tag) + { +- (void) refcount_remove(&ds->ds_longholds, tag); ++ (void) zfs_refcount_remove(&ds->ds_longholds, tag); + } + + /* Return B_TRUE if there are any long holds on this dataset. */ + boolean_t + dsl_dataset_long_held(dsl_dataset_t *ds) + { +- return (!refcount_is_zero(&ds->ds_longholds)); ++ return (!zfs_refcount_is_zero(&ds->ds_longholds)); + } + + void +diff --git a/module/zfs/dsl_destroy.c b/module/zfs/dsl_destroy.c +index d980f7d1..946eb1d3 100644 +--- a/module/zfs/dsl_destroy.c ++++ b/module/zfs/dsl_destroy.c +@@ -258,7 +258,7 @@ dsl_destroy_snapshot_sync_impl(dsl_dataset_t *ds, boolean_t defer, dmu_tx_t *tx) + rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG); + ASSERT3U(dsl_dataset_phys(ds)->ds_bp.blk_birth, <=, tx->tx_txg); + rrw_exit(&ds->ds_bp_rwlock, FTAG); +- ASSERT(refcount_is_zero(&ds->ds_longholds)); ++ ASSERT(zfs_refcount_is_zero(&ds->ds_longholds)); + + if (defer && + (ds->ds_userrefs > 0 || +@@ -619,7 +619,7 @@ dsl_destroy_head_check_impl(dsl_dataset_t *ds, int expected_holds) + if (ds->ds_is_snapshot) + return (SET_ERROR(EINVAL)); + +- if (refcount_count(&ds->ds_longholds) != expected_holds) ++ if (zfs_refcount_count(&ds->ds_longholds) != expected_holds) + return (SET_ERROR(EBUSY)); + + mos = ds->ds_dir->dd_pool->dp_meta_objset; +@@ -647,7 +647,7 @@ dsl_destroy_head_check_impl(dsl_dataset_t *ds, int expected_holds) + dsl_dataset_phys(ds->ds_prev)->ds_num_children == 2 && + ds->ds_prev->ds_userrefs == 0) { + /* We need to remove the origin snapshot as well. */ +- if (!refcount_is_zero(&ds->ds_prev->ds_longholds)) ++ if (!zfs_refcount_is_zero(&ds->ds_prev->ds_longholds)) + return (SET_ERROR(EBUSY)); + } + return (0); +diff --git a/module/zfs/metaslab.c b/module/zfs/metaslab.c +index 40658d51..2a5581c3 100644 +--- a/module/zfs/metaslab.c ++++ b/module/zfs/metaslab.c +@@ -223,7 +223,7 @@ metaslab_class_create(spa_t *spa, metaslab_ops_t *ops) + mc->mc_rotor = NULL; + mc->mc_ops = ops; + mutex_init(&mc->mc_lock, NULL, MUTEX_DEFAULT, NULL); +- refcount_create_tracked(&mc->mc_alloc_slots); ++ zfs_refcount_create_tracked(&mc->mc_alloc_slots); + + return (mc); + } +@@ -237,7 +237,7 @@ metaslab_class_destroy(metaslab_class_t *mc) + ASSERT(mc->mc_space == 0); + ASSERT(mc->mc_dspace == 0); + +- refcount_destroy(&mc->mc_alloc_slots); ++ zfs_refcount_destroy(&mc->mc_alloc_slots); + mutex_destroy(&mc->mc_lock); + kmem_free(mc, sizeof (metaslab_class_t)); + } +@@ -585,7 +585,7 @@ metaslab_group_create(metaslab_class_t *mc, vdev_t *vd) + mg->mg_activation_count = 0; + mg->mg_initialized = B_FALSE; + mg->mg_no_free_space = B_TRUE; +- refcount_create_tracked(&mg->mg_alloc_queue_depth); ++ zfs_refcount_create_tracked(&mg->mg_alloc_queue_depth); + + mg->mg_taskq = taskq_create("metaslab_group_taskq", metaslab_load_pct, + maxclsyspri, 10, INT_MAX, TASKQ_THREADS_CPU_PCT | TASKQ_DYNAMIC); +@@ -608,7 +608,7 @@ metaslab_group_destroy(metaslab_group_t *mg) + taskq_destroy(mg->mg_taskq); + avl_destroy(&mg->mg_metaslab_tree); + mutex_destroy(&mg->mg_lock); +- refcount_destroy(&mg->mg_alloc_queue_depth); ++ zfs_refcount_destroy(&mg->mg_alloc_queue_depth); + kmem_free(mg, sizeof (metaslab_group_t)); + } + +@@ -907,7 +907,7 @@ metaslab_group_allocatable(metaslab_group_t *mg, metaslab_group_t *rotor, + if (mg->mg_no_free_space) + return (B_FALSE); + +- qdepth = refcount_count(&mg->mg_alloc_queue_depth); ++ qdepth = zfs_refcount_count(&mg->mg_alloc_queue_depth); + + /* + * If this metaslab group is below its qmax or it's +@@ -928,7 +928,7 @@ metaslab_group_allocatable(metaslab_group_t *mg, metaslab_group_t *rotor, + for (mgp = mg->mg_next; mgp != rotor; mgp = mgp->mg_next) { + qmax = mgp->mg_max_alloc_queue_depth; + +- qdepth = refcount_count(&mgp->mg_alloc_queue_depth); ++ qdepth = zfs_refcount_count(&mgp->mg_alloc_queue_depth); + + /* + * If there is another metaslab group that +@@ -2679,7 +2679,7 @@ metaslab_group_alloc_decrement(spa_t *spa, uint64_t vdev, void *tag, int flags) + if (!mg->mg_class->mc_alloc_throttle_enabled) + return; + +- (void) refcount_remove(&mg->mg_alloc_queue_depth, tag); ++ (void) zfs_refcount_remove(&mg->mg_alloc_queue_depth, tag); + } + + void +@@ -2693,7 +2693,7 @@ metaslab_group_alloc_verify(spa_t *spa, const blkptr_t *bp, void *tag) + for (d = 0; d < ndvas; d++) { + uint64_t vdev = DVA_GET_VDEV(&dva[d]); + metaslab_group_t *mg = vdev_lookup_top(spa, vdev)->vdev_mg; +- VERIFY(refcount_not_held(&mg->mg_alloc_queue_depth, tag)); ++ VERIFY(zfs_refcount_not_held(&mg->mg_alloc_queue_depth, tag)); + } + #endif + } +@@ -3348,7 +3348,7 @@ metaslab_class_throttle_reserve(metaslab_class_t *mc, int slots, zio_t *zio, + ASSERT(mc->mc_alloc_throttle_enabled); + mutex_enter(&mc->mc_lock); + +- reserved_slots = refcount_count(&mc->mc_alloc_slots); ++ reserved_slots = zfs_refcount_count(&mc->mc_alloc_slots); + if (reserved_slots < mc->mc_alloc_max_slots) + available_slots = mc->mc_alloc_max_slots - reserved_slots; + +@@ -3360,7 +3360,8 @@ metaslab_class_throttle_reserve(metaslab_class_t *mc, int slots, zio_t *zio, + * them individually when an I/O completes. + */ + for (d = 0; d < slots; d++) { +- reserved_slots = zfs_refcount_add(&mc->mc_alloc_slots, zio); ++ reserved_slots = zfs_refcount_add(&mc->mc_alloc_slots, ++ zio); + } + zio->io_flags |= ZIO_FLAG_IO_ALLOCATING; + slot_reserved = B_TRUE; +@@ -3378,7 +3379,7 @@ metaslab_class_throttle_unreserve(metaslab_class_t *mc, int slots, zio_t *zio) + ASSERT(mc->mc_alloc_throttle_enabled); + mutex_enter(&mc->mc_lock); + for (d = 0; d < slots; d++) { +- (void) refcount_remove(&mc->mc_alloc_slots, zio); ++ (void) zfs_refcount_remove(&mc->mc_alloc_slots, zio); + } + mutex_exit(&mc->mc_lock); + } +diff --git a/module/zfs/refcount.c b/module/zfs/refcount.c +index 13f9bb6b..0a93aafb 100644 +--- a/module/zfs/refcount.c ++++ b/module/zfs/refcount.c +@@ -38,7 +38,7 @@ static kmem_cache_t *reference_cache; + static kmem_cache_t *reference_history_cache; + + void +-refcount_init(void) ++zfs_refcount_init(void) + { + reference_cache = kmem_cache_create("reference_cache", + sizeof (reference_t), 0, NULL, NULL, NULL, NULL, NULL, 0); +@@ -48,14 +48,14 @@ refcount_init(void) + } + + void +-refcount_fini(void) ++zfs_refcount_fini(void) + { + kmem_cache_destroy(reference_cache); + kmem_cache_destroy(reference_history_cache); + } + + void +-refcount_create(zfs_refcount_t *rc) ++zfs_refcount_create(zfs_refcount_t *rc) + { + mutex_init(&rc->rc_mtx, NULL, MUTEX_DEFAULT, NULL); + list_create(&rc->rc_list, sizeof (reference_t), +@@ -68,21 +68,21 @@ refcount_create(zfs_refcount_t *rc) + } + + void +-refcount_create_tracked(zfs_refcount_t *rc) ++zfs_refcount_create_tracked(zfs_refcount_t *rc) + { +- refcount_create(rc); ++ zfs_refcount_create(rc); + rc->rc_tracked = B_TRUE; + } + + void +-refcount_create_untracked(zfs_refcount_t *rc) ++zfs_refcount_create_untracked(zfs_refcount_t *rc) + { +- refcount_create(rc); ++ zfs_refcount_create(rc); + rc->rc_tracked = B_FALSE; + } + + void +-refcount_destroy_many(zfs_refcount_t *rc, uint64_t number) ++zfs_refcount_destroy_many(zfs_refcount_t *rc, uint64_t number) + { + reference_t *ref; + +@@ -103,25 +103,25 @@ refcount_destroy_many(zfs_refcount_t *rc, uint64_t number) + } + + void +-refcount_destroy(zfs_refcount_t *rc) ++zfs_refcount_destroy(zfs_refcount_t *rc) + { +- refcount_destroy_many(rc, 0); ++ zfs_refcount_destroy_many(rc, 0); + } + + int +-refcount_is_zero(zfs_refcount_t *rc) ++zfs_refcount_is_zero(zfs_refcount_t *rc) + { + return (rc->rc_count == 0); + } + + int64_t +-refcount_count(zfs_refcount_t *rc) ++zfs_refcount_count(zfs_refcount_t *rc) + { + return (rc->rc_count); + } + + int64_t +-refcount_add_many(zfs_refcount_t *rc, uint64_t number, void *holder) ++zfs_refcount_add_many(zfs_refcount_t *rc, uint64_t number, void *holder) + { + reference_t *ref = NULL; + int64_t count; +@@ -145,11 +145,11 @@ refcount_add_many(zfs_refcount_t *rc, uint64_t number, void *holder) + int64_t + zfs_refcount_add(zfs_refcount_t *rc, void *holder) + { +- return (refcount_add_many(rc, 1, holder)); ++ return (zfs_refcount_add_many(rc, 1, holder)); + } + + int64_t +-refcount_remove_many(zfs_refcount_t *rc, uint64_t number, void *holder) ++zfs_refcount_remove_many(zfs_refcount_t *rc, uint64_t number, void *holder) + { + reference_t *ref; + int64_t count; +@@ -197,13 +197,13 @@ refcount_remove_many(zfs_refcount_t *rc, uint64_t number, void *holder) + } + + int64_t +-refcount_remove(zfs_refcount_t *rc, void *holder) ++zfs_refcount_remove(zfs_refcount_t *rc, void *holder) + { +- return (refcount_remove_many(rc, 1, holder)); ++ return (zfs_refcount_remove_many(rc, 1, holder)); + } + + void +-refcount_transfer(zfs_refcount_t *dst, zfs_refcount_t *src) ++zfs_refcount_transfer(zfs_refcount_t *dst, zfs_refcount_t *src) + { + int64_t count, removed_count; + list_t list, removed; +@@ -234,7 +234,7 @@ refcount_transfer(zfs_refcount_t *dst, zfs_refcount_t *src) + } + + void +-refcount_transfer_ownership(zfs_refcount_t *rc, void *current_holder, ++zfs_refcount_transfer_ownership(zfs_refcount_t *rc, void *current_holder, + void *new_holder) + { + reference_t *ref; +@@ -264,7 +264,7 @@ refcount_transfer_ownership(zfs_refcount_t *rc, void *current_holder, + * might be held. + */ + boolean_t +-refcount_held(zfs_refcount_t *rc, void *holder) ++zfs_refcount_held(zfs_refcount_t *rc, void *holder) + { + reference_t *ref; + +@@ -292,7 +292,7 @@ refcount_held(zfs_refcount_t *rc, void *holder) + * since the reference might not be held. + */ + boolean_t +-refcount_not_held(zfs_refcount_t *rc, void *holder) ++zfs_refcount_not_held(zfs_refcount_t *rc, void *holder) + { + reference_t *ref; + +diff --git a/module/zfs/rrwlock.c b/module/zfs/rrwlock.c +index effff330..582b40a5 100644 +--- a/module/zfs/rrwlock.c ++++ b/module/zfs/rrwlock.c +@@ -85,7 +85,7 @@ rrn_find(rrwlock_t *rrl) + { + rrw_node_t *rn; + +- if (refcount_count(&rrl->rr_linked_rcount) == 0) ++ if (zfs_refcount_count(&rrl->rr_linked_rcount) == 0) + return (NULL); + + for (rn = tsd_get(rrw_tsd_key); rn != NULL; rn = rn->rn_next) { +@@ -120,7 +120,7 @@ rrn_find_and_remove(rrwlock_t *rrl, void *tag) + rrw_node_t *rn; + rrw_node_t *prev = NULL; + +- if (refcount_count(&rrl->rr_linked_rcount) == 0) ++ if (zfs_refcount_count(&rrl->rr_linked_rcount) == 0) + return (B_FALSE); + + for (rn = tsd_get(rrw_tsd_key); rn != NULL; rn = rn->rn_next) { +@@ -143,8 +143,8 @@ rrw_init(rrwlock_t *rrl, boolean_t track_all) + mutex_init(&rrl->rr_lock, NULL, MUTEX_DEFAULT, NULL); + cv_init(&rrl->rr_cv, NULL, CV_DEFAULT, NULL); + rrl->rr_writer = NULL; +- refcount_create(&rrl->rr_anon_rcount); +- refcount_create(&rrl->rr_linked_rcount); ++ zfs_refcount_create(&rrl->rr_anon_rcount); ++ zfs_refcount_create(&rrl->rr_linked_rcount); + rrl->rr_writer_wanted = B_FALSE; + rrl->rr_track_all = track_all; + } +@@ -155,8 +155,8 @@ rrw_destroy(rrwlock_t *rrl) + mutex_destroy(&rrl->rr_lock); + cv_destroy(&rrl->rr_cv); + ASSERT(rrl->rr_writer == NULL); +- refcount_destroy(&rrl->rr_anon_rcount); +- refcount_destroy(&rrl->rr_linked_rcount); ++ zfs_refcount_destroy(&rrl->rr_anon_rcount); ++ zfs_refcount_destroy(&rrl->rr_linked_rcount); + } + + static void +@@ -173,10 +173,10 @@ rrw_enter_read_impl(rrwlock_t *rrl, boolean_t prio, void *tag) + DTRACE_PROBE(zfs__rrwfastpath__rdmiss); + #endif + ASSERT(rrl->rr_writer != curthread); +- ASSERT(refcount_count(&rrl->rr_anon_rcount) >= 0); ++ ASSERT(zfs_refcount_count(&rrl->rr_anon_rcount) >= 0); + + while (rrl->rr_writer != NULL || (rrl->rr_writer_wanted && +- refcount_is_zero(&rrl->rr_anon_rcount) && !prio && ++ zfs_refcount_is_zero(&rrl->rr_anon_rcount) && !prio && + rrn_find(rrl) == NULL)) + cv_wait(&rrl->rr_cv, &rrl->rr_lock); + +@@ -216,8 +216,8 @@ rrw_enter_write(rrwlock_t *rrl) + mutex_enter(&rrl->rr_lock); + ASSERT(rrl->rr_writer != curthread); + +- while (refcount_count(&rrl->rr_anon_rcount) > 0 || +- refcount_count(&rrl->rr_linked_rcount) > 0 || ++ while (zfs_refcount_count(&rrl->rr_anon_rcount) > 0 || ++ zfs_refcount_count(&rrl->rr_linked_rcount) > 0 || + rrl->rr_writer != NULL) { + rrl->rr_writer_wanted = B_TRUE; + cv_wait(&rrl->rr_cv, &rrl->rr_lock); +@@ -250,24 +250,25 @@ rrw_exit(rrwlock_t *rrl, void *tag) + } + DTRACE_PROBE(zfs__rrwfastpath__exitmiss); + #endif +- ASSERT(!refcount_is_zero(&rrl->rr_anon_rcount) || +- !refcount_is_zero(&rrl->rr_linked_rcount) || ++ ASSERT(!zfs_refcount_is_zero(&rrl->rr_anon_rcount) || ++ !zfs_refcount_is_zero(&rrl->rr_linked_rcount) || + rrl->rr_writer != NULL); + + if (rrl->rr_writer == NULL) { + int64_t count; + if (rrn_find_and_remove(rrl, tag)) { +- count = refcount_remove(&rrl->rr_linked_rcount, tag); ++ count = zfs_refcount_remove( ++ &rrl->rr_linked_rcount, tag); + } else { + ASSERT(!rrl->rr_track_all); +- count = refcount_remove(&rrl->rr_anon_rcount, tag); ++ count = zfs_refcount_remove(&rrl->rr_anon_rcount, tag); + } + if (count == 0) + cv_broadcast(&rrl->rr_cv); + } else { + ASSERT(rrl->rr_writer == curthread); +- ASSERT(refcount_is_zero(&rrl->rr_anon_rcount) && +- refcount_is_zero(&rrl->rr_linked_rcount)); ++ ASSERT(zfs_refcount_is_zero(&rrl->rr_anon_rcount) && ++ zfs_refcount_is_zero(&rrl->rr_linked_rcount)); + rrl->rr_writer = NULL; + cv_broadcast(&rrl->rr_cv); + } +@@ -288,7 +289,7 @@ rrw_held(rrwlock_t *rrl, krw_t rw) + if (rw == RW_WRITER) { + held = (rrl->rr_writer == curthread); + } else { +- held = (!refcount_is_zero(&rrl->rr_anon_rcount) || ++ held = (!zfs_refcount_is_zero(&rrl->rr_anon_rcount) || + rrn_find(rrl) != NULL); + } + mutex_exit(&rrl->rr_lock); +diff --git a/module/zfs/sa.c b/module/zfs/sa.c +index df4f6fd8..08f6165d 100644 +--- a/module/zfs/sa.c ++++ b/module/zfs/sa.c +@@ -1132,7 +1132,7 @@ sa_tear_down(objset_t *os) + avl_destroy_nodes(&sa->sa_layout_hash_tree, &cookie))) { + sa_idx_tab_t *tab; + while ((tab = list_head(&layout->lot_idx_tab))) { +- ASSERT(refcount_count(&tab->sa_refcount)); ++ ASSERT(zfs_refcount_count(&tab->sa_refcount)); + sa_idx_tab_rele(os, tab); + } + } +@@ -1317,13 +1317,13 @@ sa_idx_tab_rele(objset_t *os, void *arg) + return; + + mutex_enter(&sa->sa_lock); +- if (refcount_remove(&idx_tab->sa_refcount, NULL) == 0) { ++ if (zfs_refcount_remove(&idx_tab->sa_refcount, NULL) == 0) { + list_remove(&idx_tab->sa_layout->lot_idx_tab, idx_tab); + if (idx_tab->sa_variable_lengths) + kmem_free(idx_tab->sa_variable_lengths, + sizeof (uint16_t) * + idx_tab->sa_layout->lot_var_sizes); +- refcount_destroy(&idx_tab->sa_refcount); ++ zfs_refcount_destroy(&idx_tab->sa_refcount); + kmem_free(idx_tab->sa_idx_tab, + sizeof (uint32_t) * sa->sa_num_attrs); + kmem_free(idx_tab, sizeof (sa_idx_tab_t)); +@@ -1560,7 +1560,7 @@ sa_find_idx_tab(objset_t *os, dmu_object_type_t bonustype, sa_hdr_phys_t *hdr) + idx_tab->sa_idx_tab = + kmem_zalloc(sizeof (uint32_t) * sa->sa_num_attrs, KM_SLEEP); + idx_tab->sa_layout = tb; +- refcount_create(&idx_tab->sa_refcount); ++ zfs_refcount_create(&idx_tab->sa_refcount); + if (tb->lot_var_sizes) + idx_tab->sa_variable_lengths = kmem_alloc(sizeof (uint16_t) * + tb->lot_var_sizes, KM_SLEEP); +diff --git a/module/zfs/spa.c b/module/zfs/spa.c +index 02dda927..5002b3cb 100644 +--- a/module/zfs/spa.c ++++ b/module/zfs/spa.c +@@ -2302,7 +2302,7 @@ spa_load(spa_t *spa, spa_load_state_t state, spa_import_type_t type, + * and are making their way through the eviction process. + */ + spa_evicting_os_wait(spa); +- spa->spa_minref = refcount_count(&spa->spa_refcount); ++ spa->spa_minref = zfs_refcount_count(&spa->spa_refcount); + if (error) { + if (error != EEXIST) { + spa->spa_loaded_ts.tv_sec = 0; +@@ -4260,7 +4260,7 @@ spa_create(const char *pool, nvlist_t *nvroot, nvlist_t *props, + * and are making their way through the eviction process. + */ + spa_evicting_os_wait(spa); +- spa->spa_minref = refcount_count(&spa->spa_refcount); ++ spa->spa_minref = zfs_refcount_count(&spa->spa_refcount); + spa->spa_load_state = SPA_LOAD_NONE; + + mutex_exit(&spa_namespace_lock); +@@ -6852,12 +6852,12 @@ spa_sync(spa_t *spa, uint64_t txg) + * allocations look at mg_max_alloc_queue_depth, and async + * allocations all happen from spa_sync(). + */ +- ASSERT0(refcount_count(&mg->mg_alloc_queue_depth)); ++ ASSERT0(zfs_refcount_count(&mg->mg_alloc_queue_depth)); + mg->mg_max_alloc_queue_depth = max_queue_depth; + queue_depth_total += mg->mg_max_alloc_queue_depth; + } + mc = spa_normal_class(spa); +- ASSERT0(refcount_count(&mc->mc_alloc_slots)); ++ ASSERT0(zfs_refcount_count(&mc->mc_alloc_slots)); + mc->mc_alloc_max_slots = queue_depth_total; + mc->mc_alloc_throttle_enabled = zio_dva_throttle_enabled; + +diff --git a/module/zfs/spa_misc.c b/module/zfs/spa_misc.c +index f6c9b40b..6514813e 100644 +--- a/module/zfs/spa_misc.c ++++ b/module/zfs/spa_misc.c +@@ -366,7 +366,7 @@ spa_config_lock_init(spa_t *spa) + spa_config_lock_t *scl = &spa->spa_config_lock[i]; + mutex_init(&scl->scl_lock, NULL, MUTEX_DEFAULT, NULL); + cv_init(&scl->scl_cv, NULL, CV_DEFAULT, NULL); +- refcount_create_untracked(&scl->scl_count); ++ zfs_refcount_create_untracked(&scl->scl_count); + scl->scl_writer = NULL; + scl->scl_write_wanted = 0; + } +@@ -381,7 +381,7 @@ spa_config_lock_destroy(spa_t *spa) + spa_config_lock_t *scl = &spa->spa_config_lock[i]; + mutex_destroy(&scl->scl_lock); + cv_destroy(&scl->scl_cv); +- refcount_destroy(&scl->scl_count); ++ zfs_refcount_destroy(&scl->scl_count); + ASSERT(scl->scl_writer == NULL); + ASSERT(scl->scl_write_wanted == 0); + } +@@ -406,7 +406,7 @@ spa_config_tryenter(spa_t *spa, int locks, void *tag, krw_t rw) + } + } else { + ASSERT(scl->scl_writer != curthread); +- if (!refcount_is_zero(&scl->scl_count)) { ++ if (!zfs_refcount_is_zero(&scl->scl_count)) { + mutex_exit(&scl->scl_lock); + spa_config_exit(spa, locks & ((1 << i) - 1), + tag); +@@ -441,7 +441,7 @@ spa_config_enter(spa_t *spa, int locks, void *tag, krw_t rw) + } + } else { + ASSERT(scl->scl_writer != curthread); +- while (!refcount_is_zero(&scl->scl_count)) { ++ while (!zfs_refcount_is_zero(&scl->scl_count)) { + scl->scl_write_wanted++; + cv_wait(&scl->scl_cv, &scl->scl_lock); + scl->scl_write_wanted--; +@@ -464,8 +464,8 @@ spa_config_exit(spa_t *spa, int locks, void *tag) + if (!(locks & (1 << i))) + continue; + mutex_enter(&scl->scl_lock); +- ASSERT(!refcount_is_zero(&scl->scl_count)); +- if (refcount_remove(&scl->scl_count, tag) == 0) { ++ ASSERT(!zfs_refcount_is_zero(&scl->scl_count)); ++ if (zfs_refcount_remove(&scl->scl_count, tag) == 0) { + ASSERT(scl->scl_writer == NULL || + scl->scl_writer == curthread); + scl->scl_writer = NULL; /* OK in either case */ +@@ -484,7 +484,8 @@ spa_config_held(spa_t *spa, int locks, krw_t rw) + spa_config_lock_t *scl = &spa->spa_config_lock[i]; + if (!(locks & (1 << i))) + continue; +- if ((rw == RW_READER && !refcount_is_zero(&scl->scl_count)) || ++ if ((rw == RW_READER && ++ !zfs_refcount_is_zero(&scl->scl_count)) || + (rw == RW_WRITER && scl->scl_writer == curthread)) + locks_held |= 1 << i; + } +@@ -602,7 +603,7 @@ spa_add(const char *name, nvlist_t *config, const char *altroot) + + spa->spa_deadman_synctime = MSEC2NSEC(zfs_deadman_synctime_ms); + +- refcount_create(&spa->spa_refcount); ++ zfs_refcount_create(&spa->spa_refcount); + spa_config_lock_init(spa); + spa_stats_init(spa); + +@@ -680,7 +681,7 @@ spa_remove(spa_t *spa) + + ASSERT(MUTEX_HELD(&spa_namespace_lock)); + ASSERT(spa->spa_state == POOL_STATE_UNINITIALIZED); +- ASSERT3U(refcount_count(&spa->spa_refcount), ==, 0); ++ ASSERT3U(zfs_refcount_count(&spa->spa_refcount), ==, 0); + + nvlist_free(spa->spa_config_splitting); + +@@ -705,7 +706,7 @@ spa_remove(spa_t *spa) + nvlist_free(spa->spa_feat_stats); + spa_config_set(spa, NULL); + +- refcount_destroy(&spa->spa_refcount); ++ zfs_refcount_destroy(&spa->spa_refcount); + + spa_stats_destroy(spa); + spa_config_lock_destroy(spa); +@@ -766,7 +767,7 @@ spa_next(spa_t *prev) + void + spa_open_ref(spa_t *spa, void *tag) + { +- ASSERT(refcount_count(&spa->spa_refcount) >= spa->spa_minref || ++ ASSERT(zfs_refcount_count(&spa->spa_refcount) >= spa->spa_minref || + MUTEX_HELD(&spa_namespace_lock)); + (void) zfs_refcount_add(&spa->spa_refcount, tag); + } +@@ -778,9 +779,9 @@ spa_open_ref(spa_t *spa, void *tag) + void + spa_close(spa_t *spa, void *tag) + { +- ASSERT(refcount_count(&spa->spa_refcount) > spa->spa_minref || ++ ASSERT(zfs_refcount_count(&spa->spa_refcount) > spa->spa_minref || + MUTEX_HELD(&spa_namespace_lock)); +- (void) refcount_remove(&spa->spa_refcount, tag); ++ (void) zfs_refcount_remove(&spa->spa_refcount, tag); + } + + /* +@@ -794,7 +795,7 @@ spa_close(spa_t *spa, void *tag) + void + spa_async_close(spa_t *spa, void *tag) + { +- (void) refcount_remove(&spa->spa_refcount, tag); ++ (void) zfs_refcount_remove(&spa->spa_refcount, tag); + } + + /* +@@ -807,7 +808,7 @@ spa_refcount_zero(spa_t *spa) + { + ASSERT(MUTEX_HELD(&spa_namespace_lock)); + +- return (refcount_count(&spa->spa_refcount) == spa->spa_minref); ++ return (zfs_refcount_count(&spa->spa_refcount) == spa->spa_minref); + } + + /* +@@ -1878,7 +1879,7 @@ spa_init(int mode) + #endif + + fm_init(); +- refcount_init(); ++ zfs_refcount_init(); + unique_init(); + range_tree_init(); + metaslab_alloc_trace_init(); +@@ -1914,7 +1915,7 @@ spa_fini(void) + metaslab_alloc_trace_fini(); + range_tree_fini(); + unique_fini(); +- refcount_fini(); ++ zfs_refcount_fini(); + fm_fini(); + qat_fini(); + +diff --git a/module/zfs/zfs_ctldir.c b/module/zfs/zfs_ctldir.c +index de3c5a41..2964b65a 100644 +--- a/module/zfs/zfs_ctldir.c ++++ b/module/zfs/zfs_ctldir.c +@@ -144,7 +144,7 @@ zfsctl_snapshot_alloc(char *full_name, char *full_path, spa_t *spa, + se->se_root_dentry = root_dentry; + se->se_taskqid = TASKQID_INVALID; + +- refcount_create(&se->se_refcount); ++ zfs_refcount_create(&se->se_refcount); + + return (se); + } +@@ -156,7 +156,7 @@ zfsctl_snapshot_alloc(char *full_name, char *full_path, spa_t *spa, + static void + zfsctl_snapshot_free(zfs_snapentry_t *se) + { +- refcount_destroy(&se->se_refcount); ++ zfs_refcount_destroy(&se->se_refcount); + strfree(se->se_name); + strfree(se->se_path); + +@@ -179,7 +179,7 @@ zfsctl_snapshot_hold(zfs_snapentry_t *se) + static void + zfsctl_snapshot_rele(zfs_snapentry_t *se) + { +- if (refcount_remove(&se->se_refcount, NULL) == 0) ++ if (zfs_refcount_remove(&se->se_refcount, NULL) == 0) + zfsctl_snapshot_free(se); + } + +diff --git a/module/zfs/zfs_znode.c b/module/zfs/zfs_znode.c +index 0ca10f82..7b893dc7 100644 +--- a/module/zfs/zfs_znode.c ++++ b/module/zfs/zfs_znode.c +@@ -149,7 +149,7 @@ zfs_znode_hold_cache_constructor(void *buf, void *arg, int kmflags) + znode_hold_t *zh = buf; + + mutex_init(&zh->zh_lock, NULL, MUTEX_DEFAULT, NULL); +- refcount_create(&zh->zh_refcount); ++ zfs_refcount_create(&zh->zh_refcount); + zh->zh_obj = ZFS_NO_OBJECT; + + return (0); +@@ -161,7 +161,7 @@ zfs_znode_hold_cache_destructor(void *buf, void *arg) + znode_hold_t *zh = buf; + + mutex_destroy(&zh->zh_lock); +- refcount_destroy(&zh->zh_refcount); ++ zfs_refcount_destroy(&zh->zh_refcount); + } + + void +@@ -279,7 +279,7 @@ zfs_znode_hold_enter(zfsvfs_t *zfsvfs, uint64_t obj) + kmem_cache_free(znode_hold_cache, zh_new); + + ASSERT(MUTEX_NOT_HELD(&zh->zh_lock)); +- ASSERT3S(refcount_count(&zh->zh_refcount), >, 0); ++ ASSERT3S(zfs_refcount_count(&zh->zh_refcount), >, 0); + mutex_enter(&zh->zh_lock); + + return (zh); +@@ -292,11 +292,11 @@ zfs_znode_hold_exit(zfsvfs_t *zfsvfs, znode_hold_t *zh) + boolean_t remove = B_FALSE; + + ASSERT(zfs_znode_held(zfsvfs, zh->zh_obj)); +- ASSERT3S(refcount_count(&zh->zh_refcount), >, 0); ++ ASSERT3S(zfs_refcount_count(&zh->zh_refcount), >, 0); + mutex_exit(&zh->zh_lock); + + mutex_enter(&zfsvfs->z_hold_locks[i]); +- if (refcount_remove(&zh->zh_refcount, NULL) == 0) { ++ if (zfs_refcount_remove(&zh->zh_refcount, NULL) == 0) { + avl_remove(&zfsvfs->z_hold_trees[i], zh); + remove = B_TRUE; + } +diff --git a/module/zfs/zio.c b/module/zfs/zio.c +index dd0dfcdb..3f8fca38 100644 +--- a/module/zfs/zio.c ++++ b/module/zfs/zio.c +@@ -2338,7 +2338,7 @@ zio_write_gang_block(zio_t *pio) + ASSERT(!(pio->io_flags & ZIO_FLAG_NODATA)); + + flags |= METASLAB_ASYNC_ALLOC; +- VERIFY(refcount_held(&mc->mc_alloc_slots, pio)); ++ VERIFY(zfs_refcount_held(&mc->mc_alloc_slots, pio)); + + /* + * The logical zio has already placed a reservation for +@@ -3766,7 +3766,7 @@ zio_done(zio_t *zio) + ASSERT(zio->io_priority == ZIO_PRIORITY_ASYNC_WRITE); + ASSERT(zio->io_bp != NULL); + metaslab_group_alloc_verify(zio->io_spa, zio->io_bp, zio); +- VERIFY(refcount_not_held( ++ VERIFY(zfs_refcount_not_held( + &(spa_normal_class(zio->io_spa)->mc_alloc_slots), zio)); + } + diff --git a/zfs-patches/0015-Fix-arc_release-refcount.patch b/zfs-patches/0015-Fix-arc_release-refcount.patch new file mode 100644 index 0000000..9cee846 --- /dev/null +++ b/zfs-patches/0015-Fix-arc_release-refcount.patch @@ -0,0 +1,29 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Brian Behlendorf +Date: Mon, 8 Oct 2018 14:59:34 -0700 +Subject: [PATCH] Fix arc_release() refcount + +Update arc_release to use arc_buf_size(). This hunk was accidentally +dropped when porting compressed send/recv, 2aa34383b. + +Reviewed-by: Matthew Ahrens +Signed-off-by: Tom Caputi +Signed-off-by: Brian Behlendorf +Closes #8000 +--- + module/zfs/arc.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/module/zfs/arc.c b/module/zfs/arc.c +index 32ac0837..a7fb2429 100644 +--- a/module/zfs/arc.c ++++ b/module/zfs/arc.c +@@ -5831,7 +5831,7 @@ arc_release(arc_buf_t *buf, void *tag) + + mutex_exit(&buf->b_evict_lock); + (void) zfs_refcount_add_many(&arc_anon->arcs_size, +- HDR_GET_LSIZE(nhdr), buf); ++ arc_buf_size(buf), buf); + } else { + mutex_exit(&buf->b_evict_lock); + ASSERT(zfs_refcount_count(&hdr->b_l1hdr.b_refcnt) == 1); diff --git a/zfs-patches/0016-Allow-use-of-pool-GUID-as-root-pool.patch b/zfs-patches/0016-Allow-use-of-pool-GUID-as-root-pool.patch new file mode 100644 index 0000000..435a6dc --- /dev/null +++ b/zfs-patches/0016-Allow-use-of-pool-GUID-as-root-pool.patch @@ -0,0 +1,59 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: George Melikov +Date: Wed, 24 Oct 2018 06:06:40 +0300 +Subject: [PATCH] Allow use of pool GUID as root pool +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +It's helpful if there are pools with same names, +but you need to use only one of them. + +Main case is twin servers, meanwhile some software +requires the same name of pools (e.g. Proxmox). + +Reviewed-by: Kash Pande +Reviewed-by: Brian Behlendorf +Signed-off-by: George Melikov +Signed-off-by: Igor ‘guardian’ Lidin of Moscow, Russia +Closes #8052 +--- + contrib/initramfs/scripts/zfs | 11 ++++++++++- + 1 file changed, 10 insertions(+), 1 deletion(-) + +diff --git a/contrib/initramfs/scripts/zfs b/contrib/initramfs/scripts/zfs +index 86329e76..dacd71d2 100644 +--- a/contrib/initramfs/scripts/zfs ++++ b/contrib/initramfs/scripts/zfs +@@ -193,7 +193,7 @@ import_pool() + + # Verify that the pool isn't already imported + # Make as sure as we can to not require '-f' to import. +- "${ZPOOL}" status "$pool" > /dev/null 2>&1 && return 0 ++ "${ZPOOL}" get name,guid -o value -H 2>/dev/null | grep -Fxq "$pool" && return 0 + + # For backwards compatibility, make sure that ZPOOL_IMPORT_PATH is set + # to something we can use later with the real import(s). We want to +@@ -772,6 +772,7 @@ mountroot() + # root=zfs:/ (uses this for rpool - first part, without 'zfs:') + # + # Option could also be ++ # Option could also be + + # ------------ + # Support force option +@@ -889,6 +890,14 @@ mountroot() + /bin/sh + fi + ++ # In case the pool was specified as guid, resolve guid to name ++ pool="$("${ZPOOL}" get name,guid -o name,value -H | \ ++ awk -v pool="${ZFS_RPOOL}" '$2 == pool { print $1 }')" ++ if [ -n "$pool" ]; then ++ ZFS_BOOTFS="${pool}/${ZFS_BOOTFS#*/}" ++ ZFS_RPOOL="${pool}" ++ fi ++ + # Set elevator=noop on the root pool's vdevs' disks. ZFS already + # does this for wholedisk vdevs (for all pools), so this is only + # important for partitions. diff --git a/zfs-patches/0017-ZTS-Update-O_TMPFILE-support-check.patch b/zfs-patches/0017-ZTS-Update-O_TMPFILE-support-check.patch new file mode 100644 index 0000000..439529f --- /dev/null +++ b/zfs-patches/0017-ZTS-Update-O_TMPFILE-support-check.patch @@ -0,0 +1,67 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Brian Behlendorf +Date: Mon, 14 May 2018 20:36:30 -0700 +Subject: [PATCH] ZTS: Update O_TMPFILE support check + +In CentOS 7.5 the kernel provided a compatibility wrapper to support +O_TMPFILE. This results in the test setup script correctly detecting +kernel support. But the ZFS module was built without O_TMPFILE +support due to the non-standard CentOS kernel interface. + +Handle this case by updating the setup check to fail either when +the kernel or the ZFS module fail to provide support. The reason +will be clearly logged in the test results. + +Reviewed-by: Chunwei Chen +Signed-off-by: Brian Behlendorf +Closes #7528 +--- + tests/zfs-tests/tests/functional/tmpfile/setup.ksh | 11 +++++++---- + tests/zfs-tests/tests/functional/tmpfile/tmpfile_test.c | 11 ++++++----- + 2 files changed, 13 insertions(+), 9 deletions(-) + +diff --git a/tests/zfs-tests/tests/functional/tmpfile/setup.ksh b/tests/zfs-tests/tests/functional/tmpfile/setup.ksh +index 243a5b77..bc00a2a2 100755 +--- a/tests/zfs-tests/tests/functional/tmpfile/setup.ksh ++++ b/tests/zfs-tests/tests/functional/tmpfile/setup.ksh +@@ -31,9 +31,12 @@ + + . $STF_SUITE/include/libtest.shlib + +-if ! $STF_SUITE/tests/functional/tmpfile/tmpfile_test /tmp; then +- log_unsupported "The kernel doesn't support O_TMPFILE." ++DISK=${DISKS%% *} ++default_setup_noexit $DISK ++ ++if ! $STF_SUITE/tests/functional/tmpfile/tmpfile_test $TESTDIR; then ++ default_cleanup_noexit ++ log_unsupported "The kernel/filesystem doesn't support O_TMPFILE" + fi + +-DISK=${DISKS%% *} +-default_setup $DISK ++log_pass +diff --git a/tests/zfs-tests/tests/functional/tmpfile/tmpfile_test.c b/tests/zfs-tests/tests/functional/tmpfile/tmpfile_test.c +index 5fb67b47..91527ac5 100644 +--- a/tests/zfs-tests/tests/functional/tmpfile/tmpfile_test.c ++++ b/tests/zfs-tests/tests/functional/tmpfile/tmpfile_test.c +@@ -36,13 +36,14 @@ main(int argc, char *argv[]) + + fd = open(argv[1], O_TMPFILE | O_WRONLY, 0666); + if (fd < 0) { +- /* +- * Only fail on EISDIR. If we get EOPNOTSUPP, that means +- * kernel support O_TMPFILE, but the path at argv[1] doesn't. +- */ + if (errno == EISDIR) { +- fprintf(stderr, "kernel doesn't support O_TMPFILE\n"); ++ fprintf(stderr, ++ "The kernel doesn't support O_TMPFILE\n"); + return (1); ++ } else if (errno == EOPNOTSUPP) { ++ fprintf(stderr, ++ "The filesystem doesn't support O_TMPFILE\n"); ++ return (2); + } + perror("open"); + } else { diff --git a/zfs-patches/0018-Fix-flake8-invalid-escape-sequence-x-warning.patch b/zfs-patches/0018-Fix-flake8-invalid-escape-sequence-x-warning.patch new file mode 100644 index 0000000..57fd42b --- /dev/null +++ b/zfs-patches/0018-Fix-flake8-invalid-escape-sequence-x-warning.patch @@ -0,0 +1,35 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Brian Behlendorf +Date: Wed, 24 Oct 2018 23:26:08 -0700 +Subject: [PATCH] Fix flake8 "invalid escape sequence 'x'" warning + +From, https://lintlyci.github.io/Flake8Rules/rules/W605.html + +As of Python 3.6, a backslash-character pair that is not a valid +escape sequence now generates a DeprecationWarning. Although this +will eventually become a SyntaxError, that will not be for several +Python releases. + +Note 'float_pobj' was simply removed from arcstat.py since it +was entirely unused. + +Reviewed-by: John Kennedy +Reviewed-by: Richard Elling +Signed-off-by: Brian Behlendorf +Closes #8056 +--- + cmd/arcstat/arcstat.py | 1 - + 1 file changed, 1 deletion(-) + +diff --git a/cmd/arcstat/arcstat.py b/cmd/arcstat/arcstat.py +index b52a8c29..d7d3e9b7 100755 +--- a/cmd/arcstat/arcstat.py ++++ b/cmd/arcstat/arcstat.py +@@ -112,7 +112,6 @@ cur = {} + d = {} + out = None + kstat = None +-float_pobj = re.compile("^[0-9]+(\.[0-9]+)?$") + + + def detailed_usage(): diff --git a/zfs-patches/0019-Add-BuildRequires-gcc-make-elfutils-libelf-devel.patch b/zfs-patches/0019-Add-BuildRequires-gcc-make-elfutils-libelf-devel.patch new file mode 100644 index 0000000..b56b4c3 --- /dev/null +++ b/zfs-patches/0019-Add-BuildRequires-gcc-make-elfutils-libelf-devel.patch @@ -0,0 +1,51 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Tony Hutter +Date: Wed, 7 Nov 2018 15:48:24 -0800 +Subject: [PATCH] Add BuildRequires gcc, make, elfutils-libelf-devel + +This adds a BuildRequires for gcc, make, and elfutils-libelf-devel +into our spec files. gcc has been a packaging requirement for +awhile now: + +https://fedoraproject.org/wiki/Packaging:C_and_C%2B%2B + +These additional BuildRequires allow us to mock build in +Fedora 29. + +Reviewed-by: Neal Gompa +Reviewed-by: Brian Behlendorf +Signed-off-by: Tony Hutter +Closes #8095 +Closes #8102 +--- + rpm/generic/zfs-kmod.spec.in | 4 ++++ + rpm/generic/zfs.spec.in | 1 + + 2 files changed, 5 insertions(+) + +diff --git a/rpm/generic/zfs-kmod.spec.in b/rpm/generic/zfs-kmod.spec.in +index d4746f5b..ecf14ece 100644 +--- a/rpm/generic/zfs-kmod.spec.in ++++ b/rpm/generic/zfs-kmod.spec.in +@@ -52,6 +52,10 @@ URL: http://zfsonlinux.org/ + Source0: %{module}-%{version}.tar.gz + Source10: kmodtool + BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id} -u -n) ++%if 0%{?rhel}%{?fedora} ++BuildRequires: gcc, make ++BuildRequires: elfutils-libelf-devel ++%endif + + # The developments headers will conflict with the dkms packages. + Conflicts: %{module}-dkms +diff --git a/rpm/generic/zfs.spec.in b/rpm/generic/zfs.spec.in +index fa6f1571..c1b8f2c8 100644 +--- a/rpm/generic/zfs.spec.in ++++ b/rpm/generic/zfs.spec.in +@@ -91,6 +91,7 @@ Provides: %{name}-kmod-common = %{version} + Conflicts: zfs-fuse + + %if 0%{?rhel}%{?fedora}%{?suse_version} ++BuildRequires: gcc, make + BuildRequires: zlib-devel + BuildRequires: libuuid-devel + BuildRequires: libblkid-devel diff --git a/zfs-patches/0020-Tag-zfs-0.7.12.patch b/zfs-patches/0020-Tag-zfs-0.7.12.patch new file mode 100644 index 0000000..ef3d9fc --- /dev/null +++ b/zfs-patches/0020-Tag-zfs-0.7.12.patch @@ -0,0 +1,55 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Tony Hutter +Date: Thu, 8 Nov 2018 14:38:37 -0800 +Subject: [PATCH] Tag zfs-0.7.12 + +META file and changelog updated. + +Signed-off-by: Tony Hutter +--- + META | 2 +- + rpm/generic/zfs-kmod.spec.in | 3 +++ + rpm/generic/zfs.spec.in | 3 +++ + 3 files changed, 7 insertions(+), 1 deletion(-) + +diff --git a/META b/META +index 4b0cdb9c..8631f885 100644 +--- a/META ++++ b/META +@@ -1,7 +1,7 @@ + Meta: 1 + Name: zfs + Branch: 1.0 +-Version: 0.7.11 ++Version: 0.7.12 + Release: 1 + Release-Tags: relext + License: CDDL +diff --git a/rpm/generic/zfs-kmod.spec.in b/rpm/generic/zfs-kmod.spec.in +index ecf14ece..3b97e91d 100644 +--- a/rpm/generic/zfs-kmod.spec.in ++++ b/rpm/generic/zfs-kmod.spec.in +@@ -195,6 +195,9 @@ chmod u+x ${RPM_BUILD_ROOT}%{kmodinstdir_prefix}/*/extra/*/*/* + rm -rf $RPM_BUILD_ROOT + + %changelog ++* Thu Nov 08 2018 Tony Hutter - 0.7.12-1 ++- Released 0.7.12-1, detailed release notes are available at: ++- https://github.com/zfsonlinux/zfs/releases/tag/zfs-0.7.12 + * Thu Sep 13 2018 Tony Hutter - 0.7.11-1 + - Released 0.7.11-1, detailed release notes are available at: + - https://github.com/zfsonlinux/zfs/releases/tag/zfs-0.7.11 +diff --git a/rpm/generic/zfs.spec.in b/rpm/generic/zfs.spec.in +index c1b8f2c8..f28793a8 100644 +--- a/rpm/generic/zfs.spec.in ++++ b/rpm/generic/zfs.spec.in +@@ -372,6 +372,9 @@ systemctl --system daemon-reload >/dev/null || true + %endif + + %changelog ++* Thu Nov 08 2018 Tony Hutter - 0.7.12-1 ++- Released 0.7.12-1, detailed release notes are available at: ++- https://github.com/zfsonlinux/zfs/releases/tag/zfs-0.7.12 + * Thu Sep 13 2018 Tony Hutter - 0.7.11-1 + - Released 0.7.11-1, detailed release notes are available at: + - https://github.com/zfsonlinux/zfs/releases/tag/zfs-0.7.11 diff --git a/zfs-patches/series b/zfs-patches/series index 756a299..cbeff2d 100644 --- a/zfs-patches/series +++ b/zfs-patches/series @@ -1,9 +1,20 @@ 0001-remove-DKMS-modules-and-dracut-build.patch 0002-import-with-d-dev-disk-by-id-in-scan-service.patch 0003-always-load-ZFS-module-on-boot.patch -0004-Fix-deadlock-between-zfs-umount-snapentry_expire.patch -0005-Fix-race-in-dnode_check_slots_free.patch -0006-Reduce-taskq-and-context-switch-cost-of-zio-pipe.patch +0004-Add-Breaks-Replaces-to-zfs-initramfs.patch +0005-Revert-Install-init-scripts-to-support-non-systemd-s.patch +0006-Fix-deadlock-between-zfs-umount-snapentry_expire.patch 0007-deadlock-between-mm_sem-and-tx-assign-in-zfs_write-a.patch -0008-Add-Breaks-Replaces-to-zfs-initramfs.patch -0009-Revert-Install-init-scripts-to-support-non-systemd-s.patch +0008-Fix-race-in-dnode_check_slots_free.patch +0009-Reduce-taskq-and-context-switch-cost-of-zio-pipe.patch +0010-Skip-import-activity-test-in-more-zdb-code-paths.patch +0011-Fix-statfs-2-for-32-bit-user-space.patch +0012-Zpool-iostat-remove-latency-queue-scaling.patch +0013-Linux-4.19-rc3-compat-Remove-refcount_t-compat.patch +0014-Prefix-all-refcount-functions-with-zfs_.patch +0015-Fix-arc_release-refcount.patch +0016-Allow-use-of-pool-GUID-as-root-pool.patch +0017-ZTS-Update-O_TMPFILE-support-check.patch +0018-Fix-flake8-invalid-escape-sequence-x-warning.patch +0019-Add-BuildRequires-gcc-make-elfutils-libelf-devel.patch +0020-Tag-zfs-0.7.12.patch -- 2.39.2