c/zfsonlinux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

zfs: rebase patches on top of 0.7.12-2

Browse Source 
and drop those that are part of 0.7.12

Reviewed-by: Stoiko Ivanov <s.ivanov@proxmox.com>
Tested-by: Stoiko Ivanov <s.ivanov@proxmox.com>
Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
This commit is contained in:
Fabian Grünbichler 2019-01-30 14:25:27 +01:00
parent 002d5f1b8c
commit 2249b05575
21 changed files with 68 additions and 5375 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
zfs-patches/0001-remove-DKMS-modules-and-dracut-build.patch
View File

@ -9,26 +9,14 @@ Content-Transfer-Encoding: 8bit
Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
Signed-off-by: Stoiko Ivanov <s.ivanov@proxmox.com>
---
debian/control.in | 40 ++--------------
debian/control | 1 -
debian/control.in | 40 ++-----------------
debian/not-installed | 2 +
debian/rules | 108 +--------------------------------------------------
debian/rules | 108 +------------------------------------------
4 files changed, 7 insertions(+), 144 deletions(-)
diff --git a/debian/control b/debian/control
index 4d22ff50..f33008df 100644
--- a/debian/control
+++ b/debian/control
@@ -10,7 +10,6 @@ Build-Depends: autotools-dev,
debhelper (>= 10.2),
dh-autoreconf,
dh-python,
- dkms (>> 2.1.1.2-5),
libattr1-dev,
libblkid-dev,
libselinux1-dev,
diff --git a/debian/control.in b/debian/control.in
index 96154c5c..0a9ceef6 100644
index ab62ea676..978b39e91 100644
--- a/debian/control.in
+++ b/debian/control.in
@@ -10,7 +10,6 @@ Build-Depends: autotools-dev,
@ -39,7 +27,7 @@ index 96154c5c..0a9ceef6 100644
libattr1-dev,
libblkid-dev,
libselinux1-dev,
@@ -95,26 +94,10 @@ Description: OpenZFS pool library for Linux
@@ -96,26 +95,10 @@ Description: OpenZFS pool library for Linux
.
This zpool library provides support for managing zpools.
@ -47,7 +35,7 @@ index 96154c5c..0a9ceef6 100644
-Architecture: all
-Pre-Depends: spl-dkms (<<${source:Upstream-Version}.),
- spl-dkms (>= ${source:Upstream-Version})
-Depends: dkms (>> 2.1.1.2-5), lsb-release, ${misc:Depends}
-Depends: dkms (>> 2.1.1.2-5), lsb-release, ${misc:Depends}, ${perl:Depends},
-Recommends: zfs-zed, zfsutils-linux (>= ${binary:Version}), @LINUX_COMPAT@
-Provides: zfs-modules
-Description: OpenZFS filesystem kernel modules for Linux
@ -65,8 +53,8 @@ index 96154c5c..0a9ceef6 100644
- zfs-modules | zfs-dkms,
zfsutils-linux (>= ${binary:Version}),
${misc:Depends}
Description: OpenZFS root filesystem capabilities for Linux - initramfs
@@ -125,29 +108,14 @@ Description: OpenZFS root filesystem capabilities for Linux - initramfs
Breaks: zfsutils-linux (<= 0.7.11-2)
@@ -128,29 +111,14 @@ Description: OpenZFS root filesystem capabilities for Linux - initramfs
This package adds OpenZFS to the system initramfs with a hook
for the initramfs-tools infrastructure.
@ -95,10 +83,10 @@ index 96154c5c..0a9ceef6 100644
samba-common-bin (>= 3.0.23),
- zfs-initramfs | zfs-dracut
+ zfs-initramfs
Conflicts: zfs, zfs-fuse
Conflicts: zfs, zfs-fuse, insserv (<< 1.18)
Provides: zfsutils
Description: command-line tools to manage OpenZFS filesystems
@@ -161,8 +129,7 @@ Description: command-line tools to manage OpenZFS filesystems
@@ -164,8 +132,7 @@ Description: command-line tools to manage OpenZFS filesystems
Package: zfs-zed
Section: contrib/admin
Architecture: linux-any
@ -108,7 +96,7 @@ index 96154c5c..0a9ceef6 100644
${misc:Depends},
${shlibs:Depends}
Description: OpenZFS Event Daemon
@@ -185,7 +152,6 @@ Depends: acl,
@@ -188,7 +155,6 @@ Depends: acl,
python,
sudo,
sysstat,
@ -116,8 +104,20 @@ index 96154c5c..0a9ceef6 100644
zfsutils-linux (>=${binary:Version}),
${misc:Depends},
${shlibs:Depends}
diff --git a/debian/control b/debian/control
index 7e47f3673..763f45df8 100644
--- a/debian/control
+++ b/debian/control
@@ -10,7 +10,6 @@ Build-Depends: autotools-dev,
debhelper (>= 10.2),
dh-autoreconf,
dh-python,
- dkms (>> 2.1.1.2-5),
libattr1-dev,
libblkid-dev,
libselinux1-dev,
diff --git a/debian/not-installed b/debian/not-installed
index a008985c..c60b0016 100644
index a008985cf..c60b0016f 100644
--- a/debian/not-installed
+++ b/debian/not-installed
@@ -6,3 +6,5 @@ etc/zfs/vdev_id.conf.alias.example
@ -127,7 +127,7 @@ index a008985c..c60b0016 100644
+usr/lib/dracut
+usr/share/zfs/enum-extract.pl
diff --git a/debian/rules b/debian/rules
index 21b8ccef..3ba4b99a 100755
index b4c885a6f..a7ad2b96b 100755
--- a/debian/rules
+++ b/debian/rules
@@ -6,9 +6,6 @@ LSB_DISTRIBUTOR := $(shell lsb_release -is)

2
zfs-patches/0002-import-with-d-dev-disk-by-id-in-scan-service.patch
View File

@ -13,7 +13,7 @@ Signed-off-by: Stoiko Ivanov <s.ivanov@proxmox.com>
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/etc/systemd/system/zfs-import-scan.service.in b/etc/systemd/system/zfs-import-scan.service.in
index abc8e8e6..8fe2c107 100644
index abc8e8e6d..8fe2c1072 100644
--- a/etc/systemd/system/zfs-import-scan.service.in
+++ b/etc/systemd/system/zfs-import-scan.service.in
@@ -12,7 +12,7 @@ ConditionPathExists=!@sysconfdir@/zfs/zpool.cache

2
zfs-patches/0003-always-load-ZFS-module-on-boot.patch
View File

@ -18,7 +18,7 @@ Signed-off-by: Stoiko Ivanov <s.ivanov@proxmox.com>
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/etc/modules-load.d/zfs.conf.in b/etc/modules-load.d/zfs.conf.in
index 8b41baa3..59b058c9 100644
index 8b41baa30..59b058c9a 100644
--- a/etc/modules-load.d/zfs.conf.in
+++ b/etc/modules-load.d/zfs.conf.in
@@ -1,3 +1,3 @@

40
zfs-patches/0004-Add-Breaks-Replaces-to-zfs-initramfs.patch
View File

@ -8,31 +8,35 @@ zfs-initramfs
Signed-off-by: Stoiko Ivanov <s.ivanov@proxmox.com>
---
debian/control | 2 ++
debian/control.in | 2 ++
2 files changed, 4 insertions(+)
debian/control.in | 4 ++--
debian/control | 4 ++--
2 files changed, 4 insertions(+), 4 deletions(-)
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
index 978b39e91..b623596f6 100644
--- a/debian/control.in
+++ b/debian/control.in
@@ -100,6 +100,8 @@ Depends: busybox-initramfs | busybox-static | busybox,
@@ -101,8 +101,8 @@ Depends: busybox-initramfs | busybox-static | busybox,
initramfs-tools,
zfsutils-linux (>= ${binary:Version}),
${misc:Depends}
-Breaks: zfsutils-linux (<= 0.7.11-2)
-Replaces: zfsutils-linux (<= 0.7.11-2)
+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 b/debian/control
index 763f45df8..29cdc886f 100644
--- a/debian/control
+++ b/debian/control
@@ -117,8 +117,8 @@ Depends: busybox-initramfs | busybox-static | busybox,
zfs-modules | zfs-dkms,
zfsutils-linux (>= ${binary:Version}),
${misc:Depends}
-Breaks: zfsutils-linux (<= 0.7.11-2)
-Replaces: zfsutils-linux (<= 0.7.11-2)
+Breaks: zfsutils-linux (<= 0.7.11-pve1~bpo1)
+Replaces: zfsutils-linux (<= 0.7.11-pve1~bpo1)
Description: OpenZFS root filesystem capabilities for Linux - initramfs

18
zfs-patches/0005-Revert-Install-init-scripts-to-support-non-systemd-s.patch
View File

@ -23,7 +23,7 @@ Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
delete mode 120000 debian/zfsutils-linux.zfs-share.init
diff --git a/debian/rules b/debian/rules
index 3ba4b99a..d6cf5a56 100755
index a7ad2b96b..d6cf5a56f 100755
--- a/debian/rules
+++ b/debian/rules
@@ -117,14 +117,6 @@ override_dh_install:
@ -31,10 +31,10 @@ index 3ba4b99a..d6cf5a56 100755
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
- dh_installinit -R --name zfs-import
- dh_installinit -R --name zfs-mount
- dh_installinit -R --name zfs-share
- dh_installinit -R --name zfs-zed
- mkdir -p debian/zfsutils-linux/lib/systemd/system
- ln -sr /dev/null debian/zfsutils-linux/lib/systemd/system/zfs-import.service
-
@ -43,7 +43,7 @@ index 3ba4b99a..d6cf5a56 100755
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
index 3f41f6813..000000000
--- a/debian/zfs-zed.zfs-zed.init
+++ /dev/null
@@ -1 +0,0 @@
@ -51,7 +51,7 @@ index 3f41f681..00000000
\ 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
index bfc368fd3..000000000
--- a/debian/zfsutils-linux.zfs-import.init
+++ /dev/null
@@ -1 +0,0 @@
@ -59,7 +59,7 @@ index bfc368fd..00000000
\ 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
index 62a544332..000000000
--- a/debian/zfsutils-linux.zfs-mount.init
+++ /dev/null
@@ -1 +0,0 @@
@ -67,7 +67,7 @@ index 62a54433..00000000
\ 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
index 3f069f9ba..000000000
--- a/debian/zfsutils-linux.zfs-share.init
+++ /dev/null
@@ -1 +0,0 @@

2
zfs-patches/0006-Fix-deadlock-between-zfs-umount-snapentry_expire.patch
View File

@ -28,7 +28,7 @@ Signed-off-by: Stoiko Ivanov <s.ivanov@proxmox.com>
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
index bf5a1d059..2964b65a6 100644
--- a/module/zfs/zfs_ctldir.c
+++ b/module/zfs/zfs_ctldir.c
@@ -358,8 +358,6 @@ snapentry_expire(void *data)

20
zfs-patches/0007-deadlock-between-mm_sem-and-tx-assign-in-zfs_write-a.patch
View File

@ -25,15 +25,15 @@ Closes #7939
(backported from: zfs-upstream 779a6c0bf6df76e0dd92c1ccf81f48512b835bb0)
Signed-off-by: Stoiko Ivanov <s.ivanov@proxmox.com>
---
include/sys/uio_impl.h | 2 +-
module/zcommon/zfs_uio.c | 31 ++++-
module/zfs/zfs_vnops.c | 24 +++-
tests/zfs-tests/cmd/mmapwrite/mmapwrite.c | 140 +++++++++++++++------
.../tests/functional/mmap/mmap_write_001_pos.ksh | 8 +-
include/sys/uio_impl.h | 2 +-
module/zcommon/zfs_uio.c | 31 +++-
module/zfs/zfs_vnops.c | 24 ++-
tests/zfs-tests/cmd/mmapwrite/mmapwrite.c | 140 +++++++++++++-----
.../functional/mmap/mmap_write_001_pos.ksh | 8 +-
5 files changed, 151 insertions(+), 54 deletions(-)
diff --git a/include/sys/uio_impl.h b/include/sys/uio_impl.h
index 37e283da..cfef0b95 100644
index 37e283da0..cfef0b95d 100644
--- a/include/sys/uio_impl.h
+++ b/include/sys/uio_impl.h
@@ -42,7 +42,7 @@
@ -46,7 +46,7 @@ index 37e283da..cfef0b95 100644
extern void uioskip(uio_t *, size_t);
diff --git a/module/zcommon/zfs_uio.c b/module/zcommon/zfs_uio.c
index 7b4175bb..8e969bbc 100644
index 7b4175bbe..8e969bbcc 100644
--- a/module/zcommon/zfs_uio.c
+++ b/module/zcommon/zfs_uio.c
@@ -50,6 +50,7 @@
@ -124,7 +124,7 @@ index 7b4175bb..8e969bbc 100644
EXPORT_SYMBOL(uio_prefaultpages);
diff --git a/module/zfs/zfs_vnops.c b/module/zfs/zfs_vnops.c
index 5a2e55eb..c866352d 100644
index 5a2e55eb1..c866352d7 100644
--- a/module/zfs/zfs_vnops.c
+++ b/module/zfs/zfs_vnops.c
@@ -675,7 +675,10 @@ zfs_write(struct inode *ip, uio_t *uio, int ioflag, cred_t *cr)
@ -175,7 +175,7 @@ index 5a2e55eb..c866352d 100644
zfs_inode_update(zp);
diff --git a/tests/zfs-tests/cmd/mmapwrite/mmapwrite.c b/tests/zfs-tests/cmd/mmapwrite/mmapwrite.c
index 190d31af..b9915d5d 100644
index 190d31af3..b9915d5d3 100644
--- a/tests/zfs-tests/cmd/mmapwrite/mmapwrite.c
+++ b/tests/zfs-tests/cmd/mmapwrite/mmapwrite.c
@@ -31,74 +31,132 @@
@ -353,7 +353,7 @@ index 190d31af..b9915d5d 100644
return (0);
}
diff --git a/tests/zfs-tests/tests/functional/mmap/mmap_write_001_pos.ksh b/tests/zfs-tests/tests/functional/mmap/mmap_write_001_pos.ksh
index 1eda9710..24150b82 100755
index 1eda97104..24150b827 100755
--- a/tests/zfs-tests/tests/functional/mmap/mmap_write_001_pos.ksh
+++ b/tests/zfs-tests/tests/functional/mmap/mmap_write_001_pos.ksh
@@ -53,12 +53,14 @@ if ! is_mp; then

251
zfs-patches/0008-Fix-race-in-dnode_check_slots_free.patch
View File

@ -1,251 +0,0 @@
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;
}

859
zfs-patches/0009-Reduce-taskq-and-context-switch-cost-of-zio-pipe.patch
View File

@ -1,859 +0,0 @@
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);
}
/*

221
zfs-patches/0010-Skip-import-activity-test-in-more-zdb-code-paths.patch
View File

@ -1,221 +0,0 @@
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"

180
zfs-patches/0011-Fix-statfs-2-for-32-bit-user-space.patch
View File

@ -1,180 +0,0 @@
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);
}

86
zfs-patches/0012-Zpool-iostat-remove-latency-queue-scaling.patch
View File

@ -1,86 +0,0 @@
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);

878
zfs-patches/0013-Linux-4.19-rc3-compat-Remove-refcount_t-compat.patch
View File

@ -1,878 +0,0 @@
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)

2527
zfs-patches/0014-Prefix-all-refcount-functions-with-zfs_.patch
View File

File diff suppressed because it is too large Load Diff

29
zfs-patches/0015-Fix-arc_release-refcount.patch
View File

@ -1,29 +0,0 @@
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);

59
zfs-patches/0016-Allow-use-of-pool-GUID-as-root-pool.patch
View File

@ -1,59 +0,0 @@
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.

67
zfs-patches/0017-ZTS-Update-O_TMPFILE-support-check.patch
View File

@ -1,67 +0,0 @@
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 {

35
zfs-patches/0018-Fix-flake8-invalid-escape-sequence-x-warning.patch
View File

@ -1,35 +0,0 @@
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():

51
zfs-patches/0019-Add-BuildRequires-gcc-make-elfutils-libelf-devel.patch
View File

@ -1,51 +0,0 @@
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

55
zfs-patches/0020-Tag-zfs-0.7.12.patch
View File

@ -1,55 +0,0 @@
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

13
zfs-patches/series
View File

@ -5,16 +5,3 @@
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-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