From bb7155fd8f0052191116b26c9367542f15e135d4 Mon Sep 17 00:00:00 2001 From: Thomas Lamprecht Date: Mon, 29 Aug 2022 18:09:15 +0200 Subject: [PATCH] backport fixes of regressions from newer stable kernels Signed-off-by: Thomas Lamprecht --- ...5-Adjust-log_max_qp-to-be-18-at-most.patch | 37 ++++++++++ ...te-steal-time-cache-if-MSR-value-cha.patch | 60 ++++++++++++++++ ...eport-preemption-if-the-steal-time-c.patch | 47 +++++++++++++ ...-qla2xxx-Fix-disk-failure-to-redisco.patch | 70 +++++++++++++++++++ ...le_buffered_write-endless-loop-worka.patch | 30 ++++++++ 5 files changed, 244 insertions(+) create mode 100644 patches/kernel/0027-net-mlx5-Adjust-log_max_qp-to-be-18-at-most.patch create mode 100644 patches/kernel/0028-KVM-x86-revalidate-steal-time-cache-if-MSR-value-cha.patch create mode 100644 patches/kernel/0029-KVM-x86-do-not-report-preemption-if-the-steal-time-c.patch create mode 100644 patches/kernel/0030-scsi-Revert-scsi-qla2xxx-Fix-disk-failure-to-redisco.patch create mode 100644 patches/kernel/0031-gfs2-Fix-gfs2_file_buffered_write-endless-loop-worka.patch diff --git a/patches/kernel/0027-net-mlx5-Adjust-log_max_qp-to-be-18-at-most.patch b/patches/kernel/0027-net-mlx5-Adjust-log_max_qp-to-be-18-at-most.patch new file mode 100644 index 0000000..261abb0 --- /dev/null +++ b/patches/kernel/0027-net-mlx5-Adjust-log_max_qp-to-be-18-at-most.patch @@ -0,0 +1,37 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Maher Sanalla +Date: Sun, 24 Jul 2022 11:28:21 +0300 +Subject: [PATCH] net/mlx5: Adjust log_max_qp to be 18 at most + +[ Upstream commit a6e9085d791f8306084fd5bc44dd3fdd4e1ac27b ] + +The cited commit limited log_max_qp to be 17 due to FW capabilities. +Recently, it turned out that there are old FW versions that supported +more than 17, so the cited commit caused a degradation. + +Thus, set the maximum log_max_qp back to 18 as it was before the +cited commit. + +Fixes: 7f839965b2d7 ("net/mlx5: Update log_max_qp value to be 17 at most") +Signed-off-by: Maher Sanalla +Reviewed-by: Maor Gottlieb +Signed-off-by: Saeed Mahameed +Signed-off-by: Sasha Levin +Signed-off-by: Thomas Lamprecht +--- + drivers/net/ethernet/mellanox/mlx5/core/main.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/main.c b/drivers/net/ethernet/mellanox/mlx5/core/main.c +index 4ed740994279..5a6606c843ed 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/main.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/main.c +@@ -516,7 +516,7 @@ static int handle_hca_cap(struct mlx5_core_dev *dev, void *set_ctx) + + /* Check log_max_qp from HCA caps to set in current profile */ + if (prof->log_max_qp == LOG_MAX_SUPPORTED_QPS) { +- prof->log_max_qp = min_t(u8, 17, MLX5_CAP_GEN_MAX(dev, log_max_qp)); ++ prof->log_max_qp = min_t(u8, 18, MLX5_CAP_GEN_MAX(dev, log_max_qp)); + } else if (MLX5_CAP_GEN_MAX(dev, log_max_qp) < prof->log_max_qp) { + mlx5_core_warn(dev, "log_max_qp value in current profile is %d, changing it to HCA capability limit (%d)\n", + prof->log_max_qp, diff --git a/patches/kernel/0028-KVM-x86-revalidate-steal-time-cache-if-MSR-value-cha.patch b/patches/kernel/0028-KVM-x86-revalidate-steal-time-cache-if-MSR-value-cha.patch new file mode 100644 index 0000000..8382faf --- /dev/null +++ b/patches/kernel/0028-KVM-x86-revalidate-steal-time-cache-if-MSR-value-cha.patch @@ -0,0 +1,60 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Paolo Bonzini +Date: Thu, 4 Aug 2022 15:28:32 +0200 +Subject: [PATCH] KVM: x86: revalidate steal time cache if MSR value changes + +commit 901d3765fa804ce42812f1d5b1f3de2dfbb26723 upstream. + +Commit 7e2175ebd695 ("KVM: x86: Fix recording of guest steal time +/ preempted status", 2021-11-11) open coded the previous call to +kvm_map_gfn, but in doing so it dropped the comparison between the cached +guest physical address and the one in the MSR. This cause an incorrect +cache hit if the guest modifies the steal time address while the memslots +remain the same. This can happen with kexec, in which case the steal +time data is written at the address used by the old kernel instead of +the old one. + +While at it, rename the variable from gfn to gpa since it is a plain +physical address and not a right-shifted one. + +Reported-by: Dave Young +Reported-by: Xiaoying Yan +Analyzed-by: Dr. David Alan Gilbert +Cc: David Woodhouse +Cc: stable@vger.kernel.org +Fixes: 7e2175ebd695 ("KVM: x86: Fix recording of guest steal time / preempted status") +Signed-off-by: Paolo Bonzini +Signed-off-by: Greg Kroah-Hartman +Signed-off-by: Thomas Lamprecht +--- + arch/x86/kvm/x86.c | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c +index 461c9d815d6c..b46677baf396 100644 +--- a/arch/x86/kvm/x86.c ++++ b/arch/x86/kvm/x86.c +@@ -3236,6 +3236,7 @@ static void record_steal_time(struct kvm_vcpu *vcpu) + struct gfn_to_hva_cache *ghc = &vcpu->arch.st.cache; + struct kvm_steal_time __user *st; + struct kvm_memslots *slots; ++ gpa_t gpa = vcpu->arch.st.msr_val & KVM_STEAL_VALID_BITS; + u64 steal; + u32 version; + +@@ -3253,13 +3254,12 @@ static void record_steal_time(struct kvm_vcpu *vcpu) + slots = kvm_memslots(vcpu->kvm); + + if (unlikely(slots->generation != ghc->generation || ++ gpa != ghc->gpa || + kvm_is_error_hva(ghc->hva) || !ghc->memslot)) { +- gfn_t gfn = vcpu->arch.st.msr_val & KVM_STEAL_VALID_BITS; +- + /* We rely on the fact that it fits in a single page. */ + BUILD_BUG_ON((sizeof(*st) - 1) & KVM_STEAL_VALID_BITS); + +- if (kvm_gfn_to_hva_cache_init(vcpu->kvm, ghc, gfn, sizeof(*st)) || ++ if (kvm_gfn_to_hva_cache_init(vcpu->kvm, ghc, gpa, sizeof(*st)) || + kvm_is_error_hva(ghc->hva) || !ghc->memslot) + return; + } diff --git a/patches/kernel/0029-KVM-x86-do-not-report-preemption-if-the-steal-time-c.patch b/patches/kernel/0029-KVM-x86-do-not-report-preemption-if-the-steal-time-c.patch new file mode 100644 index 0000000..b61364e --- /dev/null +++ b/patches/kernel/0029-KVM-x86-do-not-report-preemption-if-the-steal-time-c.patch @@ -0,0 +1,47 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Paolo Bonzini +Date: Thu, 4 Aug 2022 15:28:32 +0200 +Subject: [PATCH] KVM: x86: do not report preemption if the steal time cache is + stale + +commit c3c28d24d910a746b02f496d190e0e8c6560224b upstream. + +Commit 7e2175ebd695 ("KVM: x86: Fix recording of guest steal time +/ preempted status", 2021-11-11) open coded the previous call to +kvm_map_gfn, but in doing so it dropped the comparison between the cached +guest physical address and the one in the MSR. This cause an incorrect +cache hit if the guest modifies the steal time address while the memslots +remain the same. This can happen with kexec, in which case the preempted +bit is written at the address used by the old kernel instead of +the old one. + +Cc: David Woodhouse +Cc: stable@vger.kernel.org +Fixes: 7e2175ebd695 ("KVM: x86: Fix recording of guest steal time / preempted status") +Signed-off-by: Paolo Bonzini +Signed-off-by: Greg Kroah-Hartman +Signed-off-by: Thomas Lamprecht +--- + arch/x86/kvm/x86.c | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c +index b46677baf396..48aaff0ce3b9 100644 +--- a/arch/x86/kvm/x86.c ++++ b/arch/x86/kvm/x86.c +@@ -4370,6 +4370,7 @@ static void kvm_steal_time_set_preempted(struct kvm_vcpu *vcpu) + struct kvm_steal_time __user *st; + struct kvm_memslots *slots; + static const u8 preempted = KVM_VCPU_PREEMPTED; ++ gpa_t gpa = vcpu->arch.st.msr_val & KVM_STEAL_VALID_BITS; + + if (!(vcpu->arch.st.msr_val & KVM_MSR_ENABLED)) + return; +@@ -4384,6 +4385,7 @@ static void kvm_steal_time_set_preempted(struct kvm_vcpu *vcpu) + slots = kvm_memslots(vcpu->kvm); + + if (unlikely(slots->generation != ghc->generation || ++ gpa != ghc->gpa || + kvm_is_error_hva(ghc->hva) || !ghc->memslot)) + return; + diff --git a/patches/kernel/0030-scsi-Revert-scsi-qla2xxx-Fix-disk-failure-to-redisco.patch b/patches/kernel/0030-scsi-Revert-scsi-qla2xxx-Fix-disk-failure-to-redisco.patch new file mode 100644 index 0000000..83025b9 --- /dev/null +++ b/patches/kernel/0030-scsi-Revert-scsi-qla2xxx-Fix-disk-failure-to-redisco.patch @@ -0,0 +1,70 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Nilesh Javali +Date: Tue, 12 Jul 2022 22:20:36 -0700 +Subject: [PATCH] scsi: Revert "scsi: qla2xxx: Fix disk failure to rediscover" + +commit 5bc7b01c513a4a9b4cfe306e8d1720cfcfd3b8a3 upstream. + +This fixes the regression of NVMe discovery failure during driver load +time. + +This reverts commit 6a45c8e137d4e2c72eecf1ac7cf64f2fdfcead99. + +Link: https://lore.kernel.org/r/20220713052045.10683-2-njavali@marvell.com +Cc: stable@vger.kernel.org +Reviewed-by: Himanshu Madhani +Signed-off-by: Nilesh Javali +Signed-off-by: Martin K. Petersen +Signed-off-by: Greg Kroah-Hartman +Signed-off-by: Thomas Lamprecht +--- + drivers/scsi/qla2xxx/qla_init.c | 5 ++--- + drivers/scsi/qla2xxx/qla_nvme.c | 5 ----- + 2 files changed, 2 insertions(+), 8 deletions(-) + +diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c +index af8df5a800c6..7caf573af58e 100644 +--- a/drivers/scsi/qla2xxx/qla_init.c ++++ b/drivers/scsi/qla2xxx/qla_init.c +@@ -5749,8 +5749,6 @@ qla2x00_reg_remote_port(scsi_qla_host_t *vha, fc_port_t *fcport) + if (atomic_read(&fcport->state) == FCS_ONLINE) + return; + +- qla2x00_set_fcport_state(fcport, FCS_ONLINE); +- + rport_ids.node_name = wwn_to_u64(fcport->node_name); + rport_ids.port_name = wwn_to_u64(fcport->port_name); + rport_ids.port_id = fcport->d_id.b.domain << 16 | +@@ -5858,7 +5856,6 @@ qla2x00_update_fcport(scsi_qla_host_t *vha, fc_port_t *fcport) + qla2x00_reg_remote_port(vha, fcport); + break; + case MODE_TARGET: +- qla2x00_set_fcport_state(fcport, FCS_ONLINE); + if (!vha->vha_tgt.qla_tgt->tgt_stop && + !vha->vha_tgt.qla_tgt->tgt_stopped) + qlt_fc_port_added(vha, fcport); +@@ -5873,6 +5870,8 @@ qla2x00_update_fcport(scsi_qla_host_t *vha, fc_port_t *fcport) + break; + } + ++ qla2x00_set_fcport_state(fcport, FCS_ONLINE); ++ + if (IS_IIDMA_CAPABLE(vha->hw) && vha->hw->flags.gpsc_supported) { + if (fcport->id_changed) { + fcport->id_changed = 0; +diff --git a/drivers/scsi/qla2xxx/qla_nvme.c b/drivers/scsi/qla2xxx/qla_nvme.c +index 42b29f4fd937..e63272487788 100644 +--- a/drivers/scsi/qla2xxx/qla_nvme.c ++++ b/drivers/scsi/qla2xxx/qla_nvme.c +@@ -35,11 +35,6 @@ int qla_nvme_register_remote(struct scsi_qla_host *vha, struct fc_port *fcport) + (fcport->nvme_flag & NVME_FLAG_REGISTERED)) + return 0; + +- if (atomic_read(&fcport->state) == FCS_ONLINE) +- return 0; +- +- qla2x00_set_fcport_state(fcport, FCS_ONLINE); +- + fcport->nvme_flag &= ~NVME_FLAG_RESETTING; + + memset(&req, 0, sizeof(struct nvme_fc_port_info)); diff --git a/patches/kernel/0031-gfs2-Fix-gfs2_file_buffered_write-endless-loop-worka.patch b/patches/kernel/0031-gfs2-Fix-gfs2_file_buffered_write-endless-loop-worka.patch new file mode 100644 index 0000000..ae012b9 --- /dev/null +++ b/patches/kernel/0031-gfs2-Fix-gfs2_file_buffered_write-endless-loop-worka.patch @@ -0,0 +1,30 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Andreas Gruenbacher +Date: Thu, 17 Mar 2022 14:47:24 +0100 +Subject: [PATCH] gfs2: Fix gfs2_file_buffered_write endless loop workaround + +[ Upstream commit 46f3e0421ccb5474b5c006b0089b9dfd42534bb6 ] + +Since commit 554c577cee95b, gfs2_file_buffered_write() can accidentally +return a truncated iov_iter, which might confuse callers. Fix that. + +Fixes: 554c577cee95b ("gfs2: Prevent endless loops in gfs2_file_buffered_write") +Signed-off-by: Andreas Gruenbacher +Signed-off-by: Sasha Levin +Signed-off-by: Thomas Lamprecht +--- + fs/gfs2/file.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c +index 60390f9dc31f..e93185d804e0 100644 +--- a/fs/gfs2/file.c ++++ b/fs/gfs2/file.c +@@ -1086,6 +1086,7 @@ static ssize_t gfs2_file_buffered_write(struct kiocb *iocb, + gfs2_holder_uninit(gh); + if (statfs_gh) + kfree(statfs_gh); ++ from->count = orig_count - read; + return read ? read : ret; + } +