--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Stoiko Ivanov <s.ivanov@proxmox.com>
+Date: Mon, 29 Oct 2018 15:49:20 +0100
+Subject: [PATCH] Add Breaks/Replaces to zfs-initramfs
+
+addressing the move of zdev initramfs hook from zfsutils-linux to
+zfs-initramfs
+
+Signed-off-by: Stoiko Ivanov <s.ivanov@proxmox.com>
+---
+ debian/control | 2 ++
+ debian/control.in | 2 ++
+ 2 files changed, 4 insertions(+)
+
+diff --git a/debian/control b/debian/control
+index f33008df..d3d1034e 100644
+--- a/debian/control
++++ b/debian/control
+@@ -116,6 +116,8 @@ Depends: busybox-initramfs | busybox-static | busybox,
+ zfs-modules | zfs-dkms,
+ zfsutils-linux (>= ${binary:Version}),
+ ${misc:Depends}
++Breaks: zfsutils-linux (<= 0.7.11-pve1~bpo1)
++Replaces: zfsutils-linux (<= 0.7.11-pve1~bpo1)
+ 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
+diff --git a/debian/control.in b/debian/control.in
+index 0a9ceef6..09ef18cc 100644
+--- a/debian/control.in
++++ b/debian/control.in
+@@ -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)
++Replaces: zfsutils-linux (<= 0.7.11-pve1~bpo1)
+ 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
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Rohan Puri <rohan.puri15@gmail.com>
-Date: Sat, 28 Jul 2018 18:32:12 +0530
-Subject: [PATCH] Fix deadlock between zfs umount & snapentry_expire
-
-zfs umount -> zfsctl_destroy() takes the zfs_snapshot_lock as a
-writer and calls zfsctl_snapshot_unmount_cancel(), which waits
-for snapentry_expire() if present (when snap is automounted).
-This snapentry_expire() itself then waits for zfs_snapshot_lock
-as a reader, resulting in a deadlock.
-
-The fix is to only hold the zfs_snapshot_lock over the tree
-lookup and removal. After a successful lookup the lock can
-be dropped and zfs_snapentry_t will remain valid until the
-reference taken by the lookup is released.
-
-Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
-Signed-off-by: Rohan Puri <rohan.puri15@gmail.com>
-Closes #7751
-Closes #7752
-
-(Cherry-picked from fd7265c646f40e364396af5014bbb83e809e124a)
-Signed-off-by: Stoiko Ivanov <s.ivanov@proxmox.com>
-
-Signed-off-by: Stoiko Ivanov <s.ivanov@proxmox.com>
----
- module/zfs/zfs_ctldir.c | 11 +++++------
- 1 file changed, 5 insertions(+), 6 deletions(-)
-
-diff --git a/module/zfs/zfs_ctldir.c b/module/zfs/zfs_ctldir.c
-index 98897fe6..0ab5b4f0 100644
---- a/module/zfs/zfs_ctldir.c
-+++ b/module/zfs/zfs_ctldir.c
-@@ -358,8 +358,6 @@ snapentry_expire(void *data)
- static void
- zfsctl_snapshot_unmount_cancel(zfs_snapentry_t *se)
- {
-- ASSERT(RW_LOCK_HELD(&zfs_snapshot_lock));
--
- if (taskq_cancel_id(system_delay_taskq, se->se_taskqid) == 0) {
- se->se_taskqid = TASKQID_INVALID;
- zfsctl_snapshot_rele(se);
-@@ -570,13 +568,14 @@ zfsctl_destroy(zfsvfs_t *zfsvfs)
- uint64_t objsetid = dmu_objset_id(zfsvfs->z_os);
-
- rw_enter(&zfs_snapshot_lock, RW_WRITER);
-- if ((se = zfsctl_snapshot_find_by_objsetid(spa, objsetid))
-- != NULL) {
-- zfsctl_snapshot_unmount_cancel(se);
-+ se = zfsctl_snapshot_find_by_objsetid(spa, objsetid);
-+ if (se != NULL)
- zfsctl_snapshot_remove(se);
-+ rw_exit(&zfs_snapshot_lock);
-+ if (se != NULL) {
-+ zfsctl_snapshot_unmount_cancel(se);
- zfsctl_snapshot_rele(se);
- }
-- rw_exit(&zfs_snapshot_lock);
- } else if (zfsvfs->z_ctldir) {
- iput(zfsvfs->z_ctldir);
- zfsvfs->z_ctldir = NULL;
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Tom Caputi <tcaputi@datto.com>
-Date: Tue, 10 Apr 2018 14:15:05 -0400
-Subject: [PATCH] Fix race in dnode_check_slots_free()
-
-Currently, dnode_check_slots_free() works by checking dn->dn_type
-in the dnode to determine if the dnode is reclaimable. However,
-there is a small window of time between dnode_free_sync() in the
-first call to dsl_dataset_sync() and when the useraccounting code
-is run when the type is set DMU_OT_NONE, but the dnode is not yet
-evictable, leading to crashes. This patch adds the ability for
-dnodes to track which txg they were last dirtied in and adds a
-check for this before performing the reclaim.
-
-This patch also corrects several instances when dn_dirty_link was
-treated as a list_node_t when it is technically a multilist_node_t.
-
-Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
-Signed-off-by: Tom Caputi <tcaputi@datto.com>
-Requires-spl: spl-0.7-release
-Issue #7147
-Issue #7388
-Issue #7997
-
-(cherry-picked from behlendorf/issue-7997 4764f6f3be90be073d2700653dff286371e52583)
-Signed-off-by: Stoiko Ivanov <s.ivanov@proxmox.com>
----
- include/sys/dmu_impl.h | 1 +
- include/sys/dnode.h | 4 ++++
- module/zfs/dbuf.c | 3 +++
- module/zfs/dmu.c | 2 +-
- module/zfs/dmu_objset.c | 15 +++++++++++++++
- module/zfs/dnode.c | 29 +++++++++++++++++++----------
- 6 files changed, 43 insertions(+), 11 deletions(-)
-
-diff --git a/include/sys/dmu_impl.h b/include/sys/dmu_impl.h
-index 65e417e3..03a63077 100644
---- a/include/sys/dmu_impl.h
-+++ b/include/sys/dmu_impl.h
-@@ -161,6 +161,7 @@ extern "C" {
- * dn_allocated_txg
- * dn_free_txg
- * dn_assigned_txg
-+ * dn_dirty_txg
- * dd_assigned_tx
- * dn_notxholds
- * dn_dirtyctx
-diff --git a/include/sys/dnode.h b/include/sys/dnode.h
-index ea7defe1..2dd087b3 100644
---- a/include/sys/dnode.h
-+++ b/include/sys/dnode.h
-@@ -260,6 +260,7 @@ struct dnode {
- uint64_t dn_allocated_txg;
- uint64_t dn_free_txg;
- uint64_t dn_assigned_txg;
-+ uint64_t dn_dirty_txg; /* txg dnode was last dirtied */
- kcondvar_t dn_notxholds;
- enum dnode_dirtycontext dn_dirtyctx;
- uint8_t *dn_dirtyctx_firstset; /* dbg: contents meaningless */
-@@ -362,6 +363,9 @@ void dnode_evict_dbufs(dnode_t *dn);
- void dnode_evict_bonus(dnode_t *dn);
- void dnode_free_interior_slots(dnode_t *dn);
-
-+#define DNODE_IS_DIRTY(_dn) \
-+ ((_dn)->dn_dirty_txg >= spa_syncing_txg((_dn)->dn_objset->os_spa))
-+
- #define DNODE_IS_CACHEABLE(_dn) \
- ((_dn)->dn_objset->os_primary_cache == ZFS_CACHE_ALL || \
- (DMU_OT_IS_METADATA((_dn)->dn_type) && \
-diff --git a/module/zfs/dbuf.c b/module/zfs/dbuf.c
-index 4ee121f5..6edb39d6 100644
---- a/module/zfs/dbuf.c
-+++ b/module/zfs/dbuf.c
-@@ -1606,6 +1606,9 @@ dbuf_dirty(dmu_buf_impl_t *db, dmu_tx_t *tx)
- FTAG);
- }
- }
-+
-+ if (tx->tx_txg > dn->dn_dirty_txg)
-+ dn->dn_dirty_txg = tx->tx_txg;
- mutex_exit(&dn->dn_mtx);
-
- if (db->db_blkid == DMU_SPILL_BLKID)
-diff --git a/module/zfs/dmu.c b/module/zfs/dmu.c
-index 6f09aa2f..a09ac4f9 100644
---- a/module/zfs/dmu.c
-+++ b/module/zfs/dmu.c
-@@ -2044,7 +2044,7 @@ dmu_offset_next(objset_t *os, uint64_t object, boolean_t hole, uint64_t *off)
- * Check if dnode is dirty
- */
- for (i = 0; i < TXG_SIZE; i++) {
-- if (list_link_active(&dn->dn_dirty_link[i])) {
-+ if (multilist_link_active(&dn->dn_dirty_link[i])) {
- clean = B_FALSE;
- break;
- }
-diff --git a/module/zfs/dmu_objset.c b/module/zfs/dmu_objset.c
-index 449ebedf..0bed2d3e 100644
---- a/module/zfs/dmu_objset.c
-+++ b/module/zfs/dmu_objset.c
-@@ -1213,10 +1213,23 @@ dmu_objset_sync_dnodes(multilist_sublist_t *list, dmu_tx_t *tx)
- ASSERT3U(dn->dn_nlevels, <=, DN_MAX_LEVELS);
- multilist_sublist_remove(list, dn);
-
-+ /*
-+ * If we are not doing useraccounting (os_synced_dnodes == NULL)
-+ * we are done with this dnode for this txg. Unset dn_dirty_txg
-+ * if later txgs aren't dirtying it so that future holders do
-+ * not get a stale value. Otherwise, we will do this in
-+ * userquota_updates_task() when processing has completely
-+ * finished for this txg.
-+ */
- multilist_t *newlist = dn->dn_objset->os_synced_dnodes;
- if (newlist != NULL) {
- (void) dnode_add_ref(dn, newlist);
- multilist_insert(newlist, dn);
-+ } else {
-+ mutex_enter(&dn->dn_mtx);
-+ if (dn->dn_dirty_txg == tx->tx_txg)
-+ dn->dn_dirty_txg = 0;
-+ mutex_exit(&dn->dn_mtx);
- }
-
- dnode_sync(dn, tx);
-@@ -1621,6 +1634,8 @@ userquota_updates_task(void *arg)
- dn->dn_id_flags |= DN_ID_CHKED_BONUS;
- }
- dn->dn_id_flags &= ~(DN_ID_NEW_EXIST);
-+ if (dn->dn_dirty_txg == spa_syncing_txg(os->os_spa))
-+ dn->dn_dirty_txg = 0;
- mutex_exit(&dn->dn_mtx);
-
- multilist_sublist_remove(list, dn);
-diff --git a/module/zfs/dnode.c b/module/zfs/dnode.c
-index d465b545..4a169c49 100644
---- a/module/zfs/dnode.c
-+++ b/module/zfs/dnode.c
-@@ -137,7 +137,7 @@ dnode_cons(void *arg, void *unused, int kmflag)
- bzero(&dn->dn_next_blksz[0], sizeof (dn->dn_next_blksz));
-
- for (i = 0; i < TXG_SIZE; i++) {
-- list_link_init(&dn->dn_dirty_link[i]);
-+ multilist_link_init(&dn->dn_dirty_link[i]);
- dn->dn_free_ranges[i] = NULL;
- list_create(&dn->dn_dirty_records[i],
- sizeof (dbuf_dirty_record_t),
-@@ -147,6 +147,7 @@ dnode_cons(void *arg, void *unused, int kmflag)
- dn->dn_allocated_txg = 0;
- dn->dn_free_txg = 0;
- dn->dn_assigned_txg = 0;
-+ dn->dn_dirty_txg = 0;
- dn->dn_dirtyctx = 0;
- dn->dn_dirtyctx_firstset = NULL;
- dn->dn_bonus = NULL;
-@@ -184,7 +185,7 @@ dnode_dest(void *arg, void *unused)
- ASSERT(!list_link_active(&dn->dn_link));
-
- for (i = 0; i < TXG_SIZE; i++) {
-- ASSERT(!list_link_active(&dn->dn_dirty_link[i]));
-+ ASSERT(!multilist_link_active(&dn->dn_dirty_link[i]));
- ASSERT3P(dn->dn_free_ranges[i], ==, NULL);
- list_destroy(&dn->dn_dirty_records[i]);
- ASSERT0(dn->dn_next_nblkptr[i]);
-@@ -199,6 +200,7 @@ dnode_dest(void *arg, void *unused)
- ASSERT0(dn->dn_allocated_txg);
- ASSERT0(dn->dn_free_txg);
- ASSERT0(dn->dn_assigned_txg);
-+ ASSERT0(dn->dn_dirty_txg);
- ASSERT0(dn->dn_dirtyctx);
- ASSERT3P(dn->dn_dirtyctx_firstset, ==, NULL);
- ASSERT3P(dn->dn_bonus, ==, NULL);
-@@ -523,6 +525,7 @@ dnode_destroy(dnode_t *dn)
- dn->dn_allocated_txg = 0;
- dn->dn_free_txg = 0;
- dn->dn_assigned_txg = 0;
-+ dn->dn_dirty_txg = 0;
-
- dn->dn_dirtyctx = 0;
- if (dn->dn_dirtyctx_firstset != NULL) {
-@@ -592,6 +595,7 @@ dnode_allocate(dnode_t *dn, dmu_object_type_t ot, int blocksize, int ibs,
- ASSERT0(dn->dn_maxblkid);
- 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(avl_is_empty(&dn->dn_dbufs));
-@@ -604,7 +608,7 @@ dnode_allocate(dnode_t *dn, dmu_object_type_t ot, int blocksize, int ibs,
- ASSERT0(dn->dn_next_bonustype[i]);
- ASSERT0(dn->dn_rm_spillblk[i]);
- ASSERT0(dn->dn_next_blksz[i]);
-- ASSERT(!list_link_active(&dn->dn_dirty_link[i]));
-+ ASSERT(!multilist_link_active(&dn->dn_dirty_link[i]));
- ASSERT3P(list_head(&dn->dn_dirty_records[i]), ==, NULL);
- ASSERT3P(dn->dn_free_ranges[i], ==, NULL);
- }
-@@ -779,6 +783,7 @@ dnode_move_impl(dnode_t *odn, dnode_t *ndn)
- ndn->dn_allocated_txg = odn->dn_allocated_txg;
- ndn->dn_free_txg = odn->dn_free_txg;
- ndn->dn_assigned_txg = odn->dn_assigned_txg;
-+ 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);
-@@ -845,6 +850,7 @@ dnode_move_impl(dnode_t *odn, dnode_t *ndn)
- odn->dn_allocated_txg = 0;
- odn->dn_free_txg = 0;
- odn->dn_assigned_txg = 0;
-+ odn->dn_dirty_txg = 0;
- odn->dn_dirtyctx = 0;
- odn->dn_dirtyctx_firstset = NULL;
- odn->dn_have_spill = B_FALSE;
-@@ -1069,6 +1075,10 @@ dnode_check_slots_free(dnode_children_t *children, int idx, int slots)
- {
- ASSERT3S(idx + slots, <=, DNODES_PER_BLOCK);
-
-+ /*
-+ * If all dnode slots are either already free or
-+ * evictable return B_TRUE.
-+ */
- for (int i = idx; i < idx + slots; i++) {
- dnode_handle_t *dnh = &children->dnc_children[i];
- dnode_t *dn = dnh->dnh_dnode;
-@@ -1077,18 +1087,17 @@ dnode_check_slots_free(dnode_children_t *children, int idx, int slots)
- continue;
- } else if (DN_SLOT_IS_PTR(dn)) {
- mutex_enter(&dn->dn_mtx);
-- dmu_object_type_t type = dn->dn_type;
-+ boolean_t can_free = (dn->dn_type == DMU_OT_NONE &&
-+ !DNODE_IS_DIRTY(dn));
- mutex_exit(&dn->dn_mtx);
-
-- if (type != DMU_OT_NONE)
-+ if (!can_free)
- return (B_FALSE);
--
-- continue;
-+ else
-+ continue;
- } else {
- return (B_FALSE);
- }
--
-- return (B_FALSE);
- }
-
- return (B_TRUE);
-@@ -1594,7 +1603,7 @@ dnode_setdirty(dnode_t *dn, dmu_tx_t *tx)
- /*
- * If we are already marked dirty, we're done.
- */
-- if (list_link_active(&dn->dn_dirty_link[txg & TXG_MASK])) {
-+ if (multilist_link_active(&dn->dn_dirty_link[txg & TXG_MASK])) {
- multilist_sublist_unlock(mls);
- return;
- }
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Thomas Lamprecht <t.lamprecht@proxmox.com>
+Date: Wed, 31 Oct 2018 15:37:39 +0100
+Subject: [PATCH] Revert "Install init scripts to support non-systemd setups.
+ (Closes: #826994)"
+
+This reverts commit 2ad6c7f9e150e9c2fa146891785b09465aa0c7e5.
+
+Breaks on systems with sysv-rc installed (possible on Jessie upgraded
+systems)
+
+Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
+---
+ 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
+ delete mode 120000 debian/zfsutils-linux.zfs-mount.init
+ delete mode 120000 debian/zfsutils-linux.zfs-share.init
+
+diff --git a/debian/rules b/debian/rules
+index 3ba4b99a..d6cf5a56 100755
+--- a/debian/rules
++++ b/debian/rules
+@@ -117,14 +117,6 @@ override_dh_install:
+ find . -name lib*.la -delete
+ dh_install --fail-missing
+
+-override_dh_installinit:
+- dh_installinit -r --no-start --name zfs-import
+- dh_installinit -r --no-start --name zfs-mount
+- dh_installinit -r --no-start --name zfs-share
+- dh_installinit -R --no-start --name zfs-zed
+- mkdir -p debian/zfsutils-linux/lib/systemd/system
+- ln -sr /dev/null debian/zfsutils-linux/lib/systemd/system/zfs-import.service
+-
+ # ------------
+
+ 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
+--- a/debian/zfs-zed.zfs-zed.init
++++ /dev/null
+@@ -1 +0,0 @@
+-../etc/init.d/zfs-zed
+\ No newline at end of file
+diff --git a/debian/zfsutils-linux.zfs-import.init b/debian/zfsutils-linux.zfs-import.init
+deleted file mode 120000
+index bfc368fd..00000000
+--- a/debian/zfsutils-linux.zfs-import.init
++++ /dev/null
+@@ -1 +0,0 @@
+-../etc/init.d/zfs-import
+\ No newline at end of file
+diff --git a/debian/zfsutils-linux.zfs-mount.init b/debian/zfsutils-linux.zfs-mount.init
+deleted file mode 120000
+index 62a54433..00000000
+--- a/debian/zfsutils-linux.zfs-mount.init
++++ /dev/null
+@@ -1 +0,0 @@
+-../etc/init.d/zfs-mount
+\ No newline at end of file
+diff --git a/debian/zfsutils-linux.zfs-share.init b/debian/zfsutils-linux.zfs-share.init
+deleted file mode 120000
+index 3f069f9b..00000000
+--- a/debian/zfsutils-linux.zfs-share.init
++++ /dev/null
+@@ -1 +0,0 @@
+-../etc/init.d/zfs-share
+\ No newline at end of file
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Rohan Puri <rohan.puri15@gmail.com>
+Date: Sat, 28 Jul 2018 18:32:12 +0530
+Subject: [PATCH] Fix deadlock between zfs umount & snapentry_expire
+
+zfs umount -> zfsctl_destroy() takes the zfs_snapshot_lock as a
+writer and calls zfsctl_snapshot_unmount_cancel(), which waits
+for snapentry_expire() if present (when snap is automounted).
+This snapentry_expire() itself then waits for zfs_snapshot_lock
+as a reader, resulting in a deadlock.
+
+The fix is to only hold the zfs_snapshot_lock over the tree
+lookup and removal. After a successful lookup the lock can
+be dropped and zfs_snapentry_t will remain valid until the
+reference taken by the lookup is released.
+
+Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
+Signed-off-by: Rohan Puri <rohan.puri15@gmail.com>
+Closes #7751
+Closes #7752
+
+(Cherry-picked from fd7265c646f40e364396af5014bbb83e809e124a)
+Signed-off-by: Stoiko Ivanov <s.ivanov@proxmox.com>
+
+Signed-off-by: Stoiko Ivanov <s.ivanov@proxmox.com>
+---
+ module/zfs/zfs_ctldir.c | 11 +++++------
+ 1 file changed, 5 insertions(+), 6 deletions(-)
+
+diff --git a/module/zfs/zfs_ctldir.c b/module/zfs/zfs_ctldir.c
+index 98897fe6..0ab5b4f0 100644
+--- a/module/zfs/zfs_ctldir.c
++++ b/module/zfs/zfs_ctldir.c
+@@ -358,8 +358,6 @@ snapentry_expire(void *data)
+ static void
+ zfsctl_snapshot_unmount_cancel(zfs_snapentry_t *se)
+ {
+- ASSERT(RW_LOCK_HELD(&zfs_snapshot_lock));
+-
+ if (taskq_cancel_id(system_delay_taskq, se->se_taskqid) == 0) {
+ se->se_taskqid = TASKQID_INVALID;
+ zfsctl_snapshot_rele(se);
+@@ -570,13 +568,14 @@ zfsctl_destroy(zfsvfs_t *zfsvfs)
+ uint64_t objsetid = dmu_objset_id(zfsvfs->z_os);
+
+ rw_enter(&zfs_snapshot_lock, RW_WRITER);
+- if ((se = zfsctl_snapshot_find_by_objsetid(spa, objsetid))
+- != NULL) {
+- zfsctl_snapshot_unmount_cancel(se);
++ se = zfsctl_snapshot_find_by_objsetid(spa, objsetid);
++ if (se != NULL)
+ zfsctl_snapshot_remove(se);
++ rw_exit(&zfs_snapshot_lock);
++ if (se != NULL) {
++ zfsctl_snapshot_unmount_cancel(se);
+ zfsctl_snapshot_rele(se);
+ }
+- rw_exit(&zfs_snapshot_lock);
+ } else if (zfsvfs->z_ctldir) {
+ iput(zfsvfs->z_ctldir);
+ zfsvfs->z_ctldir = NULL;
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Matthew Ahrens <mahrens@delphix.com>
-Date: Thu, 2 Aug 2018 15:51:45 -0700
-Subject: [PATCH] Reduce taskq and context-switch cost of zio pipe
-
-When doing a read from disk, ZFS creates 3 ZIO's: a zio_null(), the
-logical zio_read(), and then a physical zio. Currently, each of these
-results in a separate taskq_dispatch(zio_execute).
-
-On high-read-iops workloads, this causes a significant performance
-impact. By processing all 3 ZIO's in a single taskq entry, we reduce the
-overhead on taskq locking and context switching. We accomplish this by
-allowing zio_done() to return a "next zio to execute" to zio_execute().
-
-This results in a ~12% performance increase for random reads, from
-96,000 iops to 108,000 iops (with recordsize=8k, on SSD's).
-
-Reviewed by: Pavel Zakharov <pavel.zakharov@delphix.com>
-Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
-Reviewed by: George Wilson <george.wilson@delphix.com>
-Signed-off-by: Matthew Ahrens <mahrens@delphix.com>
-External-issue: DLPX-59292
-Requires-spl: spl-0.7-release
-Closes #7736
-
-(cherry-picked from behlendorf/issue-7736 496657ab3bcfeb638b1786e1759980ccfcacb08e)
-Signed-off-by: Stoiko Ivanov <s.ivanov@proxmox.com>
----
- include/sys/zio.h | 4 +-
- module/zfs/zio.c | 250 +++++++++++++++++++++++++++++-------------------------
- 2 files changed, 137 insertions(+), 117 deletions(-)
-
-diff --git a/include/sys/zio.h b/include/sys/zio.h
-index 4b0eecc2..3618912c 100644
---- a/include/sys/zio.h
-+++ b/include/sys/zio.h
-@@ -237,7 +237,7 @@ enum zio_child {
- #define ZIO_CHILD_DDT_BIT ZIO_CHILD_BIT(ZIO_CHILD_DDT)
- #define ZIO_CHILD_LOGICAL_BIT ZIO_CHILD_BIT(ZIO_CHILD_LOGICAL)
- #define ZIO_CHILD_ALL_BITS \
-- (ZIO_CHILD_VDEV_BIT | ZIO_CHILD_GANG_BIT | \
-+ (ZIO_CHILD_VDEV_BIT | ZIO_CHILD_GANG_BIT | \
- ZIO_CHILD_DDT_BIT | ZIO_CHILD_LOGICAL_BIT)
-
- enum zio_wait_type {
-@@ -375,7 +375,7 @@ typedef struct zio_transform {
- struct zio_transform *zt_next;
- } zio_transform_t;
-
--typedef int zio_pipe_stage_t(zio_t *zio);
-+typedef zio_t *zio_pipe_stage_t(zio_t *zio);
-
- /*
- * 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
---- a/module/zfs/zio.c
-+++ b/module/zfs/zio.c
-@@ -75,9 +75,6 @@ uint64_t zio_buf_cache_frees[SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT];
-
- int zio_delay_max = ZIO_DELAY_MAX;
-
--#define ZIO_PIPELINE_CONTINUE 0x100
--#define ZIO_PIPELINE_STOP 0x101
--
- #define BP_SPANB(indblkshift, level) \
- (((uint64_t)1) << ((level) * ((indblkshift) - SPA_BLKPTRSHIFT)))
- #define COMPARE_META_LEVEL 0x80000000ul
-@@ -516,7 +513,8 @@ zio_wait_for_children(zio_t *zio, uint8_t childbits, enum zio_wait_type wait)
-
- __attribute__((always_inline))
- static inline void
--zio_notify_parent(zio_t *pio, zio_t *zio, enum zio_wait_type wait)
-+zio_notify_parent(zio_t *pio, zio_t *zio, enum zio_wait_type wait,
-+ zio_t **next_to_executep)
- {
- uint64_t *countp = &pio->io_children[zio->io_child_type][wait];
- int *errorp = &pio->io_child_error[zio->io_child_type];
-@@ -535,13 +533,33 @@ zio_notify_parent(zio_t *pio, zio_t *zio, enum zio_wait_type wait)
- ZIO_TASKQ_INTERRUPT;
- pio->io_stall = NULL;
- mutex_exit(&pio->io_lock);
-+
- /*
-- * Dispatch the parent zio in its own taskq so that
-- * the child can continue to make progress. This also
-- * prevents overflowing the stack when we have deeply nested
-- * parent-child relationships.
-+ * If we can tell the caller to execute this parent next, do
-+ * so. Otherwise dispatch the parent zio as its own task.
-+ *
-+ * Having the caller execute the parent when possible reduces
-+ * locking on the zio taskq's, reduces context switch
-+ * overhead, and has no recursion penalty. Note that one
-+ * read from disk typically causes at least 3 zio's: a
-+ * zio_null(), the logical zio_read(), and then a physical
-+ * zio. When the physical ZIO completes, we are able to call
-+ * zio_done() on all 3 of these zio's from one invocation of
-+ * zio_execute() by returning the parent back to
-+ * zio_execute(). Since the parent isn't executed until this
-+ * thread returns back to zio_execute(), the caller should do
-+ * so promptly.
-+ *
-+ * In other cases, dispatching the parent prevents
-+ * overflowing the stack when we have deeply nested
-+ * parent-child relationships, as we do with the "mega zio"
-+ * of writes for spa_sync(), and the chain of ZIL blocks.
- */
-- zio_taskq_dispatch(pio, type, B_FALSE);
-+ if (next_to_executep != NULL && *next_to_executep == NULL) {
-+ *next_to_executep = pio;
-+ } else {
-+ zio_taskq_dispatch(pio, type, B_FALSE);
-+ }
- } else {
- mutex_exit(&pio->io_lock);
- }
-@@ -1187,7 +1205,7 @@ zio_shrink(zio_t *zio, uint64_t size)
- * ==========================================================================
- */
-
--static int
-+static zio_t *
- zio_read_bp_init(zio_t *zio)
- {
- blkptr_t *bp = zio->io_bp;
-@@ -1221,15 +1239,15 @@ zio_read_bp_init(zio_t *zio)
- if (BP_GET_DEDUP(bp) && zio->io_child_type == ZIO_CHILD_LOGICAL)
- zio->io_pipeline = ZIO_DDT_READ_PIPELINE;
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
--static int
-+static zio_t *
- zio_write_bp_init(zio_t *zio)
- {
-
- if (!IO_IS_ALLOCATING(zio))
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
-
- ASSERT(zio->io_child_type != ZIO_CHILD_DDT);
-
-@@ -1244,7 +1262,7 @@ zio_write_bp_init(zio_t *zio)
- zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
-
- if (BP_IS_EMBEDDED(bp))
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
-
- /*
- * If we've been overridden and nopwrite is set then
-@@ -1255,13 +1273,13 @@ zio_write_bp_init(zio_t *zio)
- ASSERT(!zp->zp_dedup);
- ASSERT3U(BP_GET_CHECKSUM(bp), ==, zp->zp_checksum);
- zio->io_flags |= ZIO_FLAG_NOPWRITE;
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
- ASSERT(!zp->zp_nopwrite);
-
- if (BP_IS_HOLE(bp) || !zp->zp_dedup)
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
-
- ASSERT((zio_checksum_table[zp->zp_checksum].ci_flags &
- ZCHECKSUM_FLAG_DEDUP) || zp->zp_dedup_verify);
-@@ -1269,7 +1287,7 @@ zio_write_bp_init(zio_t *zio)
- if (BP_GET_CHECKSUM(bp) == zp->zp_checksum) {
- BP_SET_DEDUP(bp, 1);
- zio->io_pipeline |= ZIO_STAGE_DDT_WRITE;
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
- /*
-@@ -1281,10 +1299,10 @@ zio_write_bp_init(zio_t *zio)
- zio->io_pipeline = zio->io_orig_pipeline;
- }
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
--static int
-+static zio_t *
- zio_write_compress(zio_t *zio)
- {
- spa_t *spa = zio->io_spa;
-@@ -1303,11 +1321,11 @@ zio_write_compress(zio_t *zio)
- */
- if (zio_wait_for_children(zio, ZIO_CHILD_LOGICAL_BIT |
- ZIO_CHILD_GANG_BIT, ZIO_WAIT_READY)) {
-- return (ZIO_PIPELINE_STOP);
-+ return (NULL);
- }
-
- if (!IO_IS_ALLOCATING(zio))
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
-
- if (zio->io_children_ready != NULL) {
- /*
-@@ -1366,7 +1384,7 @@ zio_write_compress(zio_t *zio)
- zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
- ASSERT(spa_feature_is_active(spa,
- SPA_FEATURE_EMBEDDED_DATA));
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- } else {
- /*
- * Round up compressed size up to the ashift
-@@ -1459,10 +1477,10 @@ zio_write_compress(zio_t *zio)
- zio->io_pipeline |= ZIO_STAGE_NOP_WRITE;
- }
- }
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
--static int
-+static zio_t *
- zio_free_bp_init(zio_t *zio)
- {
- blkptr_t *bp = zio->io_bp;
-@@ -1472,7 +1490,7 @@ zio_free_bp_init(zio_t *zio)
- zio->io_pipeline = ZIO_DDT_FREE_PIPELINE;
- }
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
- /*
-@@ -1541,12 +1559,12 @@ zio_taskq_member(zio_t *zio, zio_taskq_type_t q)
- return (B_FALSE);
- }
-
--static int
-+static zio_t *
- zio_issue_async(zio_t *zio)
- {
- zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_FALSE);
-
-- return (ZIO_PIPELINE_STOP);
-+ return (NULL);
- }
-
- void
-@@ -1687,14 +1705,13 @@ __attribute__((always_inline))
- static inline void
- __zio_execute(zio_t *zio)
- {
-- zio->io_executor = curthread;
--
- ASSERT3U(zio->io_queued_timestamp, >, 0);
-
- while (zio->io_stage < ZIO_STAGE_DONE) {
- enum zio_stage pipeline = zio->io_pipeline;
- enum zio_stage stage = zio->io_stage;
-- int rv;
-+
-+ zio->io_executor = curthread;
-
- ASSERT(!MUTEX_HELD(&zio->io_lock));
- ASSERT(ISP2(stage));
-@@ -1736,12 +1753,16 @@ __zio_execute(zio_t *zio)
-
- zio->io_stage = stage;
- zio->io_pipeline_trace |= zio->io_stage;
-- rv = zio_pipeline[highbit64(stage) - 1](zio);
-
-- if (rv == ZIO_PIPELINE_STOP)
-- return;
-+ /*
-+ * The zio pipeline stage returns the next zio to execute
-+ * (typically the same as this one), or NULL if we should
-+ * stop.
-+ */
-+ zio = zio_pipeline[highbit64(stage) - 1](zio);
-
-- ASSERT(rv == ZIO_PIPELINE_CONTINUE);
-+ if (zio == NULL)
-+ return;
- }
- }
-
-@@ -2215,7 +2236,7 @@ zio_gang_tree_issue(zio_t *pio, zio_gang_node_t *gn, blkptr_t *bp, abd_t *data,
- zio_nowait(zio);
- }
-
--static int
-+static zio_t *
- zio_gang_assemble(zio_t *zio)
- {
- blkptr_t *bp = zio->io_bp;
-@@ -2227,16 +2248,16 @@ zio_gang_assemble(zio_t *zio)
-
- zio_gang_tree_assemble(zio, bp, &zio->io_gang_tree);
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
--static int
-+static zio_t *
- zio_gang_issue(zio_t *zio)
- {
- blkptr_t *bp = zio->io_bp;
-
- if (zio_wait_for_children(zio, ZIO_CHILD_GANG_BIT, ZIO_WAIT_DONE)) {
-- return (ZIO_PIPELINE_STOP);
-+ return (NULL);
- }
-
- ASSERT(BP_IS_GANG(bp) && zio->io_gang_leader == zio);
-@@ -2250,7 +2271,7 @@ zio_gang_issue(zio_t *zio)
-
- zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
- static void
-@@ -2290,7 +2311,7 @@ zio_write_gang_done(zio_t *zio)
- abd_put(zio->io_abd);
- }
-
--static int
-+static zio_t *
- zio_write_gang_block(zio_t *pio)
- {
- spa_t *spa = pio->io_spa;
-@@ -2349,7 +2370,7 @@ zio_write_gang_block(zio_t *pio)
- }
-
- pio->io_error = error;
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (pio);
- }
-
- if (pio == gio) {
-@@ -2423,7 +2444,7 @@ zio_write_gang_block(zio_t *pio)
-
- zio_nowait(zio);
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (pio);
- }
-
- /*
-@@ -2444,7 +2465,7 @@ zio_write_gang_block(zio_t *pio)
- * used for nopwrite, assuming that the salt and the checksums
- * themselves remain secret.
- */
--static int
-+static zio_t *
- zio_nop_write(zio_t *zio)
- {
- blkptr_t *bp = zio->io_bp;
-@@ -2471,7 +2492,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))
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
-
- /*
- * If the checksums match then reset the pipeline so that we
-@@ -2491,7 +2512,7 @@ zio_nop_write(zio_t *zio)
- zio->io_flags |= ZIO_FLAG_NOPWRITE;
- }
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
- /*
-@@ -2519,7 +2540,7 @@ zio_ddt_child_read_done(zio_t *zio)
- mutex_exit(&pio->io_lock);
- }
-
--static int
-+static zio_t *
- zio_ddt_read_start(zio_t *zio)
- {
- blkptr_t *bp = zio->io_bp;
-@@ -2540,7 +2561,7 @@ zio_ddt_read_start(zio_t *zio)
- zio->io_vsd = dde;
-
- if (ddp_self == NULL)
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
-
- 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)
- zio->io_priority, ZIO_DDT_CHILD_FLAGS(zio) |
- ZIO_FLAG_DONT_PROPAGATE, &zio->io_bookmark));
- }
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
- zio_nowait(zio_read(zio, zio->io_spa, bp,
- zio->io_abd, zio->io_size, NULL, NULL, zio->io_priority,
- ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark));
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
--static int
-+static zio_t *
- zio_ddt_read_done(zio_t *zio)
- {
- blkptr_t *bp = zio->io_bp;
-
- if (zio_wait_for_children(zio, ZIO_CHILD_DDT_BIT, ZIO_WAIT_DONE)) {
-- return (ZIO_PIPELINE_STOP);
-+ return (NULL);
- }
-
- ASSERT(BP_GET_DEDUP(bp));
-@@ -2581,12 +2602,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);
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
- if (dde == NULL) {
- zio->io_stage = ZIO_STAGE_DDT_READ_START >> 1;
- zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_FALSE);
-- return (ZIO_PIPELINE_STOP);
-+ return (NULL);
- }
- 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)
-
- ASSERT(zio->io_vsd == NULL);
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
- static boolean_t
-@@ -2780,7 +2801,7 @@ zio_ddt_ditto_write_done(zio_t *zio)
- ddt_exit(ddt);
- }
-
--static int
-+static zio_t *
- zio_ddt_write(zio_t *zio)
- {
- spa_t *spa = zio->io_spa;
-@@ -2822,7 +2843,7 @@ zio_ddt_write(zio_t *zio)
- }
- zio->io_pipeline = ZIO_WRITE_PIPELINE;
- ddt_exit(ddt);
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
- ditto_copies = ddt_ditto_copies_needed(ddt, dde, ddp);
-@@ -2848,7 +2869,7 @@ zio_ddt_write(zio_t *zio)
- zio->io_bp_override = NULL;
- BP_ZERO(bp);
- ddt_exit(ddt);
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
- dio = zio_write(zio, spa, txg, bp, zio->io_orig_abd,
-@@ -2890,12 +2911,12 @@ zio_ddt_write(zio_t *zio)
- if (dio)
- zio_nowait(dio);
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
- ddt_entry_t *freedde; /* for debugging */
-
--static int
-+static zio_t *
- zio_ddt_free(zio_t *zio)
- {
- spa_t *spa = zio->io_spa;
-@@ -2916,7 +2937,7 @@ zio_ddt_free(zio_t *zio)
- }
- ddt_exit(ddt);
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
- /*
-@@ -2953,7 +2974,7 @@ zio_io_to_allocate(spa_t *spa)
- return (zio);
- }
-
--static int
-+static zio_t *
- zio_dva_throttle(zio_t *zio)
- {
- spa_t *spa = zio->io_spa;
-@@ -2963,7 +2984,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) {
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
- ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
-@@ -2979,22 +3000,7 @@ zio_dva_throttle(zio_t *zio)
- nio = zio_io_to_allocate(zio->io_spa);
- mutex_exit(&spa->spa_alloc_lock);
-
-- if (nio == zio)
-- return (ZIO_PIPELINE_CONTINUE);
--
-- if (nio != NULL) {
-- ASSERT(nio->io_stage == ZIO_STAGE_DVA_THROTTLE);
-- /*
-- * We are passing control to a new zio so make sure that
-- * it is processed by a different thread. We do this to
-- * avoid stack overflows that can occur when parents are
-- * throttled and children are making progress. We allow
-- * it to go to the head of the taskq since it's already
-- * been waiting.
-- */
-- zio_taskq_dispatch(nio, ZIO_TASKQ_ISSUE, B_TRUE);
-- }
-- return (ZIO_PIPELINE_STOP);
-+ return (nio);
- }
-
- void
-@@ -3013,7 +3019,7 @@ zio_allocate_dispatch(spa_t *spa)
- zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_TRUE);
- }
-
--static int
-+static zio_t *
- zio_dva_allocate(zio_t *zio)
- {
- spa_t *spa = zio->io_spa;
-@@ -3054,18 +3060,18 @@ zio_dva_allocate(zio_t *zio)
- zio->io_error = error;
- }
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
--static int
-+static zio_t *
- zio_dva_free(zio_t *zio)
- {
- metaslab_free(zio->io_spa, zio->io_bp, zio->io_txg, B_FALSE);
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
--static int
-+static zio_t *
- zio_dva_claim(zio_t *zio)
- {
- int error;
-@@ -3074,7 +3080,7 @@ zio_dva_claim(zio_t *zio)
- if (error)
- zio->io_error = error;
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
- /*
-@@ -3172,7 +3178,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.
- */
--static int
-+static zio_t *
- zio_vdev_io_start(zio_t *zio)
- {
- vdev_t *vd = zio->io_vd;
-@@ -3192,7 +3198,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);
-- return (ZIO_PIPELINE_STOP);
-+ return (NULL);
- }
-
- ASSERT3P(zio->io_logical, !=, zio);
-@@ -3269,31 +3275,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);
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
- if (vd->vdev_ops->vdev_op_leaf &&
- (zio->io_type == ZIO_TYPE_READ || zio->io_type == ZIO_TYPE_WRITE)) {
-
- if (zio->io_type == ZIO_TYPE_READ && vdev_cache_read(zio))
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
-
- if ((zio = vdev_queue_io(zio)) == NULL)
-- return (ZIO_PIPELINE_STOP);
-+ return (NULL);
-
- if (!vdev_accessible(vd, zio)) {
- zio->io_error = SET_ERROR(ENXIO);
- zio_interrupt(zio);
-- return (ZIO_PIPELINE_STOP);
-+ return (NULL);
- }
- zio->io_delay = gethrtime();
- }
-
- vd->vdev_ops->vdev_op_io_start(zio);
-- return (ZIO_PIPELINE_STOP);
-+ return (NULL);
- }
-
--static int
-+static zio_t *
- zio_vdev_io_done(zio_t *zio)
- {
- vdev_t *vd = zio->io_vd;
-@@ -3301,7 +3307,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)) {
-- return (ZIO_PIPELINE_STOP);
-+ return (NULL);
- }
-
- ASSERT(zio->io_type == ZIO_TYPE_READ || zio->io_type == ZIO_TYPE_WRITE);
-@@ -3337,7 +3343,7 @@ zio_vdev_io_done(zio_t *zio)
- if (unexpected_error)
- VERIFY(vdev_probe(vd, zio) == NULL);
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
- /*
-@@ -3366,13 +3372,13 @@ zio_vsd_default_cksum_report(zio_t *zio, zio_cksum_report_t *zcr, void *ignored)
- zcr->zcr_free = zio_abd_free;
- }
-
--static int
-+static zio_t *
- zio_vdev_io_assess(zio_t *zio)
- {
- vdev_t *vd = zio->io_vd;
-
- if (zio_wait_for_children(zio, ZIO_CHILD_VDEV_BIT, ZIO_WAIT_DONE)) {
-- return (ZIO_PIPELINE_STOP);
-+ return (NULL);
- }
-
- if (vd == NULL && !(zio->io_flags & ZIO_FLAG_CONFIG_WRITER))
-@@ -3402,7 +3408,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);
-- return (ZIO_PIPELINE_STOP);
-+ return (NULL);
- }
-
- /*
-@@ -3442,7 +3448,7 @@ zio_vdev_io_assess(zio_t *zio)
- zio->io_physdone(zio->io_logical);
- }
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
- void
-@@ -3477,7 +3483,7 @@ zio_vdev_io_bypass(zio_t *zio)
- * Generate and verify checksums
- * ==========================================================================
- */
--static int
-+static zio_t *
- zio_checksum_generate(zio_t *zio)
- {
- blkptr_t *bp = zio->io_bp;
-@@ -3491,7 +3497,7 @@ zio_checksum_generate(zio_t *zio)
- checksum = zio->io_prop.zp_checksum;
-
- if (checksum == ZIO_CHECKSUM_OFF)
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
-
- ASSERT(checksum == ZIO_CHECKSUM_LABEL);
- } else {
-@@ -3505,10 +3511,10 @@ zio_checksum_generate(zio_t *zio)
-
- zio_checksum_compute(zio, checksum, zio->io_abd, zio->io_size);
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
--static int
-+static zio_t *
- zio_checksum_verify(zio_t *zio)
- {
- zio_bad_cksum_t info;
-@@ -3523,7 +3529,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)
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
-
- ASSERT(zio->io_prop.zp_checksum == ZIO_CHECKSUM_LABEL);
- }
-@@ -3538,7 +3544,7 @@ zio_checksum_verify(zio_t *zio)
- }
- }
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
- /*
-@@ -3581,7 +3587,7 @@ zio_worst_error(int e1, int e2)
- * I/O completion
- * ==========================================================================
- */
--static int
-+static zio_t *
- zio_ready(zio_t *zio)
- {
- blkptr_t *bp = zio->io_bp;
-@@ -3590,7 +3596,7 @@ zio_ready(zio_t *zio)
-
- if (zio_wait_for_children(zio, ZIO_CHILD_GANG_BIT | ZIO_CHILD_DDT_BIT,
- ZIO_WAIT_READY)) {
-- return (ZIO_PIPELINE_STOP);
-+ return (NULL);
- }
-
- if (zio->io_ready) {
-@@ -3636,7 +3642,7 @@ zio_ready(zio_t *zio)
- */
- for (; pio != NULL; pio = pio_next) {
- pio_next = zio_walk_parents(zio, &zl);
-- zio_notify_parent(pio, zio, ZIO_WAIT_READY);
-+ zio_notify_parent(pio, zio, ZIO_WAIT_READY, NULL);
- }
-
- if (zio->io_flags & ZIO_FLAG_NODATA) {
-@@ -3652,7 +3658,7 @@ zio_ready(zio_t *zio)
- zio->io_spa->spa_syncing_txg == zio->io_txg)
- zio_handle_ignored_writes(zio);
-
-- return (ZIO_PIPELINE_CONTINUE);
-+ return (zio);
- }
-
- /*
-@@ -3716,7 +3722,7 @@ zio_dva_throttle_done(zio_t *zio)
- zio_allocate_dispatch(zio->io_spa);
- }
-
--static int
-+static zio_t *
- zio_done(zio_t *zio)
- {
- /*
-@@ -3733,7 +3739,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)) {
-- return (ZIO_PIPELINE_STOP);
-+ return (NULL);
- }
-
- /*
-@@ -3957,7 +3963,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);
-- zio_notify_parent(pio, zio, ZIO_WAIT_DONE);
-+ /*
-+ * This is a rare code path, so we don't
-+ * bother with "next_to_execute".
-+ */
-+ zio_notify_parent(pio, zio, ZIO_WAIT_DONE,
-+ NULL);
- }
- }
-
-@@ -3969,7 +3980,11 @@ zio_done(zio_t *zio)
- */
- ASSERT(!(zio->io_flags & ZIO_FLAG_GODFATHER));
- zio->io_flags |= ZIO_FLAG_DONT_PROPAGATE;
-- zio_notify_parent(pio, zio, ZIO_WAIT_DONE);
-+ /*
-+ * This is a rare code path, so we don't bother with
-+ * "next_to_execute".
-+ */
-+ zio_notify_parent(pio, zio, ZIO_WAIT_DONE, NULL);
- } else if (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND) {
- /*
- * We'd fail again if we reexecuted now, so suspend
-@@ -3987,7 +4002,7 @@ zio_done(zio_t *zio)
- (task_func_t *)zio_reexecute, zio, 0,
- &zio->io_tqent);
- }
-- return (ZIO_PIPELINE_STOP);
-+ return (NULL);
- }
-
- ASSERT(zio->io_child_count == 0);
-@@ -4023,12 +4038,17 @@ zio_done(zio_t *zio)
- zio->io_state[ZIO_WAIT_DONE] = 1;
- mutex_exit(&zio->io_lock);
-
-+ /*
-+ * We are done executing this zio. We may want to execute a parent
-+ * next. See the comment in zio_notify_parent().
-+ */
-+ zio_t *next_to_execute = NULL;
- zl = NULL;
- for (pio = zio_walk_parents(zio, &zl); pio != NULL; pio = pio_next) {
- zio_link_t *remove_zl = zl;
- pio_next = zio_walk_parents(zio, &zl);
- zio_remove_child(pio, zio, remove_zl);
-- zio_notify_parent(pio, zio, ZIO_WAIT_DONE);
-+ zio_notify_parent(pio, zio, ZIO_WAIT_DONE, &next_to_execute);
- }
-
- if (zio->io_waiter != NULL) {
-@@ -4040,7 +4060,7 @@ zio_done(zio_t *zio)
- zio_destroy(zio);
- }
-
-- return (ZIO_PIPELINE_STOP);
-+ return (next_to_execute);
- }
-
- /*
+++ /dev/null
-From 5ac80068e911d3b0935903f713c5f492d518da91 Mon Sep 17 00:00:00 2001
-From: Stoiko Ivanov <s.ivanov@proxmox.com>
-Date: Mon, 29 Oct 2018 15:49:20 +0100
-Subject: [PATCH] Add Breaks/Replaces to zfs-initramfs
-
-addressing the move of zdev initramfs hook from zfsutils-linux to
-zfs-initramfs
-
-Signed-off-by: Stoiko Ivanov <s.ivanov@proxmox.com>
----
- debian/control | 2 ++
- debian/control.in | 2 ++
- 2 files changed, 4 insertions(+)
-
-diff --git a/debian/control b/debian/control
-index 4d22ff50..a414e449 100644
---- a/debian/control
-+++ b/debian/control
-@@ -117,6 +117,8 @@ Depends: busybox-initramfs | busybox-static | busybox,
- zfs-modules | zfs-dkms,
- zfsutils-linux (>= ${binary:Version}),
- ${misc:Depends}
-+Breaks: zfsutils-linux (<= 0.7.11-pve1~bpo1)
-+Replaces: zfsutils-linux (<= 0.7.11-pve1~bpo1)
- 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
-diff --git a/debian/control.in b/debian/control.in
-index 96154c5c..b9c34331 100644
---- a/debian/control.in
-+++ b/debian/control.in
-@@ -117,6 +117,8 @@ Depends: busybox-initramfs | busybox-static | busybox,
- zfs-modules | zfs-dkms,
- zfsutils-linux (>= ${binary:Version}),
- ${misc:Depends}
-+Breaks: zfsutils-linux (<= 0.7.11-pve1~bpo1)
-+Replaces: zfsutils-linux (<= 0.7.11-pve1~bpo1)
- 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
-
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Tom Caputi <tcaputi@datto.com>
+Date: Tue, 10 Apr 2018 14:15:05 -0400
+Subject: [PATCH] Fix race in dnode_check_slots_free()
+
+Currently, dnode_check_slots_free() works by checking dn->dn_type
+in the dnode to determine if the dnode is reclaimable. However,
+there is a small window of time between dnode_free_sync() in the
+first call to dsl_dataset_sync() and when the useraccounting code
+is run when the type is set DMU_OT_NONE, but the dnode is not yet
+evictable, leading to crashes. This patch adds the ability for
+dnodes to track which txg they were last dirtied in and adds a
+check for this before performing the reclaim.
+
+This patch also corrects several instances when dn_dirty_link was
+treated as a list_node_t when it is technically a multilist_node_t.
+
+Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
+Signed-off-by: Tom Caputi <tcaputi@datto.com>
+Closes #7147
+Closes #7388
+---
+ include/sys/dmu_impl.h | 1 +
+ include/sys/dnode.h | 4 ++++
+ module/zfs/dbuf.c | 3 +++
+ module/zfs/dmu.c | 2 +-
+ module/zfs/dmu_objset.c | 15 +++++++++++++++
+ module/zfs/dnode.c | 29 +++++++++++++++++++----------
+ 6 files changed, 43 insertions(+), 11 deletions(-)
+
+diff --git a/include/sys/dmu_impl.h b/include/sys/dmu_impl.h
+index 65e417e3..03a63077 100644
+--- a/include/sys/dmu_impl.h
++++ b/include/sys/dmu_impl.h
+@@ -161,6 +161,7 @@ extern "C" {
+ * dn_allocated_txg
+ * dn_free_txg
+ * dn_assigned_txg
++ * dn_dirty_txg
+ * dd_assigned_tx
+ * dn_notxholds
+ * dn_dirtyctx
+diff --git a/include/sys/dnode.h b/include/sys/dnode.h
+index ea7defe1..2dd087b3 100644
+--- a/include/sys/dnode.h
++++ b/include/sys/dnode.h
+@@ -260,6 +260,7 @@ struct dnode {
+ uint64_t dn_allocated_txg;
+ uint64_t dn_free_txg;
+ uint64_t dn_assigned_txg;
++ uint64_t dn_dirty_txg; /* txg dnode was last dirtied */
+ kcondvar_t dn_notxholds;
+ enum dnode_dirtycontext dn_dirtyctx;
+ uint8_t *dn_dirtyctx_firstset; /* dbg: contents meaningless */
+@@ -362,6 +363,9 @@ void dnode_evict_dbufs(dnode_t *dn);
+ void dnode_evict_bonus(dnode_t *dn);
+ void dnode_free_interior_slots(dnode_t *dn);
+
++#define DNODE_IS_DIRTY(_dn) \
++ ((_dn)->dn_dirty_txg >= spa_syncing_txg((_dn)->dn_objset->os_spa))
++
+ #define DNODE_IS_CACHEABLE(_dn) \
+ ((_dn)->dn_objset->os_primary_cache == ZFS_CACHE_ALL || \
+ (DMU_OT_IS_METADATA((_dn)->dn_type) && \
+diff --git a/module/zfs/dbuf.c b/module/zfs/dbuf.c
+index 4ee121f5..6edb39d6 100644
+--- a/module/zfs/dbuf.c
++++ b/module/zfs/dbuf.c
+@@ -1606,6 +1606,9 @@ dbuf_dirty(dmu_buf_impl_t *db, dmu_tx_t *tx)
+ FTAG);
+ }
+ }
++
++ if (tx->tx_txg > dn->dn_dirty_txg)
++ dn->dn_dirty_txg = tx->tx_txg;
+ mutex_exit(&dn->dn_mtx);
+
+ if (db->db_blkid == DMU_SPILL_BLKID)
+diff --git a/module/zfs/dmu.c b/module/zfs/dmu.c
+index 6f09aa2f..a09ac4f9 100644
+--- a/module/zfs/dmu.c
++++ b/module/zfs/dmu.c
+@@ -2044,7 +2044,7 @@ dmu_offset_next(objset_t *os, uint64_t object, boolean_t hole, uint64_t *off)
+ * Check if dnode is dirty
+ */
+ for (i = 0; i < TXG_SIZE; i++) {
+- if (list_link_active(&dn->dn_dirty_link[i])) {
++ if (multilist_link_active(&dn->dn_dirty_link[i])) {
+ clean = B_FALSE;
+ break;
+ }
+diff --git a/module/zfs/dmu_objset.c b/module/zfs/dmu_objset.c
+index 449ebedf..0bed2d3e 100644
+--- a/module/zfs/dmu_objset.c
++++ b/module/zfs/dmu_objset.c
+@@ -1213,10 +1213,23 @@ dmu_objset_sync_dnodes(multilist_sublist_t *list, dmu_tx_t *tx)
+ ASSERT3U(dn->dn_nlevels, <=, DN_MAX_LEVELS);
+ multilist_sublist_remove(list, dn);
+
++ /*
++ * If we are not doing useraccounting (os_synced_dnodes == NULL)
++ * we are done with this dnode for this txg. Unset dn_dirty_txg
++ * if later txgs aren't dirtying it so that future holders do
++ * not get a stale value. Otherwise, we will do this in
++ * userquota_updates_task() when processing has completely
++ * finished for this txg.
++ */
+ multilist_t *newlist = dn->dn_objset->os_synced_dnodes;
+ if (newlist != NULL) {
+ (void) dnode_add_ref(dn, newlist);
+ multilist_insert(newlist, dn);
++ } else {
++ mutex_enter(&dn->dn_mtx);
++ if (dn->dn_dirty_txg == tx->tx_txg)
++ dn->dn_dirty_txg = 0;
++ mutex_exit(&dn->dn_mtx);
+ }
+
+ dnode_sync(dn, tx);
+@@ -1621,6 +1634,8 @@ userquota_updates_task(void *arg)
+ dn->dn_id_flags |= DN_ID_CHKED_BONUS;
+ }
+ dn->dn_id_flags &= ~(DN_ID_NEW_EXIST);
++ if (dn->dn_dirty_txg == spa_syncing_txg(os->os_spa))
++ dn->dn_dirty_txg = 0;
+ mutex_exit(&dn->dn_mtx);
+
+ multilist_sublist_remove(list, dn);
+diff --git a/module/zfs/dnode.c b/module/zfs/dnode.c
+index d465b545..4a169c49 100644
+--- a/module/zfs/dnode.c
++++ b/module/zfs/dnode.c
+@@ -137,7 +137,7 @@ dnode_cons(void *arg, void *unused, int kmflag)
+ bzero(&dn->dn_next_blksz[0], sizeof (dn->dn_next_blksz));
+
+ for (i = 0; i < TXG_SIZE; i++) {
+- list_link_init(&dn->dn_dirty_link[i]);
++ multilist_link_init(&dn->dn_dirty_link[i]);
+ dn->dn_free_ranges[i] = NULL;
+ list_create(&dn->dn_dirty_records[i],
+ sizeof (dbuf_dirty_record_t),
+@@ -147,6 +147,7 @@ dnode_cons(void *arg, void *unused, int kmflag)
+ dn->dn_allocated_txg = 0;
+ dn->dn_free_txg = 0;
+ dn->dn_assigned_txg = 0;
++ dn->dn_dirty_txg = 0;
+ dn->dn_dirtyctx = 0;
+ dn->dn_dirtyctx_firstset = NULL;
+ dn->dn_bonus = NULL;
+@@ -184,7 +185,7 @@ dnode_dest(void *arg, void *unused)
+ ASSERT(!list_link_active(&dn->dn_link));
+
+ for (i = 0; i < TXG_SIZE; i++) {
+- ASSERT(!list_link_active(&dn->dn_dirty_link[i]));
++ ASSERT(!multilist_link_active(&dn->dn_dirty_link[i]));
+ ASSERT3P(dn->dn_free_ranges[i], ==, NULL);
+ list_destroy(&dn->dn_dirty_records[i]);
+ ASSERT0(dn->dn_next_nblkptr[i]);
+@@ -199,6 +200,7 @@ dnode_dest(void *arg, void *unused)
+ ASSERT0(dn->dn_allocated_txg);
+ ASSERT0(dn->dn_free_txg);
+ ASSERT0(dn->dn_assigned_txg);
++ ASSERT0(dn->dn_dirty_txg);
+ ASSERT0(dn->dn_dirtyctx);
+ ASSERT3P(dn->dn_dirtyctx_firstset, ==, NULL);
+ ASSERT3P(dn->dn_bonus, ==, NULL);
+@@ -523,6 +525,7 @@ dnode_destroy(dnode_t *dn)
+ dn->dn_allocated_txg = 0;
+ dn->dn_free_txg = 0;
+ dn->dn_assigned_txg = 0;
++ dn->dn_dirty_txg = 0;
+
+ dn->dn_dirtyctx = 0;
+ if (dn->dn_dirtyctx_firstset != NULL) {
+@@ -592,6 +595,7 @@ dnode_allocate(dnode_t *dn, dmu_object_type_t ot, int blocksize, int ibs,
+ ASSERT0(dn->dn_maxblkid);
+ 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(avl_is_empty(&dn->dn_dbufs));
+@@ -604,7 +608,7 @@ dnode_allocate(dnode_t *dn, dmu_object_type_t ot, int blocksize, int ibs,
+ ASSERT0(dn->dn_next_bonustype[i]);
+ ASSERT0(dn->dn_rm_spillblk[i]);
+ ASSERT0(dn->dn_next_blksz[i]);
+- ASSERT(!list_link_active(&dn->dn_dirty_link[i]));
++ ASSERT(!multilist_link_active(&dn->dn_dirty_link[i]));
+ ASSERT3P(list_head(&dn->dn_dirty_records[i]), ==, NULL);
+ ASSERT3P(dn->dn_free_ranges[i], ==, NULL);
+ }
+@@ -779,6 +783,7 @@ dnode_move_impl(dnode_t *odn, dnode_t *ndn)
+ ndn->dn_allocated_txg = odn->dn_allocated_txg;
+ ndn->dn_free_txg = odn->dn_free_txg;
+ ndn->dn_assigned_txg = odn->dn_assigned_txg;
++ 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);
+@@ -845,6 +850,7 @@ dnode_move_impl(dnode_t *odn, dnode_t *ndn)
+ odn->dn_allocated_txg = 0;
+ odn->dn_free_txg = 0;
+ odn->dn_assigned_txg = 0;
++ odn->dn_dirty_txg = 0;
+ odn->dn_dirtyctx = 0;
+ odn->dn_dirtyctx_firstset = NULL;
+ odn->dn_have_spill = B_FALSE;
+@@ -1069,6 +1075,10 @@ dnode_check_slots_free(dnode_children_t *children, int idx, int slots)
+ {
+ ASSERT3S(idx + slots, <=, DNODES_PER_BLOCK);
+
++ /*
++ * If all dnode slots are either already free or
++ * evictable return B_TRUE.
++ */
+ for (int i = idx; i < idx + slots; i++) {
+ dnode_handle_t *dnh = &children->dnc_children[i];
+ dnode_t *dn = dnh->dnh_dnode;
+@@ -1077,18 +1087,17 @@ dnode_check_slots_free(dnode_children_t *children, int idx, int slots)
+ continue;
+ } else if (DN_SLOT_IS_PTR(dn)) {
+ mutex_enter(&dn->dn_mtx);
+- dmu_object_type_t type = dn->dn_type;
++ boolean_t can_free = (dn->dn_type == DMU_OT_NONE &&
++ !DNODE_IS_DIRTY(dn));
+ mutex_exit(&dn->dn_mtx);
+
+- if (type != DMU_OT_NONE)
++ if (!can_free)
+ return (B_FALSE);
+-
+- continue;
++ else
++ continue;
+ } else {
+ return (B_FALSE);
+ }
+-
+- return (B_FALSE);
+ }
+
+ return (B_TRUE);
+@@ -1594,7 +1603,7 @@ dnode_setdirty(dnode_t *dn, dmu_tx_t *tx)
+ /*
+ * If we are already marked dirty, we're done.
+ */
+- if (list_link_active(&dn->dn_dirty_link[txg & TXG_MASK])) {
++ if (multilist_link_active(&dn->dn_dirty_link[txg & TXG_MASK])) {
+ multilist_sublist_unlock(mls);
+ return;
+ }
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Matthew Ahrens <mahrens@delphix.com>
+Date: Thu, 2 Aug 2018 15:51:45 -0700
+Subject: [PATCH] Reduce taskq and context-switch cost of zio pipe
+
+When doing a read from disk, ZFS creates 3 ZIO's: a zio_null(), the
+logical zio_read(), and then a physical zio. Currently, each of these
+results in a separate taskq_dispatch(zio_execute).
+
+On high-read-iops workloads, this causes a significant performance
+impact. By processing all 3 ZIO's in a single taskq entry, we reduce the
+overhead on taskq locking and context switching. We accomplish this by
+allowing zio_done() to return a "next zio to execute" to zio_execute().
+
+This results in a ~12% performance increase for random reads, from
+96,000 iops to 108,000 iops (with recordsize=8k, on SSD's).
+
+Reviewed by: Pavel Zakharov <pavel.zakharov@delphix.com>
+Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
+Reviewed by: George Wilson <george.wilson@delphix.com>
+Signed-off-by: Matthew Ahrens <mahrens@delphix.com>
+External-issue: DLPX-59292
+Closes #7736
+---
+ include/sys/zio.h | 4 +-
+ 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
+--- a/include/sys/zio.h
++++ b/include/sys/zio.h
+@@ -237,7 +237,7 @@ enum zio_child {
+ #define ZIO_CHILD_DDT_BIT ZIO_CHILD_BIT(ZIO_CHILD_DDT)
+ #define ZIO_CHILD_LOGICAL_BIT ZIO_CHILD_BIT(ZIO_CHILD_LOGICAL)
+ #define ZIO_CHILD_ALL_BITS \
+- (ZIO_CHILD_VDEV_BIT | ZIO_CHILD_GANG_BIT | \
++ (ZIO_CHILD_VDEV_BIT | ZIO_CHILD_GANG_BIT | \
+ ZIO_CHILD_DDT_BIT | ZIO_CHILD_LOGICAL_BIT)
+
+ enum zio_wait_type {
+@@ -375,7 +375,7 @@ typedef struct zio_transform {
+ struct zio_transform *zt_next;
+ } zio_transform_t;
+
+-typedef int zio_pipe_stage_t(zio_t *zio);
++typedef zio_t *zio_pipe_stage_t(zio_t *zio);
+
+ /*
+ * 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..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];
+
+ int zio_delay_max = ZIO_DELAY_MAX;
+
+-#define ZIO_PIPELINE_CONTINUE 0x100
+-#define ZIO_PIPELINE_STOP 0x101
+-
+ #define BP_SPANB(indblkshift, level) \
+ (((uint64_t)1) << ((level) * ((indblkshift) - SPA_BLKPTRSHIFT)))
+ #define COMPARE_META_LEVEL 0x80000000ul
+@@ -516,7 +513,8 @@ zio_wait_for_children(zio_t *zio, uint8_t childbits, enum zio_wait_type wait)
+
+ __attribute__((always_inline))
+ static inline void
+-zio_notify_parent(zio_t *pio, zio_t *zio, enum zio_wait_type wait)
++zio_notify_parent(zio_t *pio, zio_t *zio, enum zio_wait_type wait,
++ zio_t **next_to_executep)
+ {
+ uint64_t *countp = &pio->io_children[zio->io_child_type][wait];
+ int *errorp = &pio->io_child_error[zio->io_child_type];
+@@ -535,13 +533,33 @@ zio_notify_parent(zio_t *pio, zio_t *zio, enum zio_wait_type wait)
+ ZIO_TASKQ_INTERRUPT;
+ pio->io_stall = NULL;
+ mutex_exit(&pio->io_lock);
++
+ /*
+- * Dispatch the parent zio in its own taskq so that
+- * the child can continue to make progress. This also
+- * prevents overflowing the stack when we have deeply nested
+- * parent-child relationships.
++ * If we can tell the caller to execute this parent next, do
++ * so. Otherwise dispatch the parent zio as its own task.
++ *
++ * Having the caller execute the parent when possible reduces
++ * locking on the zio taskq's, reduces context switch
++ * overhead, and has no recursion penalty. Note that one
++ * read from disk typically causes at least 3 zio's: a
++ * zio_null(), the logical zio_read(), and then a physical
++ * zio. When the physical ZIO completes, we are able to call
++ * zio_done() on all 3 of these zio's from one invocation of
++ * zio_execute() by returning the parent back to
++ * zio_execute(). Since the parent isn't executed until this
++ * thread returns back to zio_execute(), the caller should do
++ * so promptly.
++ *
++ * In other cases, dispatching the parent prevents
++ * overflowing the stack when we have deeply nested
++ * parent-child relationships, as we do with the "mega zio"
++ * of writes for spa_sync(), and the chain of ZIL blocks.
+ */
+- zio_taskq_dispatch(pio, type, B_FALSE);
++ if (next_to_executep != NULL && *next_to_executep == NULL) {
++ *next_to_executep = pio;
++ } else {
++ zio_taskq_dispatch(pio, type, B_FALSE);
++ }
+ } else {
+ mutex_exit(&pio->io_lock);
+ }
+@@ -1187,7 +1205,7 @@ zio_shrink(zio_t *zio, uint64_t size)
+ * ==========================================================================
+ */
+
+-static int
++static zio_t *
+ zio_read_bp_init(zio_t *zio)
+ {
+ blkptr_t *bp = zio->io_bp;
+@@ -1221,15 +1239,15 @@ zio_read_bp_init(zio_t *zio)
+ if (BP_GET_DEDUP(bp) && zio->io_child_type == ZIO_CHILD_LOGICAL)
+ zio->io_pipeline = ZIO_DDT_READ_PIPELINE;
+
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+-static int
++static zio_t *
+ zio_write_bp_init(zio_t *zio)
+ {
+
+ if (!IO_IS_ALLOCATING(zio))
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+
+ ASSERT(zio->io_child_type != ZIO_CHILD_DDT);
+
+@@ -1244,7 +1262,7 @@ zio_write_bp_init(zio_t *zio)
+ zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
+
+ if (BP_IS_EMBEDDED(bp))
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+
+ /*
+ * If we've been overridden and nopwrite is set then
+@@ -1255,13 +1273,13 @@ zio_write_bp_init(zio_t *zio)
+ ASSERT(!zp->zp_dedup);
+ ASSERT3U(BP_GET_CHECKSUM(bp), ==, zp->zp_checksum);
+ zio->io_flags |= ZIO_FLAG_NOPWRITE;
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+ ASSERT(!zp->zp_nopwrite);
+
+ if (BP_IS_HOLE(bp) || !zp->zp_dedup)
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+
+ ASSERT((zio_checksum_table[zp->zp_checksum].ci_flags &
+ ZCHECKSUM_FLAG_DEDUP) || zp->zp_dedup_verify);
+@@ -1269,7 +1287,7 @@ zio_write_bp_init(zio_t *zio)
+ if (BP_GET_CHECKSUM(bp) == zp->zp_checksum) {
+ BP_SET_DEDUP(bp, 1);
+ zio->io_pipeline |= ZIO_STAGE_DDT_WRITE;
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+ /*
+@@ -1281,10 +1299,10 @@ zio_write_bp_init(zio_t *zio)
+ zio->io_pipeline = zio->io_orig_pipeline;
+ }
+
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+-static int
++static zio_t *
+ zio_write_compress(zio_t *zio)
+ {
+ spa_t *spa = zio->io_spa;
+@@ -1303,11 +1321,11 @@ zio_write_compress(zio_t *zio)
+ */
+ if (zio_wait_for_children(zio, ZIO_CHILD_LOGICAL_BIT |
+ ZIO_CHILD_GANG_BIT, ZIO_WAIT_READY)) {
+- return (ZIO_PIPELINE_STOP);
++ return (NULL);
+ }
+
+ if (!IO_IS_ALLOCATING(zio))
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+
+ if (zio->io_children_ready != NULL) {
+ /*
+@@ -1366,7 +1384,7 @@ zio_write_compress(zio_t *zio)
+ zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
+ ASSERT(spa_feature_is_active(spa,
+ SPA_FEATURE_EMBEDDED_DATA));
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ } else {
+ /*
+ * Round up compressed size up to the ashift
+@@ -1459,10 +1477,10 @@ zio_write_compress(zio_t *zio)
+ zio->io_pipeline |= ZIO_STAGE_NOP_WRITE;
+ }
+ }
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+-static int
++static zio_t *
+ zio_free_bp_init(zio_t *zio)
+ {
+ blkptr_t *bp = zio->io_bp;
+@@ -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 +1561,12 @@ zio_taskq_member(zio_t *zio, zio_taskq_type_t q)
+ return (B_FALSE);
+ }
+
+-static int
++static zio_t *
+ zio_issue_async(zio_t *zio)
+ {
+ zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_FALSE);
+
+- return (ZIO_PIPELINE_STOP);
++ return (NULL);
+ }
+
+ void
+@@ -1687,14 +1707,13 @@ __attribute__((always_inline))
+ static inline void
+ __zio_execute(zio_t *zio)
+ {
+- zio->io_executor = curthread;
+-
+ ASSERT3U(zio->io_queued_timestamp, >, 0);
+
+ while (zio->io_stage < ZIO_STAGE_DONE) {
+ enum zio_stage pipeline = zio->io_pipeline;
+ enum zio_stage stage = zio->io_stage;
+- int rv;
++
++ zio->io_executor = curthread;
+
+ ASSERT(!MUTEX_HELD(&zio->io_lock));
+ ASSERT(ISP2(stage));
+@@ -1736,12 +1755,16 @@ __zio_execute(zio_t *zio)
+
+ zio->io_stage = stage;
+ zio->io_pipeline_trace |= zio->io_stage;
+- rv = zio_pipeline[highbit64(stage) - 1](zio);
+
+- if (rv == ZIO_PIPELINE_STOP)
+- return;
++ /*
++ * The zio pipeline stage returns the next zio to execute
++ * (typically the same as this one), or NULL if we should
++ * stop.
++ */
++ zio = zio_pipeline[highbit64(stage) - 1](zio);
+
+- ASSERT(rv == ZIO_PIPELINE_CONTINUE);
++ if (zio == NULL)
++ return;
+ }
+ }
+
+@@ -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);
+ }
+
+-static int
++static zio_t *
+ zio_gang_assemble(zio_t *zio)
+ {
+ blkptr_t *bp = zio->io_bp;
+@@ -2227,16 +2250,16 @@ zio_gang_assemble(zio_t *zio)
+
+ zio_gang_tree_assemble(zio, bp, &zio->io_gang_tree);
+
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+-static int
++static zio_t *
+ zio_gang_issue(zio_t *zio)
+ {
+ blkptr_t *bp = zio->io_bp;
+
+ if (zio_wait_for_children(zio, ZIO_CHILD_GANG_BIT, ZIO_WAIT_DONE)) {
+- return (ZIO_PIPELINE_STOP);
++ return (NULL);
+ }
+
+ ASSERT(BP_IS_GANG(bp) && zio->io_gang_leader == zio);
+@@ -2250,7 +2273,7 @@ zio_gang_issue(zio_t *zio)
+
+ zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
+
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+ static void
+@@ -2290,7 +2313,7 @@ zio_write_gang_done(zio_t *zio)
+ abd_put(zio->io_abd);
+ }
+
+-static int
++static zio_t *
+ zio_write_gang_block(zio_t *pio)
+ {
+ spa_t *spa = pio->io_spa;
+@@ -2349,7 +2372,7 @@ zio_write_gang_block(zio_t *pio)
+ }
+
+ pio->io_error = error;
+- return (ZIO_PIPELINE_CONTINUE);
++ return (pio);
+ }
+
+ if (pio == gio) {
+@@ -2423,7 +2446,7 @@ zio_write_gang_block(zio_t *pio)
+
+ zio_nowait(zio);
+
+- return (ZIO_PIPELINE_CONTINUE);
++ return (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.
+ */
+-static int
++static zio_t *
+ zio_nop_write(zio_t *zio)
+ {
+ blkptr_t *bp = zio->io_bp;
+@@ -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))
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+
+ /*
+ * If the checksums match then reset the pipeline so that we
+@@ -2491,7 +2514,7 @@ zio_nop_write(zio_t *zio)
+ zio->io_flags |= ZIO_FLAG_NOPWRITE;
+ }
+
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+ /*
+@@ -2519,7 +2542,7 @@ zio_ddt_child_read_done(zio_t *zio)
+ mutex_exit(&pio->io_lock);
+ }
+
+-static int
++static zio_t *
+ zio_ddt_read_start(zio_t *zio)
+ {
+ blkptr_t *bp = zio->io_bp;
+@@ -2540,7 +2563,7 @@ zio_ddt_read_start(zio_t *zio)
+ zio->io_vsd = dde;
+
+ if (ddp_self == NULL)
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+
+ for (p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
+ if (ddp->ddp_phys_birth == 0 || ddp == ddp_self)
+@@ -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));
+ }
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+ zio_nowait(zio_read(zio, zio->io_spa, bp,
+ zio->io_abd, zio->io_size, NULL, NULL, zio->io_priority,
+ ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark));
+
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+-static int
++static zio_t *
+ zio_ddt_read_done(zio_t *zio)
+ {
+ blkptr_t *bp = zio->io_bp;
+
+ if (zio_wait_for_children(zio, ZIO_CHILD_DDT_BIT, ZIO_WAIT_DONE)) {
+- return (ZIO_PIPELINE_STOP);
++ return (NULL);
+ }
+
+ ASSERT(BP_GET_DEDUP(bp));
+@@ -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);
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+ if (dde == NULL) {
+ zio->io_stage = ZIO_STAGE_DDT_READ_START >> 1;
+ zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_FALSE);
+- return (ZIO_PIPELINE_STOP);
++ return (NULL);
+ }
+ if (dde->dde_repair_abd != NULL) {
+ abd_copy(zio->io_abd, dde->dde_repair_abd,
+@@ -2599,7 +2622,7 @@ zio_ddt_read_done(zio_t *zio)
+
+ ASSERT(zio->io_vsd == NULL);
+
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+ static boolean_t
+@@ -2780,7 +2803,7 @@ zio_ddt_ditto_write_done(zio_t *zio)
+ ddt_exit(ddt);
+ }
+
+-static int
++static zio_t *
+ zio_ddt_write(zio_t *zio)
+ {
+ spa_t *spa = zio->io_spa;
+@@ -2822,7 +2845,7 @@ zio_ddt_write(zio_t *zio)
+ }
+ zio->io_pipeline = ZIO_WRITE_PIPELINE;
+ ddt_exit(ddt);
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+ ditto_copies = ddt_ditto_copies_needed(ddt, dde, ddp);
+@@ -2848,7 +2871,7 @@ zio_ddt_write(zio_t *zio)
+ zio->io_bp_override = NULL;
+ BP_ZERO(bp);
+ ddt_exit(ddt);
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+ dio = zio_write(zio, spa, txg, bp, zio->io_orig_abd,
+@@ -2890,12 +2913,12 @@ zio_ddt_write(zio_t *zio)
+ if (dio)
+ zio_nowait(dio);
+
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+ ddt_entry_t *freedde; /* for debugging */
+
+-static int
++static zio_t *
+ zio_ddt_free(zio_t *zio)
+ {
+ spa_t *spa = zio->io_spa;
+@@ -2916,7 +2939,7 @@ zio_ddt_free(zio_t *zio)
+ }
+ ddt_exit(ddt);
+
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+ /*
+@@ -2953,7 +2976,7 @@ zio_io_to_allocate(spa_t *spa)
+ return (zio);
+ }
+
+-static int
++static zio_t *
+ zio_dva_throttle(zio_t *zio)
+ {
+ spa_t *spa = zio->io_spa;
+@@ -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) {
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+ ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
+@@ -2979,22 +3002,7 @@ zio_dva_throttle(zio_t *zio)
+ nio = zio_io_to_allocate(zio->io_spa);
+ mutex_exit(&spa->spa_alloc_lock);
+
+- if (nio == zio)
+- return (ZIO_PIPELINE_CONTINUE);
+-
+- if (nio != NULL) {
+- ASSERT(nio->io_stage == ZIO_STAGE_DVA_THROTTLE);
+- /*
+- * We are passing control to a new zio so make sure that
+- * it is processed by a different thread. We do this to
+- * avoid stack overflows that can occur when parents are
+- * throttled and children are making progress. We allow
+- * it to go to the head of the taskq since it's already
+- * been waiting.
+- */
+- zio_taskq_dispatch(nio, ZIO_TASKQ_ISSUE, B_TRUE);
+- }
+- return (ZIO_PIPELINE_STOP);
++ return (nio);
+ }
+
+ void
+@@ -3013,7 +3021,7 @@ zio_allocate_dispatch(spa_t *spa)
+ zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_TRUE);
+ }
+
+-static int
++static zio_t *
+ zio_dva_allocate(zio_t *zio)
+ {
+ spa_t *spa = zio->io_spa;
+@@ -3054,18 +3062,18 @@ zio_dva_allocate(zio_t *zio)
+ zio->io_error = error;
+ }
+
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+-static int
++static zio_t *
+ zio_dva_free(zio_t *zio)
+ {
+ metaslab_free(zio->io_spa, zio->io_bp, zio->io_txg, B_FALSE);
+
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+-static int
++static zio_t *
+ zio_dva_claim(zio_t *zio)
+ {
+ int error;
+@@ -3074,7 +3082,7 @@ zio_dva_claim(zio_t *zio)
+ if (error)
+ zio->io_error = error;
+
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+ /*
+@@ -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.
+ */
+-static int
++static zio_t *
+ zio_vdev_io_start(zio_t *zio)
+ {
+ vdev_t *vd = zio->io_vd;
+@@ -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);
+- return (ZIO_PIPELINE_STOP);
++ return (NULL);
+ }
+
+ ASSERT3P(zio->io_logical, !=, 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);
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+ if (vd->vdev_ops->vdev_op_leaf &&
+ (zio->io_type == ZIO_TYPE_READ || zio->io_type == ZIO_TYPE_WRITE)) {
+
+ if (zio->io_type == ZIO_TYPE_READ && vdev_cache_read(zio))
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+
+ if ((zio = vdev_queue_io(zio)) == NULL)
+- return (ZIO_PIPELINE_STOP);
++ return (NULL);
+
+ if (!vdev_accessible(vd, zio)) {
+ zio->io_error = SET_ERROR(ENXIO);
+ zio_interrupt(zio);
+- return (ZIO_PIPELINE_STOP);
++ return (NULL);
+ }
+ zio->io_delay = gethrtime();
+ }
+
+ vd->vdev_ops->vdev_op_io_start(zio);
+- return (ZIO_PIPELINE_STOP);
++ return (NULL);
+ }
+
+-static int
++static zio_t *
+ zio_vdev_io_done(zio_t *zio)
+ {
+ vdev_t *vd = zio->io_vd;
+@@ -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)) {
+- return (ZIO_PIPELINE_STOP);
++ return (NULL);
+ }
+
+ ASSERT(zio->io_type == ZIO_TYPE_READ || zio->io_type == ZIO_TYPE_WRITE);
+@@ -3337,7 +3345,7 @@ zio_vdev_io_done(zio_t *zio)
+ if (unexpected_error)
+ VERIFY(vdev_probe(vd, zio) == NULL);
+
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+ /*
+@@ -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;
+ }
+
+-static int
++static zio_t *
+ zio_vdev_io_assess(zio_t *zio)
+ {
+ vdev_t *vd = zio->io_vd;
+
+ if (zio_wait_for_children(zio, ZIO_CHILD_VDEV_BIT, ZIO_WAIT_DONE)) {
+- return (ZIO_PIPELINE_STOP);
++ return (NULL);
+ }
+
+ if (vd == NULL && !(zio->io_flags & ZIO_FLAG_CONFIG_WRITER))
+@@ -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);
+- return (ZIO_PIPELINE_STOP);
++ return (NULL);
+ }
+
+ /*
+@@ -3442,7 +3450,7 @@ zio_vdev_io_assess(zio_t *zio)
+ zio->io_physdone(zio->io_logical);
+ }
+
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+ void
+@@ -3477,7 +3485,7 @@ zio_vdev_io_bypass(zio_t *zio)
+ * Generate and verify checksums
+ * ==========================================================================
+ */
+-static int
++static zio_t *
+ zio_checksum_generate(zio_t *zio)
+ {
+ blkptr_t *bp = zio->io_bp;
+@@ -3491,7 +3499,7 @@ zio_checksum_generate(zio_t *zio)
+ checksum = zio->io_prop.zp_checksum;
+
+ if (checksum == ZIO_CHECKSUM_OFF)
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+
+ ASSERT(checksum == ZIO_CHECKSUM_LABEL);
+ } else {
+@@ -3505,10 +3513,10 @@ zio_checksum_generate(zio_t *zio)
+
+ zio_checksum_compute(zio, checksum, zio->io_abd, zio->io_size);
+
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+-static int
++static zio_t *
+ zio_checksum_verify(zio_t *zio)
+ {
+ zio_bad_cksum_t info;
+@@ -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)
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+
+ ASSERT(zio->io_prop.zp_checksum == ZIO_CHECKSUM_LABEL);
+ }
+@@ -3538,7 +3546,7 @@ zio_checksum_verify(zio_t *zio)
+ }
+ }
+
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+ /*
+@@ -3581,7 +3589,7 @@ zio_worst_error(int e1, int e2)
+ * I/O completion
+ * ==========================================================================
+ */
+-static int
++static zio_t *
+ zio_ready(zio_t *zio)
+ {
+ blkptr_t *bp = zio->io_bp;
+@@ -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)) {
+- return (ZIO_PIPELINE_STOP);
++ return (NULL);
+ }
+
+ if (zio->io_ready) {
+@@ -3636,7 +3644,7 @@ zio_ready(zio_t *zio)
+ */
+ for (; pio != NULL; pio = pio_next) {
+ pio_next = zio_walk_parents(zio, &zl);
+- zio_notify_parent(pio, zio, ZIO_WAIT_READY);
++ zio_notify_parent(pio, zio, ZIO_WAIT_READY, NULL);
+ }
+
+ if (zio->io_flags & ZIO_FLAG_NODATA) {
+@@ -3652,7 +3660,7 @@ zio_ready(zio_t *zio)
+ zio->io_spa->spa_syncing_txg == zio->io_txg)
+ zio_handle_ignored_writes(zio);
+
+- return (ZIO_PIPELINE_CONTINUE);
++ return (zio);
+ }
+
+ /*
+@@ -3716,7 +3724,7 @@ zio_dva_throttle_done(zio_t *zio)
+ zio_allocate_dispatch(zio->io_spa);
+ }
+
+-static int
++static zio_t *
+ 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)) {
+- return (ZIO_PIPELINE_STOP);
++ return (NULL);
+ }
+
+ /*
+@@ -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);
+- zio_notify_parent(pio, zio, ZIO_WAIT_DONE);
++ /*
++ * This is a rare code path, so we don't
++ * bother with "next_to_execute".
++ */
++ zio_notify_parent(pio, zio, ZIO_WAIT_DONE,
++ NULL);
+ }
+ }
+
+@@ -3969,7 +3982,11 @@ zio_done(zio_t *zio)
+ */
+ ASSERT(!(zio->io_flags & ZIO_FLAG_GODFATHER));
+ zio->io_flags |= ZIO_FLAG_DONT_PROPAGATE;
+- zio_notify_parent(pio, zio, ZIO_WAIT_DONE);
++ /*
++ * This is a rare code path, so we don't bother with
++ * "next_to_execute".
++ */
++ zio_notify_parent(pio, zio, ZIO_WAIT_DONE, NULL);
+ } else if (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND) {
+ /*
+ * We'd fail again if we reexecuted now, so suspend
+@@ -3987,7 +4004,7 @@ zio_done(zio_t *zio)
+ (task_func_t *)zio_reexecute, zio, 0,
+ &zio->io_tqent);
+ }
+- return (ZIO_PIPELINE_STOP);
++ return (NULL);
+ }
+
+ ASSERT(zio->io_child_count == 0);
+@@ -4023,12 +4040,17 @@ zio_done(zio_t *zio)
+ zio->io_state[ZIO_WAIT_DONE] = 1;
+ mutex_exit(&zio->io_lock);
+
++ /*
++ * We are done executing this zio. We may want to execute a parent
++ * next. See the comment in zio_notify_parent().
++ */
++ zio_t *next_to_execute = NULL;
+ zl = NULL;
+ for (pio = zio_walk_parents(zio, &zl); pio != NULL; pio = pio_next) {
+ zio_link_t *remove_zl = zl;
+ pio_next = zio_walk_parents(zio, &zl);
+ zio_remove_child(pio, zio, remove_zl);
+- zio_notify_parent(pio, zio, ZIO_WAIT_DONE);
++ zio_notify_parent(pio, zio, ZIO_WAIT_DONE, &next_to_execute);
+ }
+
+ if (zio->io_waiter != NULL) {
+@@ -4040,7 +4062,7 @@ zio_done(zio_t *zio)
+ zio_destroy(zio);
+ }
+
+- return (ZIO_PIPELINE_STOP);
++ return (next_to_execute);
+ }
+
+ /*
+++ /dev/null
-From c37a6401469cae16519db06d623d49c6f606f312 Mon Sep 17 00:00:00 2001
-From: Thomas Lamprecht <t.lamprecht@proxmox.com>
-Date: Wed, 31 Oct 2018 15:37:39 +0100
-Subject: [PATCH] Revert "Install init scripts to support non-systemd setups.
- (Closes: #826994)"
-
-This reverts commit 2ad6c7f9e150e9c2fa146891785b09465aa0c7e5.
-
-Breaks on systems with sysv-rc installed (possible on Jessie upgraded
-systems)
-
-Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
----
- 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
- delete mode 120000 debian/zfsutils-linux.zfs-mount.init
- delete mode 120000 debian/zfsutils-linux.zfs-share.init
-
-diff --git a/debian/rules b/debian/rules
-index 5fba58ff..81c301e4 100644
---- a/debian/rules
-+++ b/debian/rules
-@@ -161,14 +153,6 @@ override_dh_install:
- find . -name lib*.la -delete
- dh_install --fail-missing
-
--override_dh_installinit:
-- dh_installinit -r --no-start --name zfs-import
-- dh_installinit -r --no-start --name zfs-mount
-- dh_installinit -r --no-start --name zfs-share
-- dh_installinit -R --no-start --name zfs-zed
-- mkdir -p debian/zfsutils-linux/lib/systemd/system
-- ln -sr /dev/null debian/zfsutils-linux/lib/systemd/system/zfs-import.service
--
- # ------------
-
- override_dh_prep-deb-files:
-diff --git a/debian/zfs-zed.zfs-zed.init b/debian/zfs-zed.zfs-zed.init
-deleted file mode 120000
-index 3f41f681..00000000
---- a/debian/zfs-zed.zfs-zed.init
-+++ /dev/null
-@@ -1 +0,0 @@
--../etc/init.d/zfs-zed
-\ No newline at end of file
-diff --git a/debian/zfsutils-linux.zfs-import.init b/debian/zfsutils-linux.zfs-import.init
-deleted file mode 120000
-index bfc368fd..00000000
---- a/debian/zfsutils-linux.zfs-import.init
-+++ /dev/null
-@@ -1 +0,0 @@
--../etc/init.d/zfs-import
-\ No newline at end of file
-diff --git a/debian/zfsutils-linux.zfs-mount.init b/debian/zfsutils-linux.zfs-mount.init
-deleted file mode 120000
-index 62a54433..00000000
---- a/debian/zfsutils-linux.zfs-mount.init
-+++ /dev/null
-@@ -1 +0,0 @@
--../etc/init.d/zfs-mount
-\ No newline at end of file
-diff --git a/debian/zfsutils-linux.zfs-share.init b/debian/zfsutils-linux.zfs-share.init
-deleted file mode 120000
-index 3f069f9b..00000000
---- a/debian/zfsutils-linux.zfs-share.init
-+++ /dev/null
-@@ -1 +0,0 @@
--../etc/init.d/zfs-share
-\ No newline at end of file
---
-2.19.1
-
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Olaf Faaland <faaland1@llnl.gov>
+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 <behlendorf1@llnl.gov>
+Reviewed-by: Gu Zheng <guzheng2331314@163.com>
+Signed-off-by: Olaf Faaland <faaland1@llnl.gov>
+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"
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Brian Behlendorf <behlendorf1@llnl.gov>
+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 <andreas.dilger@whamcloud.com>
+Reviewed-by: Richard Yao <ryao@gentoo.org>
+Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
+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 <linux/compat.h>
++ ],[
++ 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 <sys/taskq.h>
+ #include <sys/cred.h>
+ #include <linux/backing-dev.h>
++#include <linux/compat.h>
+
+ /*
+ * 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);
+ }
+
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Gregor Kopka <mailfrom-github@kopka.net>
+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 <hutter2@llnl.gov>
+Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
+Signed-off-by: Gregor Kopka <gregor@kopka.net>
+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);
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Tim Schumacher <timschumi@gmx.de>
+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 <fpletz@fnordicwalking.de>
+Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
+Signed-off-by: Tim Schumacher <timschumi@gmx.de>
+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 <linux/posix_acl.h>
+
+@@ -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)
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Tim Schumacher <timschumi@gmx.de>
+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 <mahrens@delphix.com>
+Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
+Signed-off-by: Tim Schumacher <timschumi@gmx.de>
+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));
+ }
+
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Brian Behlendorf <behlendorf1@llnl.gov>
+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 <mahrens@delphix.com>
+Signed-off-by: Tom Caputi <tcaputi@datto.com>
+Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
+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);
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: George Melikov <mail@gmelikov.ru>
+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 <kash@tripleback.net>
+Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
+Signed-off-by: George Melikov <mail@gmelikov.ru>
+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:<pool>/<dataset> (uses this for rpool - first part, without 'zfs:')
+ #
+ # Option <dataset> could also be <snapshot>
++ # Option <pool> could also be <guid>
+
+ # ------------
+ # Support force option
+@@ -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.
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Brian Behlendorf <behlendorf1@llnl.gov>
+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 <tuxoko@gmail.com>
+Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
+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 {
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Brian Behlendorf <behlendorf1@llnl.gov>
+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 <john.kennedy@delphix.com>
+Reviewed-by: Richard Elling <Richard.Elling@RichardElling.com>
+Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
+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():
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Tony Hutter <hutter2@llnl.gov>
+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 <ngompa@datto.com>
+Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
+Signed-off-by: Tony Hutter <hutter2@llnl.gov>
+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
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Tony Hutter <hutter2@llnl.gov>
+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 <hutter2@llnl.gov>
+---
+ 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 <hutter2@llnl.gov> - 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 <hutter2@llnl.gov> - 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 <hutter2@llnl.gov> - 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 <hutter2@llnl.gov> - 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
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
projects / zfsonlinux.git / commitdiff