diff --git a/patches.drivers/ALSA-usb-audio-fix-a-memory-leak-bug.patch b/patches.drivers/ALSA-usb-audio-fix-a-memory-leak-bug.patch new file mode 100644 index 0000000..19a6635 --- /dev/null +++ b/patches.drivers/ALSA-usb-audio-fix-a-memory-leak-bug.patch @@ -0,0 +1,39 @@ +From a67060201b746a308b1674f66bf289c9faef6d09 Mon Sep 17 00:00:00 2001 +From: Wenwen Wang +Date: Tue, 6 Aug 2019 03:00:27 -0400 +Subject: [PATCH] ALSA: usb-audio: fix a memory leak bug +Git-commit: a67060201b746a308b1674f66bf289c9faef6d09 +Patch-mainline: v5.3-rc4 +References: bsc#1111666 + +In snd_usb_get_audioformat_uac3(), a structure for channel maps 'chmap' is +allocated through kzalloc() before the execution goto 'found_clock'. +However, this structure is not deallocated if the memory allocation for +'pd' fails, leading to a memory leak bug. + +To fix the above issue, free 'fp->chmap' before returning NULL. + +Fixes: 7edf3b5e6a45 ("ALSA: usb-audio: AudioStreaming Power Domain parsing") +Signed-off-by: Wenwen Wang +Cc: +Signed-off-by: Takashi Iwai + +--- + sound/usb/stream.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/sound/usb/stream.c b/sound/usb/stream.c +index 7ee9d17d0143..e852c7fd6109 100644 +--- a/sound/usb/stream.c ++++ b/sound/usb/stream.c +@@ -1043,6 +1043,7 @@ snd_usb_get_audioformat_uac3(struct snd_usb_audio *chip, + + pd = kzalloc(sizeof(*pd), GFP_KERNEL); + if (!pd) { ++ kfree(fp->chmap); + kfree(fp->rate_table); + kfree(fp); + return NULL; +-- +2.16.4 + diff --git a/patches.drivers/mmc-sdhci-pci-Fix-BYT-OCP-setting.patch b/patches.drivers/mmc-sdhci-pci-Fix-BYT-OCP-setting.patch new file mode 100644 index 0000000..98108b4 --- /dev/null +++ b/patches.drivers/mmc-sdhci-pci-Fix-BYT-OCP-setting.patch @@ -0,0 +1,184 @@ +From 0a49a619e7e1aeb3f5f5511ca59314423c83dae2 Mon Sep 17 00:00:00 2001 +From: Adrian Hunter +Date: Mon, 6 May 2019 11:38:53 +0300 +Subject: [PATCH] mmc: sdhci-pci: Fix BYT OCP setting +Git-commit: 0a49a619e7e1aeb3f5f5511ca59314423c83dae2 +Patch-mainline: v5.2-rc1 +References: bsc#1051510 + +Some time ago, a fix was done for the sdhci-acpi driver, refer +commit 6e1c7d6103fe ("mmc: sdhci-acpi: Reduce Baytrail eMMC/SD/SDIO +hangs"). The same issue was not expected to affect the sdhci-pci driver, +but there have been reports to the contrary, so make the same hardware +setting change. + +This patch applies to v5.0+ but before that backports will be required. + +Signed-off-by: Adrian Hunter +Cc: stable@vger.kernel.org +Signed-off-by: Ulf Hansson +Acked-by: Takashi Iwai + +--- + drivers/mmc/host/Kconfig | 1 + drivers/mmc/host/sdhci-pci-core.c | 96 ++++++++++++++++++++++++++++++++++++++ + 2 files changed, 97 insertions(+) + +--- a/drivers/mmc/host/Kconfig ++++ b/drivers/mmc/host/Kconfig +@@ -73,6 +73,7 @@ config MMC_SDHCI_PCI + tristate "SDHCI support on PCI bus" + depends on MMC_SDHCI && PCI + select MMC_CQHCI ++ select IOSF_MBI if X86 + help + This selects the PCI Secure Digital Host Controller Interface. + Most controllers found today are PCI devices. +--- a/drivers/mmc/host/sdhci-pci-core.c ++++ b/drivers/mmc/host/sdhci-pci-core.c +@@ -30,6 +30,10 @@ + #include + #include + ++#ifdef CONFIG_X86 ++#include ++#endif ++ + #include "cqhci.h" + + #include "sdhci.h" +@@ -456,6 +460,50 @@ static const struct sdhci_pci_fixes sdhc + .probe_slot = pch_hc_probe_slot, + }; + ++#ifdef CONFIG_X86 ++ ++#define BYT_IOSF_SCCEP 0x63 ++#define BYT_IOSF_OCP_NETCTRL0 0x1078 ++#define BYT_IOSF_OCP_TIMEOUT_BASE GENMASK(10, 8) ++ ++static void byt_ocp_setting(struct pci_dev *pdev) ++{ ++ u32 val = 0; ++ ++ if (pdev->device != PCI_DEVICE_ID_INTEL_BYT_EMMC && ++ pdev->device != PCI_DEVICE_ID_INTEL_BYT_SDIO && ++ pdev->device != PCI_DEVICE_ID_INTEL_BYT_SD && ++ pdev->device != PCI_DEVICE_ID_INTEL_BYT_EMMC2) ++ return; ++ ++ if (iosf_mbi_read(BYT_IOSF_SCCEP, MBI_CR_READ, BYT_IOSF_OCP_NETCTRL0, ++ &val)) { ++ dev_err(&pdev->dev, "%s read error\n", __func__); ++ return; ++ } ++ ++ if (!(val & BYT_IOSF_OCP_TIMEOUT_BASE)) ++ return; ++ ++ val &= ~BYT_IOSF_OCP_TIMEOUT_BASE; ++ ++ if (iosf_mbi_write(BYT_IOSF_SCCEP, MBI_CR_WRITE, BYT_IOSF_OCP_NETCTRL0, ++ val)) { ++ dev_err(&pdev->dev, "%s write error\n", __func__); ++ return; ++ } ++ ++ dev_dbg(&pdev->dev, "%s completed\n", __func__); ++} ++ ++#else ++ ++static inline void byt_ocp_setting(struct pci_dev *pdev) ++{ ++} ++ ++#endif ++ + enum { + INTEL_DSM_FNS = 0, + INTEL_DSM_V18_SWITCH = 3, +@@ -696,6 +744,8 @@ static void byt_probe_slot(struct sdhci_ + + byt_read_dsm(slot); + ++ byt_ocp_setting(slot->chip->pdev); ++ + ops->execute_tuning = intel_execute_tuning; + } + +@@ -860,7 +910,35 @@ static int byt_sd_probe_slot(struct sdhc + return 0; + } + ++#ifdef CONFIG_PM_SLEEP ++ ++static int byt_resume(struct sdhci_pci_chip *chip) ++{ ++ byt_ocp_setting(chip->pdev); ++ ++ return sdhci_pci_resume_host(chip); ++} ++ ++#endif ++ ++#ifdef CONFIG_PM ++ ++static int byt_runtime_resume(struct sdhci_pci_chip *chip) ++{ ++ byt_ocp_setting(chip->pdev); ++ ++ return sdhci_pci_runtime_resume_host(chip); ++} ++ ++#endif ++ + static const struct sdhci_pci_fixes sdhci_intel_byt_emmc = { ++#ifdef CONFIG_PM_SLEEP ++ .resume = byt_resume, ++#endif ++#ifdef CONFIG_PM ++ .runtime_resume = byt_runtime_resume, ++#endif + .allow_runtime_pm = true, + .probe_slot = byt_emmc_probe_slot, + .quirks = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC, +@@ -892,6 +970,12 @@ static const struct sdhci_pci_fixes sdhc + }; + + static const struct sdhci_pci_fixes sdhci_ni_byt_sdio = { ++#ifdef CONFIG_PM_SLEEP ++ .resume = byt_resume, ++#endif ++#ifdef CONFIG_PM ++ .runtime_resume = byt_runtime_resume, ++#endif + .quirks = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC, + .quirks2 = SDHCI_QUIRK2_HOST_OFF_CARD_ON | + SDHCI_QUIRK2_PRESET_VALUE_BROKEN, +@@ -902,6 +986,12 @@ static const struct sdhci_pci_fixes sdhc + }; + + static const struct sdhci_pci_fixes sdhci_intel_byt_sdio = { ++#ifdef CONFIG_PM_SLEEP ++ .resume = byt_resume, ++#endif ++#ifdef CONFIG_PM ++ .runtime_resume = byt_runtime_resume, ++#endif + .quirks = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC, + .quirks2 = SDHCI_QUIRK2_HOST_OFF_CARD_ON | + SDHCI_QUIRK2_PRESET_VALUE_BROKEN, +@@ -912,6 +1002,12 @@ static const struct sdhci_pci_fixes sdhc + }; + + static const struct sdhci_pci_fixes sdhci_intel_byt_sd = { ++#ifdef CONFIG_PM_SLEEP ++ .resume = byt_resume, ++#endif ++#ifdef CONFIG_PM ++ .runtime_resume = byt_runtime_resume, ++#endif + .quirks = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC, + .quirks2 = SDHCI_QUIRK2_CARD_ON_NEEDS_BUS_ON | + SDHCI_QUIRK2_PRESET_VALUE_BROKEN | diff --git a/patches.drivers/scsi-cxgb4i-fix-incorrect-spelling-reveive-receive b/patches.drivers/scsi-cxgb4i-fix-incorrect-spelling-reveive-receive new file mode 100644 index 0000000..f917e6c --- /dev/null +++ b/patches.drivers/scsi-cxgb4i-fix-incorrect-spelling-reveive-receive @@ -0,0 +1,28 @@ +From: Varun Prakash +Date: Sun, 14 Apr 2019 21:15:12 +0530 +Subject: scsi: cxgb4i: fix incorrect spelling "reveive" -> "receive" +Git-commit: 21112e13cc7aba49f68bdecb19306e610fe0c3bf +Patch-mainline: v5.2-rc1 +References: bsc#1136346 jsc#SLE-4682 + +Signed-off-by: Varun Prakash +Signed-off-by: Martin K. Petersen +Acked-by: Lee Duncan +--- + drivers/scsi/cxgbi/cxgb4i/cxgb4i.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c b/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c +index d44914e5e415..124f3345420f 100644 +--- a/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c ++++ b/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c +@@ -60,7 +60,7 @@ MODULE_PARM_DESC(dbg_level, "Debug flag (default=0)"); + #define CXGB4I_DEFAULT_10G_RCV_WIN (256 * 1024) + static int cxgb4i_rcv_win = -1; + module_param(cxgb4i_rcv_win, int, 0644); +-MODULE_PARM_DESC(cxgb4i_rcv_win, "TCP reveive window in bytes"); ++MODULE_PARM_DESC(cxgb4i_rcv_win, "TCP receive window in bytes"); + + #define CXGB4I_DEFAULT_10G_SND_WIN (128 * 1024) + static int cxgb4i_snd_win = -1; + diff --git a/patches.drivers/scsi-cxgb4i-get-pf-number-from-lldi-pf b/patches.drivers/scsi-cxgb4i-get-pf-number-from-lldi-pf new file mode 100644 index 0000000..aeb3310 --- /dev/null +++ b/patches.drivers/scsi-cxgb4i-get-pf-number-from-lldi-pf @@ -0,0 +1,32 @@ +From: Varun Prakash +Date: Thu, 21 Feb 2019 19:34:23 +0530 +Subject: scsi: cxgb4i: get pf number from lldi->pf +Git-commit: b184487c1ac9504cb1f8d02751eac00f0c1581fb +Patch-mainline: v5.1-rc1 +References: bsc#1136346 jsc#SLE-4682 + +Instead of using viid to get pf number, directly get pf number from +lldi->pf. + +Signed-off-by: Varun Prakash +Signed-off-by: Martin K. Petersen +Acked-by: Lee Duncan +--- + drivers/scsi/cxgbi/cxgb4i/cxgb4i.c | 3 +-- + 1 file changed, 1 insertion(+), 2 deletions(-) + +diff --git a/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c b/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c +index 49f8028ac524..ba14a4cdf120 100644 +--- a/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c ++++ b/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c +@@ -2122,8 +2122,7 @@ static void *t4_uld_add(const struct cxgb4_lld_info *lldi) + cdev->itp = &cxgb4i_iscsi_transport; + cdev->owner = THIS_MODULE; + +- cdev->pfvf = FW_VIID_PFN_G(cxgb4_port_viid(lldi->ports[0])) +- << FW_VIID_PFN_S; ++ cdev->pfvf = FW_PFVF_CMD_PFN_V(lldi->pf); + pr_info("cdev 0x%p,%s, pfvf %u.\n", + cdev, lldi->ports[0]->name, cdev->pfvf); + + diff --git a/patches.drivers/scsi-cxgb4i-validate-tcp-sequence-number-only-if-chip-version-t5 b/patches.drivers/scsi-cxgb4i-validate-tcp-sequence-number-only-if-chip-version-t5 new file mode 100644 index 0000000..00ae7aa --- /dev/null +++ b/patches.drivers/scsi-cxgb4i-validate-tcp-sequence-number-only-if-chip-version-t5 @@ -0,0 +1,33 @@ +From: Varun Prakash +Date: Thu, 21 Feb 2019 20:12:16 +0530 +Subject: scsi: cxgb4i: validate tcp sequence number only if chip version <= T5 +Git-commit: 26af1a368e40618d67956b1f883fbcfec292c5d8 +Patch-mainline: v5.1-rc1 +References: bsc#1136346 jsc#SLE-4682 + +T6 adapters generates DDP completion message on receiving all iSCSI pdus in +a sequence. Because of this, driver can not keep track of tcp sequence +number for T6 adapters. + +Signed-off-by: Varun Prakash +Signed-off-by: Martin K. Petersen +Acked-by: Lee Duncan +--- + drivers/scsi/cxgbi/cxgb4i/cxgb4i.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +diff --git a/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c b/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c +index ba14a4cdf120..bab06b947af3 100644 +--- a/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c ++++ b/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c +@@ -1210,7 +1210,8 @@ static void do_rx_iscsi_hdr(struct cxgbi_device *cdev, struct sk_buff *skb) + csk->skb_ulp_lhdr = skb; + cxgbi_skcb_set_flag(skb, SKCBF_RX_HDR); + +- if (cxgbi_skcb_tcp_seq(skb) != csk->rcv_nxt) { ++ if ((CHELSIO_CHIP_VERSION(lldi->adapter_type) <= CHELSIO_T5) && ++ (cxgbi_skcb_tcp_seq(skb) != csk->rcv_nxt)) { + pr_info("tid %u, CPL_ISCSI_HDR, bad seq, 0x%x/0x%x.\n", + csk->tid, cxgbi_skcb_tcp_seq(skb), + csk->rcv_nxt); + diff --git a/patches.drivers/scsi-pmcraid-don-t-allocate-a-dma-coherent-buffer-fo.patch b/patches.drivers/scsi-pmcraid-don-t-allocate-a-dma-coherent-buffer-fo.patch new file mode 100644 index 0000000..7627119 --- /dev/null +++ b/patches.drivers/scsi-pmcraid-don-t-allocate-a-dma-coherent-buffer-fo.patch @@ -0,0 +1,59 @@ +From: Christoph Hellwig +Date: Thu, 18 Oct 2018 15:05:36 +0200 +Subject: scsi: pmcraid: don't allocate a dma coherent buffer for sense data +Patch-mainline: v5.0-rc1 +Git-commit: a9b9e3adc9a98ce59a8544d31da597807a473bd1 +References: bsc#1135990 jsc#SLE-4709 + +We can just dma map the sense buffer passed with the scsi command, +and that gets us out of the nasty business of doing dma coherent +allocations from irq context. + +Signed-off-by: Christoph Hellwig +Signed-off-by: Martin K. Petersen +Acked-by: Daniel Wagner +--- + drivers/scsi/pmcraid.c | 24 ++++++++---------------- + 1 file changed, 8 insertions(+), 16 deletions(-) + +--- a/drivers/scsi/pmcraid.c ++++ b/drivers/scsi/pmcraid.c +@@ -851,16 +851,9 @@ static void pmcraid_erp_done(struct pmcr + cmd->ioa_cb->ioarcb.cdb[0], ioasc); + } + +- /* if we had allocated sense buffers for request sense, copy the sense +- * release the buffers +- */ +- if (cmd->sense_buffer != NULL) { +- memcpy(scsi_cmd->sense_buffer, +- cmd->sense_buffer, +- SCSI_SENSE_BUFFERSIZE); +- pci_free_consistent(pinstance->pdev, +- SCSI_SENSE_BUFFERSIZE, +- cmd->sense_buffer, cmd->sense_buffer_dma); ++ if (cmd->sense_buffer) { ++ dma_unmap_single(&pinstance->pdev->dev, cmd->sense_buffer_dma, ++ SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE); + cmd->sense_buffer = NULL; + cmd->sense_buffer_dma = 0; + } +@@ -2451,13 +2444,12 @@ static void pmcraid_request_sense(struct + { + struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb; + struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl; ++ struct device *dev = &cmd->drv_inst->pdev->dev; + +- /* allocate DMAable memory for sense buffers */ +- cmd->sense_buffer = pci_alloc_consistent(cmd->drv_inst->pdev, +- SCSI_SENSE_BUFFERSIZE, +- &cmd->sense_buffer_dma); +- +- if (cmd->sense_buffer == NULL) { ++ cmd->sense_buffer = cmd->scsi_cmd->sense_buffer; ++ cmd->sense_buffer_dma = dma_map_single(dev, cmd->sense_buffer, ++ SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE); ++ if (dma_mapping_error(dev, cmd->sense_buffer_dma)) { + pmcraid_err + ("couldn't allocate sense buffer for request sense\n"); + pmcraid_erp_done(cmd); diff --git a/patches.drivers/scsi-pmcraid-simplify-pmcraid_cancel_all-a-bit.patch b/patches.drivers/scsi-pmcraid-simplify-pmcraid_cancel_all-a-bit.patch new file mode 100644 index 0000000..586c351 --- /dev/null +++ b/patches.drivers/scsi-pmcraid-simplify-pmcraid_cancel_all-a-bit.patch @@ -0,0 +1,67 @@ +From: Christoph Hellwig +Date: Thu, 18 Oct 2018 15:05:35 +0200 +Subject: scsi: pmcraid: simplify pmcraid_cancel_all a bit +Patch-mainline: v5.0-rc1 +Git-commit: 203654b42ff12782322558db5479057089248a28 +References: bsc#1135990 jsc#SLE-4709 + +No need for a local cmd_done variable, and pass boolean values as bool +type instead of u32. + +Signed-off-by: Christoph Hellwig +Signed-off-by: Martin K. Petersen +Acked-by: Daniel Wagner +--- + drivers/scsi/pmcraid.c | 13 ++++++------- + 1 file changed, 6 insertions(+), 7 deletions(-) + +--- a/drivers/scsi/pmcraid.c ++++ b/drivers/scsi/pmcraid.c +@@ -2498,17 +2498,15 @@ static void pmcraid_request_sense(struct + /** + * pmcraid_cancel_all - cancel all outstanding IOARCBs as part of error recovery + * @cmd: command that failed +- * @sense: true if request_sense is required after cancel all ++ * @need_sense: true if request_sense is required after cancel all + * + * This function sends a cancel all to a device to clear the queue. + */ +-static void pmcraid_cancel_all(struct pmcraid_cmd *cmd, u32 sense) ++static void pmcraid_cancel_all(struct pmcraid_cmd *cmd, bool need_sense) + { + struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd; + struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb; + struct pmcraid_resource_entry *res = scsi_cmd->device->hostdata; +- void (*cmd_done) (struct pmcraid_cmd *) = sense ? pmcraid_erp_done +- : pmcraid_request_sense; + + memset(ioarcb->cdb, 0, PMCRAID_MAX_CDB_LEN); + ioarcb->request_flags0 = SYNC_OVERRIDE; +@@ -2526,7 +2524,8 @@ static void pmcraid_cancel_all(struct pm + /* writing to IOARRIN must be protected by host_lock, as mid-layer + * schedule queuecommand while we are doing this + */ +- pmcraid_send_cmd(cmd, cmd_done, ++ pmcraid_send_cmd(cmd, need_sense ? ++ pmcraid_erp_done : pmcraid_request_sense, + PMCRAID_REQUEST_SENSE_TIMEOUT, + pmcraid_timeout_handler); + } +@@ -2619,7 +2618,7 @@ static int pmcraid_error_handler(struct + struct pmcraid_ioasa *ioasa = &cmd->ioa_cb->ioasa; + u32 ioasc = le32_to_cpu(ioasa->ioasc); + u32 masked_ioasc = ioasc & PMCRAID_IOASC_SENSE_MASK; +- u32 sense_copied = 0; ++ bool sense_copied = false; + + if (!res) { + pmcraid_info("resource pointer is NULL\n"); +@@ -2691,7 +2690,7 @@ static int pmcraid_error_handler(struct + memcpy(scsi_cmd->sense_buffer, + ioasa->sense_data, + data_size); +- sense_copied = 1; ++ sense_copied = true; + } + + if (RES_IS_GSCSI(res->cfg_entry)) diff --git a/patches.drivers/scsi-pmcraid-use-generic-DMA-API.patch b/patches.drivers/scsi-pmcraid-use-generic-DMA-API.patch new file mode 100644 index 0000000..0650b97 --- /dev/null +++ b/patches.drivers/scsi-pmcraid-use-generic-DMA-API.patch @@ -0,0 +1,227 @@ +From: Christoph Hellwig +Date: Thu, 18 Oct 2018 15:05:37 +0200 +Subject: scsi: pmcraid: use generic DMA API +Patch-mainline: v5.0-rc1 +Git-commit: 371a6c328ad423c51ffcf68ec211d3eeb80f1874 +References: bsc#1135990 jsc#SLE-4709 + +Switch from the legacy PCI DMA API to the generic DMA API. + +Signed-off-by: Christoph Hellwig +Signed-off-by: Martin K. Petersen +Acked-by: Daniel Wagner +--- + drivers/scsi/pmcraid.c | 79 ++++++++++++++++++++++--------------------------- + 1 file changed, 36 insertions(+), 43 deletions(-) + +--- a/drivers/scsi/pmcraid.c ++++ b/drivers/scsi/pmcraid.c +@@ -3556,7 +3556,7 @@ static int pmcraid_build_passthrough_ioa + return -ENOMEM; + } + +- sglist->num_dma_sg = pci_map_sg(cmd->drv_inst->pdev, ++ sglist->num_dma_sg = dma_map_sg(&cmd->drv_inst->pdev->dev, + sglist->scatterlist, + sglist->num_sg, direction); + +@@ -3605,7 +3605,7 @@ static void pmcraid_release_passthrough_ + struct pmcraid_sglist *sglist = cmd->sglist; + + if (buflen > 0) { +- pci_unmap_sg(cmd->drv_inst->pdev, ++ dma_unmap_sg(&cmd->drv_inst->pdev->dev, + sglist->scatterlist, + sglist->num_sg, + direction); +@@ -4741,9 +4741,9 @@ static void + pmcraid_release_host_rrqs(struct pmcraid_instance *pinstance, int maxindex) + { + int i; +- for (i = 0; i < maxindex; i++) { + +- pci_free_consistent(pinstance->pdev, ++ for (i = 0; i < maxindex; i++) { ++ dma_free_coherent(&pinstance->pdev->dev, + HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD, + pinstance->hrrq_start[i], + pinstance->hrrq_start_bus_addr[i]); +@@ -4770,11 +4770,9 @@ static int pmcraid_allocate_host_rrqs(st + + for (i = 0; i < pinstance->num_hrrq; i++) { + pinstance->hrrq_start[i] = +- pci_alloc_consistent( +- pinstance->pdev, +- buffer_size, +- &(pinstance->hrrq_start_bus_addr[i])); +- ++ dma_alloc_coherent(&pinstance->pdev->dev, buffer_size, ++ &pinstance->hrrq_start_bus_addr[i], ++ GFP_KERNEL); + if (!pinstance->hrrq_start[i]) { + pmcraid_err("pci_alloc failed for hrrq vector : %d\n", + i); +@@ -4803,7 +4801,7 @@ static int pmcraid_allocate_host_rrqs(st + static void pmcraid_release_hcams(struct pmcraid_instance *pinstance) + { + if (pinstance->ccn.msg != NULL) { +- pci_free_consistent(pinstance->pdev, ++ dma_free_coherent(&pinstance->pdev->dev, + PMCRAID_AEN_HDR_SIZE + + sizeof(struct pmcraid_hcam_ccn_ext), + pinstance->ccn.msg, +@@ -4815,7 +4813,7 @@ static void pmcraid_release_hcams(struct + } + + if (pinstance->ldn.msg != NULL) { +- pci_free_consistent(pinstance->pdev, ++ dma_free_coherent(&pinstance->pdev->dev, + PMCRAID_AEN_HDR_SIZE + + sizeof(struct pmcraid_hcam_ldn), + pinstance->ldn.msg, +@@ -4836,17 +4834,15 @@ static void pmcraid_release_hcams(struct + */ + static int pmcraid_allocate_hcams(struct pmcraid_instance *pinstance) + { +- pinstance->ccn.msg = pci_alloc_consistent( +- pinstance->pdev, ++ pinstance->ccn.msg = dma_alloc_coherent(&pinstance->pdev->dev, + PMCRAID_AEN_HDR_SIZE + + sizeof(struct pmcraid_hcam_ccn_ext), +- &(pinstance->ccn.baddr)); ++ &pinstance->ccn.baddr, GFP_KERNEL); + +- pinstance->ldn.msg = pci_alloc_consistent( +- pinstance->pdev, ++ pinstance->ldn.msg = dma_alloc_coherent(&pinstance->pdev->dev, + PMCRAID_AEN_HDR_SIZE + + sizeof(struct pmcraid_hcam_ldn), +- &(pinstance->ldn.baddr)); ++ &pinstance->ldn.baddr, GFP_KERNEL); + + if (pinstance->ldn.msg == NULL || pinstance->ccn.msg == NULL) { + pmcraid_release_hcams(pinstance); +@@ -4874,7 +4870,7 @@ static void pmcraid_release_config_buffe + { + if (pinstance->cfg_table != NULL && + pinstance->cfg_table_bus_addr != 0) { +- pci_free_consistent(pinstance->pdev, ++ dma_free_coherent(&pinstance->pdev->dev, + sizeof(struct pmcraid_config_table), + pinstance->cfg_table, + pinstance->cfg_table_bus_addr); +@@ -4918,10 +4914,10 @@ static int pmcraid_allocate_config_buffe + list_add_tail(&pinstance->res_entries[i].queue, + &pinstance->free_res_q); + +- pinstance->cfg_table = +- pci_alloc_consistent(pinstance->pdev, ++ pinstance->cfg_table = dma_alloc_coherent(&pinstance->pdev->dev, + sizeof(struct pmcraid_config_table), +- &pinstance->cfg_table_bus_addr); ++ &pinstance->cfg_table_bus_addr, ++ GFP_KERNEL); + + if (NULL == pinstance->cfg_table) { + pmcraid_err("couldn't alloc DMA memory for config table\n"); +@@ -4986,7 +4982,7 @@ static void pmcraid_release_buffers(stru + pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq); + + if (pinstance->inq_data != NULL) { +- pci_free_consistent(pinstance->pdev, ++ dma_free_coherent(&pinstance->pdev->dev, + sizeof(struct pmcraid_inquiry_data), + pinstance->inq_data, + pinstance->inq_data_baddr); +@@ -4996,7 +4992,7 @@ static void pmcraid_release_buffers(stru + } + + if (pinstance->timestamp_data != NULL) { +- pci_free_consistent(pinstance->pdev, ++ dma_free_coherent(&pinstance->pdev->dev, + sizeof(struct pmcraid_timestamp_data), + pinstance->timestamp_data, + pinstance->timestamp_data_baddr); +@@ -5013,8 +5009,8 @@ static void pmcraid_release_buffers(stru + * This routine pre-allocates memory based on the type of block as below: + * cmdblocks(PMCRAID_MAX_CMD): kernel memory using kernel's slab_allocator, + * IOARCBs(PMCRAID_MAX_CMD) : DMAable memory, using pci pool allocator +- * config-table entries : DMAable memory using pci_alloc_consistent +- * HostRRQs : DMAable memory, using pci_alloc_consistent ++ * config-table entries : DMAable memory using dma_alloc_coherent ++ * HostRRQs : DMAable memory, using dma_alloc_coherent + * + * Return Value + * 0 in case all of the blocks are allocated, -ENOMEM otherwise. +@@ -5051,11 +5047,9 @@ static int pmcraid_init_buffers(struct p + } + + /* allocate DMAable memory for page D0 INQUIRY buffer */ +- pinstance->inq_data = pci_alloc_consistent( +- pinstance->pdev, ++ pinstance->inq_data = dma_alloc_coherent(&pinstance->pdev->dev, + sizeof(struct pmcraid_inquiry_data), +- &pinstance->inq_data_baddr); +- ++ &pinstance->inq_data_baddr, GFP_KERNEL); + if (pinstance->inq_data == NULL) { + pmcraid_err("couldn't allocate DMA memory for INQUIRY\n"); + pmcraid_release_buffers(pinstance); +@@ -5063,11 +5057,10 @@ static int pmcraid_init_buffers(struct p + } + + /* allocate DMAable memory for set timestamp data buffer */ +- pinstance->timestamp_data = pci_alloc_consistent( +- pinstance->pdev, ++ pinstance->timestamp_data = dma_alloc_coherent(&pinstance->pdev->dev, + sizeof(struct pmcraid_timestamp_data), +- &pinstance->timestamp_data_baddr); +- ++ &pinstance->timestamp_data_baddr, ++ GFP_KERNEL); + if (pinstance->timestamp_data == NULL) { + pmcraid_err("couldn't allocate DMA memory for \ + set time_stamp \n"); +@@ -5356,12 +5349,12 @@ static int pmcraid_resume(struct pci_dev + + pci_set_master(pdev); + +- if ((sizeof(dma_addr_t) == 4) || +- pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) +- rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)); ++ if (sizeof(dma_addr_t) == 4 || ++ dma_set_mask(&pdev->dev, DMA_BIT_MASK(64))) ++ rc = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32)); + + if (rc == 0) +- rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)); ++ rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32)); + + if (rc != 0) { + dev_err(&pdev->dev, "resume: Failed to set PCI DMA mask\n"); +@@ -5765,19 +5758,19 @@ static int pmcraid_probe(struct pci_dev + /* Firmware requires the system bus address of IOARCB to be within + * 32-bit addressable range though it has 64-bit IOARRIN register. + * However, firmware supports 64-bit streaming DMA buffers, whereas +- * coherent buffers are to be 32-bit. Since pci_alloc_consistent always ++ * coherent buffers are to be 32-bit. Since dma_alloc_coherent always + * returns memory within 4GB (if not, change this logic), coherent + * buffers are within firmware acceptable address ranges. + */ +- if ((sizeof(dma_addr_t) == 4) || +- pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) +- rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)); ++ if (sizeof(dma_addr_t) == 4 || ++ dma_set_mask(&pdev->dev, DMA_BIT_MASK(64))) ++ rc = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32)); + + /* firmware expects 32-bit DMA addresses for IOARRIN register; set 32 +- * bit mask for pci_alloc_consistent to return addresses within 4GB ++ * bit mask for dma_alloc_coherent to return addresses within 4GB + */ + if (rc == 0) +- rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)); ++ rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32)); + + if (rc != 0) { + dev_err(&pdev->dev, "Failed to set PCI DMA mask\n"); diff --git a/patches.drivers/scsi-pmcraid-use-sg-helper-to-iterate-over-scatterli.patch b/patches.drivers/scsi-pmcraid-use-sg-helper-to-iterate-over-scatterli.patch new file mode 100644 index 0000000..32480f2 --- /dev/null +++ b/patches.drivers/scsi-pmcraid-use-sg-helper-to-iterate-over-scatterli.patch @@ -0,0 +1,78 @@ +From: Ming Lei +Date: Tue, 18 Jun 2019 09:37:47 +0800 +Subject: scsi: pmcraid: use sg helper to iterate over scatterlist +Patch-mainline: v5.3-rc1 +Git-commit: 74eb7446eda5e348dbb90981e91e9caf54f2fde4 +References: bsc#1135990 jsc#SLE-4709 + +Unlike the legacy I/O path, scsi-mq preallocates a large array to hold +the scatterlist for each request. This static allocation can consume +substantial amounts of memory on modern controllers which support a +large number of concurrently outstanding requests. + +To facilitate a switch to a smaller static allocation combined with a +dynamic allocation for requests that need it, we need to make sure all +SCSI drivers handle chained scatterlists correctly. + +Convert remaining drivers that directly dereference the scatterlist +array to using the iterator functions. + +[mkp: clarified commit message] + +Reviewed-by: Christoph Hellwig +Reviewed-by: Bart Van Assche +Signed-off-by: Ming Lei +Signed-off-by: Martin K. Petersen +Acked-by: Daniel Wagner +--- + drivers/scsi/pmcraid.c | 14 +++++++------- + 1 file changed, 7 insertions(+), 7 deletions(-) + +--- a/drivers/scsi/pmcraid.c ++++ b/drivers/scsi/pmcraid.c +@@ -3312,7 +3312,7 @@ static int pmcraid_copy_sglist( + int direction + ) + { +- struct scatterlist *scatterlist; ++ struct scatterlist *sg; + void *kaddr; + int bsize_elem; + int i; +@@ -3321,10 +3321,10 @@ static int pmcraid_copy_sglist( + /* Determine the actual number of bytes per element */ + bsize_elem = PAGE_SIZE * (1 << sglist->order); + +- scatterlist = sglist->scatterlist; ++ sg = sglist->scatterlist; + +- for (i = 0; i < (len / bsize_elem); i++, buffer += bsize_elem) { +- struct page *page = sg_page(&scatterlist[i]); ++ for (i = 0; i < (len / bsize_elem); i++, sg = sg_next(sg), buffer += bsize_elem) { ++ struct page *page = sg_page(sg); + + kaddr = kmap(page); + if (direction == DMA_TO_DEVICE) +@@ -3339,11 +3339,11 @@ static int pmcraid_copy_sglist( + return -EFAULT; + } + +- scatterlist[i].length = bsize_elem; ++ sg->length = bsize_elem; + } + + if (len % bsize_elem) { +- struct page *page = sg_page(&scatterlist[i]); ++ struct page *page = sg_page(sg); + + kaddr = kmap(page); + +@@ -3354,7 +3354,7 @@ static int pmcraid_copy_sglist( + + kunmap(page); + +- scatterlist[i].length = len % bsize_elem; ++ sg->length = len % bsize_elem; + } + + if (rc) { diff --git a/patches.drm/drm-i915-Fix-wrong-escape-clock-divisor-init-for-GLK.patch b/patches.drm/drm-i915-Fix-wrong-escape-clock-divisor-init-for-GLK.patch new file mode 100644 index 0000000..b9fe49c --- /dev/null +++ b/patches.drm/drm-i915-Fix-wrong-escape-clock-divisor-init-for-GLK.patch @@ -0,0 +1,59 @@ +From 73a0ff0b30af79bf0303d557eb82f1d1945bb6ee Mon Sep 17 00:00:00 2001 +From: Stanislav Lisovskiy +Date: Fri, 12 Jul 2019 11:19:38 +0300 +Subject: [PATCH] drm/i915: Fix wrong escape clock divisor init for GLK +Git-commit: 73a0ff0b30af79bf0303d557eb82f1d1945bb6ee +Patch-mainline: v5.3-rc4 +No-fix: ce52ad5dd52cfaf3398058384e0ff94134bbd89c +References: bsc#1051510 + +According to Bspec clock divisor registers in GeminiLake +should be initialized by shifting 1(<<) to amount of correspondent +divisor. While i915 was writing all this time that value as is. + +Surprisingly that it by accident worked, until we met some issues +with Microtech Etab. + +V2: Added Fixes tag and cc +V3: Added stable to cc as well. + +Signed-off-by: Stanislav Lisovskiy +Reviewed-by: Vandita Kulkarni +Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=108826 +Fixes: bcc657004841 ("drm/i915/glk: Program txesc clock divider for GLK") +Cc: Deepak M +Cc: Madhav Chauhan +Cc: Jani Nikula +Cc: Jani Nikula +Cc: Joonas Lahtinen +Cc: Rodrigo Vivi +Cc: intel-gfx@lists.freedesktop.org +Cc: stable@vger.kernel.org +Signed-off-by: Jani Nikula +Link: https://patchwork.freedesktop.org/patch/msgid/20190712081938.14185-1-stanislav.lisovskiy@intel.com +(cherry picked from commit ce52ad5dd52cfaf3398058384e0ff94134bbd89c) + +Acked-by: Takashi Iwai + +--- + drivers/gpu/drm/i915/display/vlv_dsi_pll.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/drivers/gpu/drm/i915/display/vlv_dsi_pll.c b/drivers/gpu/drm/i915/display/vlv_dsi_pll.c +index 99cc3e2e9c2c..f016a776a39e 100644 +--- a/drivers/gpu/drm/i915/vlv_dsi_pll.c ++++ b/drivers/gpu/drm/i915/vlv_dsi_pll.c +@@ -396,8 +396,8 @@ static void glk_dsi_program_esc_clock(struct drm_device *dev, + else + txesc2_div = 10; + +- I915_WRITE(MIPIO_TXESC_CLK_DIV1, txesc1_div & GLK_TX_ESC_CLK_DIV1_MASK); +- I915_WRITE(MIPIO_TXESC_CLK_DIV2, txesc2_div & GLK_TX_ESC_CLK_DIV2_MASK); ++ I915_WRITE(MIPIO_TXESC_CLK_DIV1, (1 << (txesc1_div - 1)) & GLK_TX_ESC_CLK_DIV1_MASK); ++ I915_WRITE(MIPIO_TXESC_CLK_DIV2, (1 << (txesc2_div - 1)) & GLK_TX_ESC_CLK_DIV2_MASK); + } + + /* Program BXT Mipi clocks and dividers */ +-- +2.16.4 + diff --git a/patches.drm/drm-rockchip-Suspend-DP-late.patch b/patches.drm/drm-rockchip-Suspend-DP-late.patch new file mode 100644 index 0000000..1d86d66 --- /dev/null +++ b/patches.drm/drm-rockchip-Suspend-DP-late.patch @@ -0,0 +1,46 @@ +From f7ccbed656f78212593ca965d9a8f34bf24e0aab Mon Sep 17 00:00:00 2001 +From: Douglas Anderson +Date: Fri, 2 Aug 2019 11:46:16 -0700 +Subject: [PATCH] drm/rockchip: Suspend DP late +Git-commit: f7ccbed656f78212593ca965d9a8f34bf24e0aab +Patch-mainline: v5.3-rc4 +References: bsc#1051510 + +In commit fe64ba5c6323 ("drm/rockchip: Resume DP early") we moved +resume to be early but left suspend at its normal time. This seems +like it could be OK, but casues problems if a suspend gets interrupted +partway through. The OS only balances matching suspend/resume levels. +...so if suspend was called then resume will be called. If suspend +late was called then resume early will be called. ...but if suspend +was called resume early might not get called. This leads to an +unbalance in the clock enables / disables. + +Lets take the simple fix and just move suspend to be late to match. +This makes the PM core take proper care in keeping things balanced. + +Fixes: fe64ba5c6323 ("drm/rockchip: Resume DP early") +Signed-off-by: Douglas Anderson +Signed-off-by: Sean Paul +Link: https://patchwork.freedesktop.org/patch/msgid/20190802184616.44822-1-dianders@chromium.org +Acked-by: Takashi Iwai + +--- + drivers/gpu/drm/rockchip/analogix_dp-rockchip.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/drivers/gpu/drm/rockchip/analogix_dp-rockchip.c b/drivers/gpu/drm/rockchip/analogix_dp-rockchip.c +index 95e5c517a15f..9aae3d8e99ef 100644 +--- a/drivers/gpu/drm/rockchip/analogix_dp-rockchip.c ++++ b/drivers/gpu/drm/rockchip/analogix_dp-rockchip.c +@@ -432,7 +432,7 @@ static int rockchip_dp_resume(struct device *dev) + + static const struct dev_pm_ops rockchip_dp_pm_ops = { + #ifdef CONFIG_PM_SLEEP +- .suspend = rockchip_dp_suspend, ++ .suspend_late = rockchip_dp_suspend, + .resume_early = rockchip_dp_resume, + #endif + }; +-- +2.16.4 + diff --git a/patches.fixes/nl-mac-80211-fix-interface-combinations-on-crypto-co.patch b/patches.fixes/nl-mac-80211-fix-interface-combinations-on-crypto-co.patch new file mode 100644 index 0000000..85d1e30 --- /dev/null +++ b/patches.fixes/nl-mac-80211-fix-interface-combinations-on-crypto-co.patch @@ -0,0 +1,166 @@ +From e6f4051123fd33901e9655a675b22aefcdc5d277 Mon Sep 17 00:00:00 2001 +From: Manikanta Pubbisetty +Date: Mon, 22 Jul 2019 12:44:50 +0530 +Subject: [PATCH] {nl,mac}80211: fix interface combinations on crypto controlled devices +Git-commit: e6f4051123fd33901e9655a675b22aefcdc5d277 +Patch-mainline: v5.3-rc4 +References: bsc#1111666 + +Commit 33d915d9e8ce ("{nl,mac}80211: allow 4addr AP operation on +crypto controlled devices") has introduced a change which allows +4addr operation on crypto controlled devices (ex: ath10k). This +change has inadvertently impacted the interface combinations logic +on such devices. + +General rule is that software interfaces like AP/VLAN should not be +listed under supported interface combinations and should not be +considered during validation of these combinations; because of the +aforementioned change, AP/VLAN interfaces(if present) will be checked +against interfaces supported by the device and blocks valid interface +combinations. + +Consider a case where an AP and AP/VLAN are up and running; when a +second AP device is brought up on the same physical device, this AP +will be checked against the AP/VLAN interface (which will not be +part of supported interface combinations of the device) and blocks +second AP to come up. + +Add a new API cfg80211_iftype_allowed() to fix the problem, this +API works for all devices with/without SW crypto control. + +Signed-off-by: Manikanta Pubbisetty +Fixes: 33d915d9e8ce ("{nl,mac}80211: allow 4addr AP operation on crypto controlled devices") +Link: https://lore.kernel.org/r/1563779690-9716-1-git-send-email-mpubbise@codeaurora.org +Signed-off-by: Johannes Berg +Acked-by: Takashi Iwai + +--- + include/net/cfg80211.h | 15 +++++++++++++++ + net/mac80211/util.c | 7 +++---- + net/wireless/core.c | 6 ++---- + net/wireless/nl80211.c | 4 +--- + net/wireless/util.c | 27 +++++++++++++++++++++++++-- + 5 files changed, 46 insertions(+), 13 deletions(-) + +--- a/include/net/cfg80211.h ++++ b/include/net/cfg80211.h +@@ -6563,6 +6563,21 @@ int cfg80211_external_auth_request(struc + struct cfg80211_external_auth_params *params, + gfp_t gfp); + ++/** ++ * cfg80211_iftype_allowed - check whether the interface can be allowed ++ * @wiphy: the wiphy ++ * @iftype: interface type ++ * @is_4addr: use_4addr flag, must be '0' when check_swif is '1' ++ * @check_swif: check iftype against software interfaces ++ * ++ * Check whether the interface is allowed to operate; additionally, this API ++ * can be used to check iftype against the software interfaces when ++ * check_swif is '1'. ++ */ ++bool cfg80211_iftype_allowed(struct wiphy *wiphy, enum nl80211_iftype iftype, ++ bool is_4addr, u8 check_swif); ++ ++ + /* Logging, debugging and troubleshooting/diagnostic helpers. */ + + /* wiphy_printk helpers, similar to dev_printk */ +--- a/net/mac80211/util.c ++++ b/net/mac80211/util.c +@@ -3526,9 +3526,7 @@ int ieee80211_check_combinations(struct + } + + /* Always allow software iftypes */ +- if (local->hw.wiphy->software_iftypes & BIT(iftype) || +- (iftype == NL80211_IFTYPE_AP_VLAN && +- local->hw.wiphy->flags & WIPHY_FLAG_4ADDR_AP)) { ++ if (cfg80211_iftype_allowed(local->hw.wiphy, iftype, 0, 1)) { + if (radar_detect) + return -EINVAL; + return 0; +@@ -3563,7 +3561,8 @@ int ieee80211_check_combinations(struct + + if (sdata_iter == sdata || + !ieee80211_sdata_running(sdata_iter) || +- local->hw.wiphy->software_iftypes & BIT(wdev_iter->iftype)) ++ cfg80211_iftype_allowed(local->hw.wiphy, ++ wdev_iter->iftype, 0, 1)) + continue; + + params.iftype_num[wdev_iter->iftype]++; +--- a/net/wireless/core.c ++++ b/net/wireless/core.c +@@ -1335,10 +1335,8 @@ static int cfg80211_netdev_notifier_call + } + break; + case NETDEV_PRE_UP: +- if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype)) && +- !(wdev->iftype == NL80211_IFTYPE_AP_VLAN && +- rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP && +- wdev->use_4addr)) ++ if (!cfg80211_iftype_allowed(wdev->wiphy, wdev->iftype, ++ wdev->use_4addr, 0)) + return notifier_from_errno(-EOPNOTSUPP); + + if (rfkill_blocked(rdev->rfkill)) +--- a/net/wireless/nl80211.c ++++ b/net/wireless/nl80211.c +@@ -3210,9 +3210,7 @@ static int nl80211_new_interface(struct + return err; + } + +- if (!(rdev->wiphy.interface_modes & (1 << type)) && +- !(type == NL80211_IFTYPE_AP_VLAN && params.use_4addr && +- rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP)) ++ if (!cfg80211_iftype_allowed(&rdev->wiphy, type, params.use_4addr, 0)) + return -EOPNOTSUPP; + + err = nl80211_parse_mon_options(rdev, type, info, ¶ms); +--- a/net/wireless/util.c ++++ b/net/wireless/util.c +@@ -1669,7 +1669,7 @@ int cfg80211_iter_combinations(struct wi + for (iftype = 0; iftype < NUM_NL80211_IFTYPES; iftype++) { + num_interfaces += params->iftype_num[iftype]; + if (params->iftype_num[iftype] > 0 && +- !(wiphy->software_iftypes & BIT(iftype))) ++ !cfg80211_iftype_allowed(wiphy, iftype, 0, 1)) + used_iftypes |= BIT(iftype); + } + +@@ -1691,7 +1691,7 @@ int cfg80211_iter_combinations(struct wi + return -ENOMEM; + + for (iftype = 0; iftype < NUM_NL80211_IFTYPES; iftype++) { +- if (wiphy->software_iftypes & BIT(iftype)) ++ if (cfg80211_iftype_allowed(wiphy, iftype, 0, 1)) + continue; + for (j = 0; j < c->n_limits; j++) { + all_iftypes |= limits[j].types; +@@ -1894,3 +1894,26 @@ EXPORT_SYMBOL(rfc1042_header); + const unsigned char bridge_tunnel_header[] __aligned(2) = + { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 }; + EXPORT_SYMBOL(bridge_tunnel_header); ++ ++bool cfg80211_iftype_allowed(struct wiphy *wiphy, enum nl80211_iftype iftype, ++ bool is_4addr, u8 check_swif) ++ ++{ ++ bool is_vlan = iftype == NL80211_IFTYPE_AP_VLAN; ++ ++ switch (check_swif) { ++ case 0: ++ if (is_vlan && is_4addr) ++ return wiphy->flags & WIPHY_FLAG_4ADDR_AP; ++ return wiphy->interface_modes & BIT(iftype); ++ case 1: ++ if (!(wiphy->software_iftypes & BIT(iftype)) && is_vlan) ++ return wiphy->flags & WIPHY_FLAG_4ADDR_AP; ++ return wiphy->software_iftypes & BIT(iftype); ++ default: ++ break; ++ } ++ ++ return false; ++} ++EXPORT_SYMBOL(cfg80211_iftype_allowed); diff --git a/patches.fixes/staging-fsl-dpaa2-ethsw-fix-memory-leak-of-switchdev.patch b/patches.fixes/staging-fsl-dpaa2-ethsw-fix-memory-leak-of-switchdev.patch new file mode 100644 index 0000000..6ee5332 --- /dev/null +++ b/patches.fixes/staging-fsl-dpaa2-ethsw-fix-memory-leak-of-switchdev.patch @@ -0,0 +1,37 @@ +From 5555ebbbac822b4fa28db2be15aaf98b3c21af26 Mon Sep 17 00:00:00 2001 +From: Colin Ian King +Date: Sat, 8 Jun 2019 12:50:31 +0100 +Subject: [PATCH] staging: fsl-dpaa2/ethsw: fix memory leak of switchdev_work +Git-commit: 5555ebbbac822b4fa28db2be15aaf98b3c21af26 +Patch-mainline: v5.3-rc1 +References: bsc#1111666 + +In the default event case switchdev_work is being leaked because +nothing is queued for work. Fix this by kfree'ing switchdev_work +before returning NOTIFY_DONE. + +Addresses-coverity: ("Resource leak") +Fixes: 44baaa43d7cc ("staging: fsl-dpaa2/ethsw: Add Freescale DPAA2 Ethernet Switch driver") +Signed-off-by: Colin Ian King +Signed-off-by: Greg Kroah-Hartman +Acked-by: Takashi Iwai + +--- + drivers/staging/fsl-dpaa2/ethsw/ethsw.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/drivers/staging/fsl-dpaa2/ethsw/ethsw.c b/drivers/staging/fsl-dpaa2/ethsw/ethsw.c +index e3c3e427309a..f73edaf6ce87 100644 +--- a/drivers/staging/fsl-dpaa2/ethsw/ethsw.c ++++ b/drivers/staging/fsl-dpaa2/ethsw/ethsw.c +@@ -1086,6 +1086,7 @@ static int port_switchdev_event(struct notifier_block *unused, + dev_hold(dev); + break; + default: ++ kfree(switchdev_work); + return NOTIFY_DONE; + } + +-- +2.16.4 + diff --git a/patches.suse/kvm-s390-add-debug-logging-for-cpu-model-subfunctions b/patches.suse/kvm-s390-add-debug-logging-for-cpu-model-subfunctions new file mode 100644 index 0000000..2f7799a --- /dev/null +++ b/patches.suse/kvm-s390-add-debug-logging-for-cpu-model-subfunctions @@ -0,0 +1,179 @@ +From: Christian Borntraeger +Date: Wed, 20 Feb 2019 11:38:42 -0500 +Subject: KVM: s390: add debug logging for cpu model subfunctions +Git-commit: 11ba5961a2156a4f210627ed8421387e2531b100 +Patch-mainline: v5.1-rc1 +References: jsc#SLE-6240 FATE#327380 + +As userspace can now get/set the subfunctions we want to trace those. +This will allow to also check QEMUs cpu model vs. what the real +hardware provides. + +Signed-off-by: Christian Borntraeger +Reviewed-by: David Hildenbrand +Reviewed-by: Cornelia Huck +Reviewed-by: Janosch Frank +Acked-by: Petr Tesarik +--- + arch/s390/kvm/kvm-s390.c | 136 +++++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 136 insertions(+) + +--- a/arch/s390/kvm/kvm-s390.c ++++ b/arch/s390/kvm/kvm-s390.c +@@ -1267,6 +1267,51 @@ static int kvm_s390_set_processor_subfun + } + mutex_unlock(&kvm->lock); + ++ VM_EVENT(kvm, 3, "SET: guest PLO subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.plo)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.plo)[1], ++ ((unsigned long *) &kvm->arch.model.subfuncs.plo)[2], ++ ((unsigned long *) &kvm->arch.model.subfuncs.plo)[3]); ++ VM_EVENT(kvm, 3, "SET: guest PTFF subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.ptff)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.ptff)[1]); ++ VM_EVENT(kvm, 3, "SET: guest KMAC subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmac)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmac)[1]); ++ VM_EVENT(kvm, 3, "SET: guest KMC subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmc)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmc)[1]); ++ VM_EVENT(kvm, 3, "SET: guest KM subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.km)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.km)[1]); ++ VM_EVENT(kvm, 3, "SET: guest KIMD subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.kimd)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.kimd)[1]); ++ VM_EVENT(kvm, 3, "SET: guest KLMD subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.klmd)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.klmd)[1]); ++ VM_EVENT(kvm, 3, "SET: guest PCKMO subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.pckmo)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.pckmo)[1]); ++ VM_EVENT(kvm, 3, "SET: guest KMCTR subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmctr)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmctr)[1]); ++ VM_EVENT(kvm, 3, "SET: guest KMF subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmf)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmf)[1]); ++ VM_EVENT(kvm, 3, "SET: guest KMO subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmo)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmo)[1]); ++ VM_EVENT(kvm, 3, "SET: guest PCC subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.pcc)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.pcc)[1]); ++ VM_EVENT(kvm, 3, "SET: guest PPNO subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.ppno)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.ppno)[1]); ++ VM_EVENT(kvm, 3, "SET: guest KMA subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.kma)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.kma)[1]); ++ + return 0; + } + +@@ -1382,6 +1427,51 @@ static int kvm_s390_get_processor_subfun + sizeof(struct kvm_s390_vm_cpu_subfunc))) + return -EFAULT; + ++ VM_EVENT(kvm, 3, "GET: guest PLO subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.plo)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.plo)[1], ++ ((unsigned long *) &kvm->arch.model.subfuncs.plo)[2], ++ ((unsigned long *) &kvm->arch.model.subfuncs.plo)[3]); ++ VM_EVENT(kvm, 3, "GET: guest PTFF subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.ptff)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.ptff)[1]); ++ VM_EVENT(kvm, 3, "GET: guest KMAC subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmac)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmac)[1]); ++ VM_EVENT(kvm, 3, "GET: guest KMC subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmc)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmc)[1]); ++ VM_EVENT(kvm, 3, "GET: guest KM subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.km)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.km)[1]); ++ VM_EVENT(kvm, 3, "GET: guest KIMD subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.kimd)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.kimd)[1]); ++ VM_EVENT(kvm, 3, "GET: guest KLMD subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.klmd)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.klmd)[1]); ++ VM_EVENT(kvm, 3, "GET: guest PCKMO subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.pckmo)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.pckmo)[1]); ++ VM_EVENT(kvm, 3, "GET: guest KMCTR subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmctr)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmctr)[1]); ++ VM_EVENT(kvm, 3, "GET: guest KMF subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmf)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmf)[1]); ++ VM_EVENT(kvm, 3, "GET: guest KMO subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmo)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.kmo)[1]); ++ VM_EVENT(kvm, 3, "GET: guest PCC subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.pcc)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.pcc)[1]); ++ VM_EVENT(kvm, 3, "GET: guest PPNO subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.ppno)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.ppno)[1]); ++ VM_EVENT(kvm, 3, "GET: guest KMA subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.kma)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.kma)[1]); ++ + return 0; + } + +@@ -1391,6 +1481,52 @@ static int kvm_s390_get_machine_subfunc( + if (copy_to_user((void __user *)attr->addr, &kvm_s390_available_subfunc, + sizeof(struct kvm_s390_vm_cpu_subfunc))) + return -EFAULT; ++ ++ VM_EVENT(kvm, 3, "GET: host PLO subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm_s390_available_subfunc.plo)[0], ++ ((unsigned long *) &kvm_s390_available_subfunc.plo)[1], ++ ((unsigned long *) &kvm_s390_available_subfunc.plo)[2], ++ ((unsigned long *) &kvm_s390_available_subfunc.plo)[3]); ++ VM_EVENT(kvm, 3, "GET: host PTFF subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm_s390_available_subfunc.ptff)[0], ++ ((unsigned long *) &kvm_s390_available_subfunc.ptff)[1]); ++ VM_EVENT(kvm, 3, "GET: host KMAC subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm_s390_available_subfunc.kmac)[0], ++ ((unsigned long *) &kvm_s390_available_subfunc.kmac)[1]); ++ VM_EVENT(kvm, 3, "GET: host KMC subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm_s390_available_subfunc.kmc)[0], ++ ((unsigned long *) &kvm_s390_available_subfunc.kmc)[1]); ++ VM_EVENT(kvm, 3, "GET: host KM subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm_s390_available_subfunc.km)[0], ++ ((unsigned long *) &kvm_s390_available_subfunc.km)[1]); ++ VM_EVENT(kvm, 3, "GET: host KIMD subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm_s390_available_subfunc.kimd)[0], ++ ((unsigned long *) &kvm_s390_available_subfunc.kimd)[1]); ++ VM_EVENT(kvm, 3, "GET: host KLMD subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm_s390_available_subfunc.klmd)[0], ++ ((unsigned long *) &kvm_s390_available_subfunc.klmd)[1]); ++ VM_EVENT(kvm, 3, "GET: host PCKMO subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm_s390_available_subfunc.pckmo)[0], ++ ((unsigned long *) &kvm_s390_available_subfunc.pckmo)[1]); ++ VM_EVENT(kvm, 3, "GET: host KMCTR subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm_s390_available_subfunc.kmctr)[0], ++ ((unsigned long *) &kvm_s390_available_subfunc.kmctr)[1]); ++ VM_EVENT(kvm, 3, "GET: host KMF subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm_s390_available_subfunc.kmf)[0], ++ ((unsigned long *) &kvm_s390_available_subfunc.kmf)[1]); ++ VM_EVENT(kvm, 3, "GET: host KMO subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm_s390_available_subfunc.kmo)[0], ++ ((unsigned long *) &kvm_s390_available_subfunc.kmo)[1]); ++ VM_EVENT(kvm, 3, "GET: host PCC subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm_s390_available_subfunc.pcc)[0], ++ ((unsigned long *) &kvm_s390_available_subfunc.pcc)[1]); ++ VM_EVENT(kvm, 3, "GET: host PPNO subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm_s390_available_subfunc.ppno)[0], ++ ((unsigned long *) &kvm_s390_available_subfunc.ppno)[1]); ++ VM_EVENT(kvm, 3, "GET: host KMA subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm_s390_available_subfunc.kma)[0], ++ ((unsigned long *) &kvm_s390_available_subfunc.kma)[1]); ++ + return 0; + } + diff --git a/patches.suse/kvm-s390-add-deflate-conversion-facilty-to-cpu-model b/patches.suse/kvm-s390-add-deflate-conversion-facilty-to-cpu-model new file mode 100644 index 0000000..5eceaa6 --- /dev/null +++ b/patches.suse/kvm-s390-add-deflate-conversion-facilty-to-cpu-model @@ -0,0 +1,103 @@ +From: Christian Borntraeger +Date: Fri, 28 Dec 2018 10:46:04 +0100 +Subject: KVM: s390: add deflate conversion facilty to cpu model +Git-commit: 4f45b90e1c03466202fca7f62eaf32243f220830 +Patch-mainline: v5.2-rc1 +References: jsc#SLE-6240 FATE#327380 + +This enables stfle.151 and adds the subfunctions for DFLTCC. Bit 151 is +added to the list of facilities that will be enabled when there is no +cpu model involved as DFLTCC requires no additional handling from +userspace, e.g. for migration. + +Please note that a cpu model enabled user space can and will have the +final decision on the facility bits for a guests. + +Signed-off-by: Christian Borntraeger +Reviewed-by: Collin Walling +Reviewed-by: David Hildenbrand +Acked-by: Petr Tesarik +--- + arch/s390/include/uapi/asm/kvm.h | 3 ++- + arch/s390/kvm/kvm-s390.c | 19 +++++++++++++++++++ + arch/s390/tools/gen_facilities.c | 1 + + 3 files changed, 22 insertions(+), 1 deletion(-) + +--- a/arch/s390/include/uapi/asm/kvm.h ++++ b/arch/s390/include/uapi/asm/kvm.h +@@ -157,7 +157,8 @@ struct kvm_s390_vm_cpu_subfunc { + __u8 kma[16]; /* with MSA8 */ + __u8 kdsa[16]; /* with MSA9 */ + __u8 sortl[32]; /* with STFLE.150 */ +- __u8 reserved[1760]; ++ __u8 dfltcc[32]; /* with STFLE.151 */ ++ __u8 reserved[1728]; + }; + + /* kvm attributes for crypto */ +--- a/arch/s390/kvm/kvm-s390.c ++++ b/arch/s390/kvm/kvm-s390.c +@@ -316,6 +316,7 @@ static inline void __insn32_query(unsign + } + + #define INSN_SORTL 0xb938 ++#define INSN_DFLTCC 0xb939 + + static void kvm_s390_cpu_feat_init(void) + { +@@ -371,6 +372,9 @@ static void kvm_s390_cpu_feat_init(void) + if (test_facility(150)) /* SORTL */ + __insn32_query(INSN_SORTL, kvm_s390_available_subfunc.sortl); + ++ if (test_facility(151)) /* DFLTCC */ ++ __insn32_query(INSN_DFLTCC, kvm_s390_available_subfunc.dfltcc); ++ + if (MACHINE_HAS_ESOP) + allow_cpu_feat(KVM_S390_VM_CPU_FEAT_ESOP); + /* +@@ -1349,6 +1353,11 @@ static int kvm_s390_set_processor_subfun + ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[1], + ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[2], + ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[3]); ++ VM_EVENT(kvm, 3, "SET: guest DFLTCC subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[1], ++ ((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[2], ++ ((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[3]); + + return 0; + } +@@ -1517,6 +1526,11 @@ static int kvm_s390_get_processor_subfun + ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[1], + ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[2], + ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[3]); ++ VM_EVENT(kvm, 3, "GET: guest DFLTCC subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[1], ++ ((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[2], ++ ((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[3]); + + return 0; + } +@@ -1580,6 +1594,11 @@ static int kvm_s390_get_machine_subfunc( + ((unsigned long *) &kvm_s390_available_subfunc.sortl)[1], + ((unsigned long *) &kvm_s390_available_subfunc.sortl)[2], + ((unsigned long *) &kvm_s390_available_subfunc.sortl)[3]); ++ VM_EVENT(kvm, 3, "GET: host DFLTCC subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm_s390_available_subfunc.dfltcc)[0], ++ ((unsigned long *) &kvm_s390_available_subfunc.dfltcc)[1], ++ ((unsigned long *) &kvm_s390_available_subfunc.dfltcc)[2], ++ ((unsigned long *) &kvm_s390_available_subfunc.dfltcc)[3]); + + return 0; + } +--- a/arch/s390/tools/gen_facilities.c ++++ b/arch/s390/tools/gen_facilities.c +@@ -95,6 +95,7 @@ static struct facility_def facility_defs + 139, /* multiple epoch facility */ + 146, /* msa extension 8 */ + 150, /* enhanced sort */ ++ 151, /* deflate conversion */ + 155, /* msa extension 9 */ + -1 /* END */ + } diff --git a/patches.suse/kvm-s390-add-enhanced-sort-facilty-to-cpu-model b/patches.suse/kvm-s390-add-enhanced-sort-facilty-to-cpu-model new file mode 100644 index 0000000..2de9154 --- /dev/null +++ b/patches.suse/kvm-s390-add-enhanced-sort-facilty-to-cpu-model @@ -0,0 +1,104 @@ +From: Christian Borntraeger +Date: Fri, 28 Dec 2018 10:59:06 +0100 +Subject: KVM: s390: add enhanced sort facilty to cpu model +Git-commit: 173aec2d5a9fa5f40e462661a8283fcafe04764f +Patch-mainline: v5.2-rc1 +References: jsc#SLE-6240 FATE#327380 + +This enables stfle.150 and adds the subfunctions for SORTL. Bit 150 is +added to the list of facilities that will be enabled when there is no +cpu model involved as sortl requires no additional handling from +userspace, e.g. for migration. + +Please note that a cpu model enabled user space can and will have the +final decision on the facility bits for a guests. + +Signed-off-by: Christian Borntraeger +Reviewed-by: Collin Walling +Reviewed-by: David Hildenbrand +Acked-by: Petr Tesarik +--- + arch/s390/include/uapi/asm/kvm.h | 3 ++- + arch/s390/kvm/kvm-s390.c | 20 ++++++++++++++++++++ + arch/s390/tools/gen_facilities.c | 1 + + 3 files changed, 23 insertions(+), 1 deletion(-) + +--- a/arch/s390/include/uapi/asm/kvm.h ++++ b/arch/s390/include/uapi/asm/kvm.h +@@ -156,7 +156,8 @@ struct kvm_s390_vm_cpu_subfunc { + __u8 ppno[16]; /* with MSA5 */ + __u8 kma[16]; /* with MSA8 */ + __u8 kdsa[16]; /* with MSA9 */ +- __u8 reserved[1792]; ++ __u8 sortl[32]; /* with STFLE.150 */ ++ __u8 reserved[1760]; + }; + + /* kvm attributes for crypto */ +--- a/arch/s390/kvm/kvm-s390.c ++++ b/arch/s390/kvm/kvm-s390.c +@@ -315,6 +315,8 @@ static inline void __insn32_query(unsign + : "cc"); + } + ++#define INSN_SORTL 0xb938 ++ + static void kvm_s390_cpu_feat_init(void) + { + int i; +@@ -366,6 +368,9 @@ static void kvm_s390_cpu_feat_init(void) + __cpacf_query(CPACF_KDSA, (cpacf_mask_t *) + kvm_s390_available_subfunc.kdsa); + ++ if (test_facility(150)) /* SORTL */ ++ __insn32_query(INSN_SORTL, kvm_s390_available_subfunc.sortl); ++ + if (MACHINE_HAS_ESOP) + allow_cpu_feat(KVM_S390_VM_CPU_FEAT_ESOP); + /* +@@ -1339,6 +1344,11 @@ static int kvm_s390_set_processor_subfun + VM_EVENT(kvm, 3, "SET: guest KDSA subfunc 0x%16.16lx.%16.16lx", + ((unsigned long *) &kvm->arch.model.subfuncs.kdsa)[0], + ((unsigned long *) &kvm->arch.model.subfuncs.kdsa)[1]); ++ VM_EVENT(kvm, 3, "SET: guest SORTL subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[1], ++ ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[2], ++ ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[3]); + + return 0; + } +@@ -1502,6 +1512,11 @@ static int kvm_s390_get_processor_subfun + VM_EVENT(kvm, 3, "GET: guest KDSA subfunc 0x%16.16lx.%16.16lx", + ((unsigned long *) &kvm->arch.model.subfuncs.kdsa)[0], + ((unsigned long *) &kvm->arch.model.subfuncs.kdsa)[1]); ++ VM_EVENT(kvm, 3, "GET: guest SORTL subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[1], ++ ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[2], ++ ((unsigned long *) &kvm->arch.model.subfuncs.sortl)[3]); + + return 0; + } +@@ -1560,6 +1575,11 @@ static int kvm_s390_get_machine_subfunc( + VM_EVENT(kvm, 3, "GET: host KDSA subfunc 0x%16.16lx.%16.16lx", + ((unsigned long *) &kvm_s390_available_subfunc.kdsa)[0], + ((unsigned long *) &kvm_s390_available_subfunc.kdsa)[1]); ++ VM_EVENT(kvm, 3, "GET: host SORTL subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm_s390_available_subfunc.sortl)[0], ++ ((unsigned long *) &kvm_s390_available_subfunc.sortl)[1], ++ ((unsigned long *) &kvm_s390_available_subfunc.sortl)[2], ++ ((unsigned long *) &kvm_s390_available_subfunc.sortl)[3]); + + return 0; + } +--- a/arch/s390/tools/gen_facilities.c ++++ b/arch/s390/tools/gen_facilities.c +@@ -94,6 +94,7 @@ static struct facility_def facility_defs + 131, /* enhanced-SOP 2 and side-effect */ + 139, /* multiple epoch facility */ + 146, /* msa extension 8 */ ++ 150, /* enhanced sort */ + 155, /* msa extension 9 */ + -1 /* END */ + } diff --git a/patches.suse/kvm-s390-add-msa9-to-cpumodel b/patches.suse/kvm-s390-add-msa9-to-cpumodel new file mode 100644 index 0000000..b52d54c --- /dev/null +++ b/patches.suse/kvm-s390-add-msa9-to-cpumodel @@ -0,0 +1,128 @@ +From: Christian Borntraeger +Date: Fri, 28 Dec 2018 09:33:35 +0100 +Subject: KVM: s390: add MSA9 to cpumodel +Git-commit: 13209ad0395c4de7fa48108b1dac72e341d5c089 +Patch-mainline: v5.2-rc1 +References: jsc#SLE-6240 FATE#327380 + +This enables stfle.155 and adds the subfunctions for KDSA. Bit 155 is +added to the list of facilities that will be enabled when there is no +cpu model involved as MSA9 requires no additional handling from +userspace, e.g. for migration. + +Please note that a cpu model enabled user space can and will have the +final decision on the facility bits for a guests. + +Signed-off-by: Christian Borntraeger +Acked-by: Janosch Frank +Reviewed-by: Collin Walling +Reviewed-by: David Hildenbrand +Acked-by: Petr Tesarik +--- + Documentation/virtual/kvm/devices/vm.txt | 3 ++- + arch/s390/include/asm/cpacf.h | 1 + + arch/s390/include/uapi/asm/kvm.h | 3 ++- + arch/s390/kvm/kvm-s390.c | 13 +++++++++++++ + arch/s390/tools/gen_facilities.c | 1 + + tools/arch/s390/include/uapi/asm/kvm.h | 3 ++- + 6 files changed, 21 insertions(+), 3 deletions(-) + +--- a/Documentation/virtual/kvm/devices/vm.txt ++++ b/Documentation/virtual/kvm/devices/vm.txt +@@ -141,7 +141,8 @@ struct kvm_s390_vm_cpu_subfunc { + u8 pcc[16]; # valid with Message-Security-Assist-Extension 4 + u8 ppno[16]; # valid with Message-Security-Assist-Extension 5 + u8 kma[16]; # valid with Message-Security-Assist-Extension 8 +- u8 reserved[1808]; # reserved for future instructions ++ u8 kdsa[16]; # valid with Message-Security-Assist-Extension 9 ++ u8 reserved[1792]; # reserved for future instructions + }; + + Parameters: address of a buffer to load the subfunction blocks from. +--- a/arch/s390/include/asm/cpacf.h ++++ b/arch/s390/include/asm/cpacf.h +@@ -27,6 +27,7 @@ + #define CPACF_KMCTR 0xb92d /* MSA4 */ + #define CPACF_PRNO 0xb93c /* MSA5 */ + #define CPACF_KMA 0xb929 /* MSA8 */ ++#define CPACF_KDSA 0xb93a /* MSA9 */ + + /* + * En/decryption modifier bits +--- a/arch/s390/include/uapi/asm/kvm.h ++++ b/arch/s390/include/uapi/asm/kvm.h +@@ -155,7 +155,8 @@ struct kvm_s390_vm_cpu_subfunc { + __u8 pcc[16]; /* with MSA4 */ + __u8 ppno[16]; /* with MSA5 */ + __u8 kma[16]; /* with MSA8 */ +- __u8 reserved[1808]; ++ __u8 kdsa[16]; /* with MSA9 */ ++ __u8 reserved[1792]; + }; + + /* kvm attributes for crypto */ +--- a/arch/s390/kvm/kvm-s390.c ++++ b/arch/s390/kvm/kvm-s390.c +@@ -349,6 +349,10 @@ static void kvm_s390_cpu_feat_init(void) + __cpacf_query(CPACF_KMA, (cpacf_mask_t *) + kvm_s390_available_subfunc.kma); + ++ if (test_facility(155)) /* MSA9 */ ++ __cpacf_query(CPACF_KDSA, (cpacf_mask_t *) ++ kvm_s390_available_subfunc.kdsa); ++ + if (MACHINE_HAS_ESOP) + allow_cpu_feat(KVM_S390_VM_CPU_FEAT_ESOP); + /* +@@ -1319,6 +1323,9 @@ static int kvm_s390_set_processor_subfun + VM_EVENT(kvm, 3, "SET: guest KMA subfunc 0x%16.16lx.%16.16lx", + ((unsigned long *) &kvm->arch.model.subfuncs.kma)[0], + ((unsigned long *) &kvm->arch.model.subfuncs.kma)[1]); ++ VM_EVENT(kvm, 3, "SET: guest KDSA subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.kdsa)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.kdsa)[1]); + + return 0; + } +@@ -1479,6 +1486,9 @@ static int kvm_s390_get_processor_subfun + VM_EVENT(kvm, 3, "GET: guest KMA subfunc 0x%16.16lx.%16.16lx", + ((unsigned long *) &kvm->arch.model.subfuncs.kma)[0], + ((unsigned long *) &kvm->arch.model.subfuncs.kma)[1]); ++ VM_EVENT(kvm, 3, "GET: guest KDSA subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm->arch.model.subfuncs.kdsa)[0], ++ ((unsigned long *) &kvm->arch.model.subfuncs.kdsa)[1]); + + return 0; + } +@@ -1534,6 +1544,9 @@ static int kvm_s390_get_machine_subfunc( + VM_EVENT(kvm, 3, "GET: host KMA subfunc 0x%16.16lx.%16.16lx", + ((unsigned long *) &kvm_s390_available_subfunc.kma)[0], + ((unsigned long *) &kvm_s390_available_subfunc.kma)[1]); ++ VM_EVENT(kvm, 3, "GET: host KDSA subfunc 0x%16.16lx.%16.16lx", ++ ((unsigned long *) &kvm_s390_available_subfunc.kdsa)[0], ++ ((unsigned long *) &kvm_s390_available_subfunc.kdsa)[1]); + + return 0; + } +--- a/arch/s390/tools/gen_facilities.c ++++ b/arch/s390/tools/gen_facilities.c +@@ -94,6 +94,7 @@ static struct facility_def facility_defs + 131, /* enhanced-SOP 2 and side-effect */ + 139, /* multiple epoch facility */ + 146, /* msa extension 8 */ ++ 155, /* msa extension 9 */ + -1 /* END */ + } + }, +--- a/tools/arch/s390/include/uapi/asm/kvm.h ++++ b/tools/arch/s390/include/uapi/asm/kvm.h +@@ -148,7 +148,8 @@ struct kvm_s390_vm_cpu_subfunc { + __u8 pcc[16]; /* with MSA4 */ + __u8 ppno[16]; /* with MSA5 */ + __u8 kma[16]; /* with MSA8 */ +- __u8 reserved[1808]; ++ __u8 kdsa[16]; /* with MSA9 */ ++ __u8 reserved[1792]; + }; + + /* kvm attributes for crypto */ diff --git a/patches.suse/kvm-s390-add-vector-bcd-enhancements-facility-to-cpumodel b/patches.suse/kvm-s390-add-vector-bcd-enhancements-facility-to-cpumodel new file mode 100644 index 0000000..7349102 --- /dev/null +++ b/patches.suse/kvm-s390-add-vector-bcd-enhancements-facility-to-cpumodel @@ -0,0 +1,37 @@ +From: Christian Borntraeger +Date: Fri, 28 Dec 2018 09:45:58 +0100 +Subject: KVM: s390: add vector BCD enhancements facility to cpumodel +Git-commit: d5cb6ab1e3d4d7e0648a167f6290e89f6e86964e +Patch-mainline: v5.2-rc1 +References: jsc#SLE-6240 FATE#327380 + +If vector support is enabled, the vector BCD enhancements facility +might also be enabled. +We can directly forward this facility to the guest if available +and VX is requested by user space. + +Please note that user space can and will have the final decision +on the facility bits for a guests. + +Signed-off-by: Christian Borntraeger +Reviewed-by: Janosch Frank +Reviewed-by: Collin Walling +Reviewed-by: David Hildenbrand +Acked-by: Petr Tesarik +--- + arch/s390/kvm/kvm-s390.c | 4 ++++ + 1 file changed, 4 insertions(+) + +--- a/arch/s390/kvm/kvm-s390.c ++++ b/arch/s390/kvm/kvm-s390.c +@@ -624,6 +624,10 @@ static int kvm_vm_ioctl_enable_cap(struc + set_kvm_facility(kvm->arch.model.fac_mask, 148); + set_kvm_facility(kvm->arch.model.fac_list, 148); + } ++ if (test_facility(152)) { ++ set_kvm_facility(kvm->arch.model.fac_mask, 152); ++ set_kvm_facility(kvm->arch.model.fac_list, 152); ++ } + r = 0; + } else + r = -EINVAL; diff --git a/patches.suse/kvm-s390-add-vector-enhancements-facility-2-to-cpumodel b/patches.suse/kvm-s390-add-vector-enhancements-facility-2-to-cpumodel new file mode 100644 index 0000000..fc64b8f --- /dev/null +++ b/patches.suse/kvm-s390-add-vector-enhancements-facility-2-to-cpumodel @@ -0,0 +1,37 @@ +From: Christian Borntraeger +Date: Fri, 28 Dec 2018 09:43:37 +0100 +Subject: KVM: s390: add vector enhancements facility 2 to cpumodel +Git-commit: 7832e91cd33f21f3cf82b003478c292915a1ec14 +Patch-mainline: v5.2-rc1 +References: jsc#SLE-6240 FATE#327380 + +If vector support is enabled, the vector enhancements facility 2 +might also be enabled. +We can directly forward this facility to the guest if available +and VX is requested by user space. + +Please note that user space can and will have the final decision +on the facility bits for a guests. + +Signed-off-by: Christian Borntraeger +Reviewed-by: Janosch Frank +Reviewed-by: Collin Walling +Reviewed-by: David Hildenbrand +Acked-by: Petr Tesarik +--- + arch/s390/kvm/kvm-s390.c | 4 ++++ + 1 file changed, 4 insertions(+) + +--- a/arch/s390/kvm/kvm-s390.c ++++ b/arch/s390/kvm/kvm-s390.c +@@ -620,6 +620,10 @@ static int kvm_vm_ioctl_enable_cap(struc + set_kvm_facility(kvm->arch.model.fac_mask, 135); + set_kvm_facility(kvm->arch.model.fac_list, 135); + } ++ if (test_facility(148)) { ++ set_kvm_facility(kvm->arch.model.fac_mask, 148); ++ set_kvm_facility(kvm->arch.model.fac_list, 148); ++ } + r = 0; + } else + r = -EINVAL; diff --git a/patches.suse/kvm-s390-enable-msa9-keywrapping-functions-depending-on-cpu-model b/patches.suse/kvm-s390-enable-msa9-keywrapping-functions-depending-on-cpu-model new file mode 100644 index 0000000..b56d38f --- /dev/null +++ b/patches.suse/kvm-s390-enable-msa9-keywrapping-functions-depending-on-cpu-model @@ -0,0 +1,108 @@ +From: Christian Borntraeger +Date: Wed, 3 Apr 2019 03:00:35 -0400 +Subject: KVM: s390: enable MSA9 keywrapping functions depending on cpu model +Git-commit: 8ec2fa52eac53bff7ef1cedbc4ad8af650ec937c +Patch-mainline: v5.2-rc1 +References: jsc#SLE-6240 FATE#327380 + +Instead of adding a new machine option to disable/enable the keywrapping +options of pckmo (like for AES and DEA) we can now use the CPU model to +decide. As ECC is also wrapped with the AES key we need that to be +enabled. + +Signed-off-by: Christian Borntraeger +Reviewed-by: David Hildenbrand +Acked-by: Petr Tesarik +--- + arch/s390/include/asm/kvm_host.h | 1 + + arch/s390/kvm/kvm-s390.c | 27 ++++++++++++++++++++++++++- + arch/s390/kvm/vsie.c | 5 ++++- + 3 files changed, 31 insertions(+), 2 deletions(-) + +--- a/arch/s390/include/asm/kvm_host.h ++++ b/arch/s390/include/asm/kvm_host.h +@@ -274,6 +274,7 @@ struct kvm_s390_sie_block { + #define ECD_HOSTREGMGMT 0x20000000 + #define ECD_MEF 0x08000000 + #define ECD_ETOKENF 0x02000000 ++#define ECD_ECC 0x00200000 + __u32 ecd; /* 0x01c8 */ + __u8 reserved1cc[18]; /* 0x01cc */ + __u64 pp; /* 0x01de */ +--- a/arch/s390/kvm/kvm-s390.c ++++ b/arch/s390/kvm/kvm-s390.c +@@ -2754,6 +2754,25 @@ void kvm_arch_vcpu_postcreate(struct kvm + vcpu->arch.enabled_gmap = vcpu->arch.gmap; + } + ++static bool kvm_has_pckmo_subfunc(struct kvm *kvm, unsigned long nr) ++{ ++ if (test_bit_inv(nr, (unsigned long *)&kvm->arch.model.subfuncs.pckmo) && ++ test_bit_inv(nr, (unsigned long *)&kvm_s390_available_subfunc.pckmo)) ++ return true; ++ return false; ++} ++ ++static bool kvm_has_pckmo_ecc(struct kvm *kvm) ++{ ++ /* At least one ECC subfunction must be present */ ++ return kvm_has_pckmo_subfunc(kvm, 32) || ++ kvm_has_pckmo_subfunc(kvm, 33) || ++ kvm_has_pckmo_subfunc(kvm, 34) || ++ kvm_has_pckmo_subfunc(kvm, 40) || ++ kvm_has_pckmo_subfunc(kvm, 41); ++ ++} ++ + static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu) + { + /* +@@ -2766,13 +2785,19 @@ static void kvm_s390_vcpu_crypto_setup(s + vcpu->arch.sie_block->crycbd = vcpu->kvm->arch.crypto.crycbd; + vcpu->arch.sie_block->ecb3 &= ~(ECB3_AES | ECB3_DEA); + vcpu->arch.sie_block->eca &= ~ECA_APIE; ++ vcpu->arch.sie_block->ecd &= ~ECD_ECC; + + if (vcpu->kvm->arch.crypto.apie) + vcpu->arch.sie_block->eca |= ECA_APIE; + + /* Set up protected key support */ +- if (vcpu->kvm->arch.crypto.aes_kw) ++ if (vcpu->kvm->arch.crypto.aes_kw) { + vcpu->arch.sie_block->ecb3 |= ECB3_AES; ++ /* ecc is also wrapped with AES key */ ++ if (kvm_has_pckmo_ecc(vcpu->kvm)) ++ vcpu->arch.sie_block->ecd |= ECD_ECC; ++ } ++ + if (vcpu->kvm->arch.crypto.dea_kw) + vcpu->arch.sie_block->ecb3 |= ECB3_DEA; + } +--- a/arch/s390/kvm/vsie.c ++++ b/arch/s390/kvm/vsie.c +@@ -282,6 +282,7 @@ static int shadow_crycb(struct kvm_vcpu + const u32 crycb_addr = crycbd_o & 0x7ffffff8U; + unsigned long *b1, *b2; + u8 ecb3_flags; ++ u32 ecd_flags; + int apie_h; + int key_msk = test_kvm_facility(vcpu->kvm, 76); + int fmt_o = crycbd_o & CRYCB_FORMAT_MASK; +@@ -314,7 +315,8 @@ static int shadow_crycb(struct kvm_vcpu + /* we may only allow it if enabled for guest 2 */ + ecb3_flags = scb_o->ecb3 & vcpu->arch.sie_block->ecb3 & + (ECB3_AES | ECB3_DEA); +- if (!ecb3_flags) ++ ecd_flags = scb_o->ecd & vcpu->arch.sie_block->ecd & ECD_ECC; ++ if (!ecb3_flags && !ecd_flags) + goto end; + + /* copy only the wrapping keys */ +@@ -323,6 +325,7 @@ static int shadow_crycb(struct kvm_vcpu + return set_validity_icpt(scb_s, 0x0035U); + + scb_s->ecb3 |= ecb3_flags; ++ scb_s->ecd |= ecd_flags; + + /* xor both blocks in one run */ + b1 = (unsigned long *) vsie_page->crycb.dea_wrapping_key_mask; diff --git a/patches.suse/kvm-s390-implement-subfunction-processor-calls b/patches.suse/kvm-s390-implement-subfunction-processor-calls new file mode 100644 index 0000000..5c56388 --- /dev/null +++ b/patches.suse/kvm-s390-implement-subfunction-processor-calls @@ -0,0 +1,107 @@ +From: Christian Borntraeger +Date: Mon, 18 Feb 2019 07:48:25 -0500 +Subject: KVM: s390: implement subfunction processor calls +Git-commit: 346fa2f891c71a9b98014f8f62c15f4c7dd95ec1 +Patch-mainline: v5.1-rc1 +References: jsc#SLE-6240 FATE#327380 + +While we will not implement interception for query functions yet, we can +and should disable functions that have a control bit based on the given +CPU model. + +Let us start with enabling the subfunction interface. + +Signed-off-by: Christian Borntraeger +Reviewed-by: David Hildenbrand +Reviewed-by: Janosch Frank +Reviewed-by: Cornelia Huck +Acked-by: Petr Tesarik +--- + arch/s390/include/asm/kvm_host.h | 1 + + arch/s390/kvm/kvm-s390.c | 35 ++++++++++++++++++++++------------- + 2 files changed, 23 insertions(+), 13 deletions(-) + +--- a/arch/s390/include/asm/kvm_host.h ++++ b/arch/s390/include/asm/kvm_host.h +@@ -691,6 +691,7 @@ struct s390_io_adapter { + struct kvm_s390_cpu_model { + /* facility mask supported by kvm & hosting machine */ + __u64 fac_mask[S390_ARCH_FAC_LIST_SIZE_U64]; ++ struct kvm_s390_vm_cpu_subfunc subfuncs; + /* facility list requested by guest (in dma page) */ + __u64 *fac_list; + u64 cpuid; +--- a/arch/s390/kvm/kvm-s390.c ++++ b/arch/s390/kvm/kvm-s390.c +@@ -1254,11 +1254,20 @@ static int kvm_s390_set_processor_feat(s + static int kvm_s390_set_processor_subfunc(struct kvm *kvm, + struct kvm_device_attr *attr) + { +- /* +- * Once supported by kernel + hw, we have to store the subfunctions +- * in kvm->arch and remember that user space configured them. +- */ +- return -ENXIO; ++ mutex_lock(&kvm->lock); ++ if (kvm->created_vcpus) { ++ mutex_unlock(&kvm->lock); ++ return -EBUSY; ++ } ++ ++ if (copy_from_user(&kvm->arch.model.subfuncs, (void __user *)attr->addr, ++ sizeof(struct kvm_s390_vm_cpu_subfunc))) { ++ mutex_unlock(&kvm->lock); ++ return -EFAULT; ++ } ++ mutex_unlock(&kvm->lock); ++ ++ return 0; + } + + static int kvm_s390_set_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) +@@ -1369,12 +1378,11 @@ static int kvm_s390_get_machine_feat(str + static int kvm_s390_get_processor_subfunc(struct kvm *kvm, + struct kvm_device_attr *attr) + { +- /* +- * Once we can actually configure subfunctions (kernel + hw support), +- * we have to check if they were already set by user space, if so copy +- * them from kvm->arch. +- */ +- return -ENXIO; ++ if (copy_to_user((void __user *)attr->addr, &kvm->arch.model.subfuncs, ++ sizeof(struct kvm_s390_vm_cpu_subfunc))) ++ return -EFAULT; ++ ++ return 0; + } + + static int kvm_s390_get_machine_subfunc(struct kvm *kvm, +@@ -1385,6 +1393,7 @@ static int kvm_s390_get_machine_subfunc( + return -EFAULT; + return 0; + } ++ + static int kvm_s390_get_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr) + { + int ret = -ENXIO; +@@ -1502,10 +1511,9 @@ static int kvm_s390_vm_has_attr(struct k + case KVM_S390_VM_CPU_PROCESSOR_FEAT: + case KVM_S390_VM_CPU_MACHINE_FEAT: + case KVM_S390_VM_CPU_MACHINE_SUBFUNC: ++ case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: + ret = 0; + break; +- /* configuring subfunctions is not supported yet */ +- case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC: + default: + ret = -ENXIO; + break; +@@ -2087,6 +2095,7 @@ int kvm_arch_init_vm(struct kvm *kvm, un + kvm->arch.model.fac_list[i] = S390_lowcore.stfle_fac_list[i] & + kvm_s390_fac_base[i]; + } ++ kvm->arch.model.subfuncs = kvm_s390_available_subfunc; + + /* we are always in czam mode - even on pre z14 machines */ + set_kvm_facility(kvm->arch.model.fac_mask, 138); diff --git a/patches.suse/kvm-s390-provide-query-function-for-instructions-returning-32-byte b/patches.suse/kvm-s390-provide-query-function-for-instructions-returning-32-byte new file mode 100644 index 0000000..5663329 --- /dev/null +++ b/patches.suse/kvm-s390-provide-query-function-for-instructions-returning-32-byte @@ -0,0 +1,42 @@ +From: Christian Borntraeger +Date: Wed, 20 Feb 2019 03:04:07 -0500 +Subject: KVM: s390: provide query function for instructions returning 32 byte +Git-commit: d668139718a9e2260702777bd8d86d71c30b6539 +Patch-mainline: v5.2-rc1 +References: jsc#SLE-6240 FATE#327380 + +Some of the new features have a 32byte response for the query function. +Provide a new wrapper similar to __cpacf_query. We might want to factor +this out if other users come up, as of today there is none. So let us +keep the function within KVM. + +Signed-off-by: Christian Borntraeger +Reviewed-by: Collin Walling +Reviewed-by: David Hildenbrand +Acked-by: Petr Tesarik +--- + arch/s390/kvm/kvm-s390.c | 13 +++++++++++++ + 1 file changed, 13 insertions(+) + +--- a/arch/s390/kvm/kvm-s390.c ++++ b/arch/s390/kvm/kvm-s390.c +@@ -302,6 +302,19 @@ static inline int plo_test_bit(unsigned + return cc == 0; + } + ++static inline void __insn32_query(unsigned int opcode, u8 query[32]) ++{ ++ register unsigned long r0 asm("0") = 0; /* query function */ ++ register unsigned long r1 asm("1") = (unsigned long) query; ++ ++ asm volatile( ++ /* Parameter regs are ignored */ ++ " .insn rrf,%[opc] << 16,2,4,6,0\n" ++ : "=m" (*query) ++ : "d" (r0), "a" (r1), [opc] "i" (opcode) ++ : "cc"); ++} ++ + static void kvm_s390_cpu_feat_init(void) + { + int i; diff --git a/patches.suse/s390-cpum_cf-add-support-for-cpu-mf-svn-6 b/patches.suse/s390-cpum_cf-add-support-for-cpu-mf-svn-6 index 2120ccf..aa58c57 100644 --- a/patches.suse/s390-cpum_cf-add-support-for-cpu-mf-svn-6 +++ b/patches.suse/s390-cpum_cf-add-support-for-cpu-mf-svn-6 @@ -15,9 +15,9 @@ Reviewed-by: Hendrik Brueckner Signed-off-by: Martin Schwidefsky Acked-by: Petr Tesarik --- - arch/s390/kernel/perf_cpum_cf.c | 4 - + arch/s390/kernel/perf_cpum_cf.c | 15 +++- arch/s390/kernel/perf_cpum_cf_events.c | 107 ++++++++++++++++++++++----------- - 2 files changed, 75 insertions(+), 36 deletions(-) + 2 files changed, 84 insertions(+), 38 deletions(-) --- a/arch/s390/kernel/perf_cpum_cf.c +++ b/arch/s390/kernel/perf_cpum_cf.c @@ -32,9 +32,39 @@ Acked-by: Petr Tesarik * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License (version 2 only) +@@ -49,7 +49,7 @@ static enum cpumf_ctr_set get_counter_se + set = CPUMF_CTR_SET_USER; + else if (event < 128) + set = CPUMF_CTR_SET_CRYPTO; +- else if (event < 256) ++ else if (event < 288) + set = CPUMF_CTR_SET_EXT; + else if (event >= 448 && event < 496) + set = CPUMF_CTR_SET_MT_DIAG; +@@ -73,12 +73,19 @@ static int validate_ctr_version(const st + err = -EOPNOTSUPP; + break; + case CPUMF_CTR_SET_CRYPTO: ++ if ((cpuhw->info.csvn >= 1 && cpuhw->info.csvn <= 5 && ++ hwc->config > 79) || ++ (cpuhw->info.csvn >= 6 && hwc->config > 83)) ++ err = -EOPNOTSUPP; ++ break; + case CPUMF_CTR_SET_EXT: + if (cpuhw->info.csvn < 1) + err = -EOPNOTSUPP; + if ((cpuhw->info.csvn == 1 && hwc->config > 159) || + (cpuhw->info.csvn == 2 && hwc->config > 175) || +- (cpuhw->info.csvn > 2 && hwc->config > 255)) ++ (cpuhw->info.csvn >= 3 && cpuhw->info.csvn <= 5 ++ && hwc->config > 255) || ++ (cpuhw->info.csvn >= 6 && hwc->config > 287)) + err = -EOPNOTSUPP; + break; + case CPUMF_CTR_SET_MT_DIAG: --- a/arch/s390/kernel/perf_cpum_cf_events.c +++ b/arch/s390/kernel/perf_cpum_cf_events.c -@@ -29,22 +29,26 @@ CPUMF_EVENT_ATTR(cf_fvn3, PROBLEM_STATE_ +@@ -30,22 +30,26 @@ CPUMF_EVENT_ATTR(cf_fvn3, PROBLEM_STATE_ CPUMF_EVENT_ATTR(cf_fvn3, PROBLEM_STATE_INSTRUCTIONS, 0x0021); CPUMF_EVENT_ATTR(cf_fvn3, L1D_DIR_WRITES, 0x0004); CPUMF_EVENT_ATTR(cf_fvn3, L1D_PENALTY_CYCLES, 0x0005); @@ -77,7 +107,7 @@ Acked-by: Petr Tesarik CPUMF_EVENT_ATTR(cf_z10, L1I_L2_SOURCED_WRITES, 0x0080); CPUMF_EVENT_ATTR(cf_z10, L1D_L2_SOURCED_WRITES, 0x0081); CPUMF_EVENT_ATTR(cf_z10, L1I_L3_LOCAL_WRITES, 0x0082); -@@ -260,23 +264,47 @@ static struct attribute *cpumcf_fvn3_pmu +@@ -261,23 +265,47 @@ static struct attribute *cpumcf_fvn3_pmu NULL, }; @@ -142,7 +172,7 @@ Acked-by: Petr Tesarik NULL, }; -@@ -560,7 +588,18 @@ __init const struct attribute_group **cp +@@ -561,7 +589,18 @@ __init const struct attribute_group **cp default: cfvn = none; } diff --git a/series.conf b/series.conf index cdebd9d..31a51ed 100644 --- a/series.conf +++ b/series.conf @@ -44289,6 +44289,9 @@ patches.drivers/scsi-lpfc-add-Trunking-support.patch patches.drivers/scsi-lpfc-update-driver-version-to-12.0.0.8.patch patches.drivers/scsi-qla2xxx-use-lower_32_bits-and-upper_32_bits-ins.patch + patches.drivers/scsi-pmcraid-simplify-pmcraid_cancel_all-a-bit.patch + patches.drivers/scsi-pmcraid-don-t-allocate-a-dma-coherent-buffer-fo.patch + patches.drivers/scsi-pmcraid-use-generic-DMA-API.patch patches.drivers/scsi-hisi_sas-use-dma_set_mask_and_coherent.patch patches.drivers/scsi-lpfc-use-dma_set_mask_and_coherent.patch patches.drivers/scsi-hisi_sas-Create-separate-host-attributes-per-HB.patch @@ -46098,6 +46101,8 @@ patches.drivers/scsi-megaraid_sas-return-error-when-create-dma-pool-failed patches.drivers/scsi-csiostor-drop-serial_number-usage patches.drivers/scsi-mpt3sas-Add-missing-breaks-in-switch-statements.patch + patches.drivers/scsi-cxgb4i-get-pf-number-from-lldi-pf + patches.drivers/scsi-cxgb4i-validate-tcp-sequence-number-only-if-chip-version-t5 patches.drivers/iommu-vt-d-check-identity-map-for-hot-added-devices patches.drivers/iommu-vt-d-disable-ats-support-on-untrusted-devices patches.drivers/iommu-vt-d-fix-null-pointer-reference-in-intel_svm_bind_mm @@ -46302,6 +46307,8 @@ patches.arch/kvm-x86-mmu-detect-mmio-generation-wrap-in-any-address-space patches.arch/kvm-x86-mmu-do-not-cache-mmio-accesses-while-memslots-are-in-flux patches.arch/KVM-PPC-Release-all-hardware-TCE-tables-attached-to-.patch + patches.suse/kvm-s390-implement-subfunction-processor-calls + patches.suse/kvm-s390-add-debug-logging-for-cpu-model-subfunctions patches.arch/arm64-KVM-Fix-architecturally-invalid-reset-value-fo.patch patches.fixes/CIFS-fix-POSIX-lock-leak-and-invalid-ptr-deref.patch patches.fixes/It-s-wrong-to-add-len-to-sector_nr-in-raid10-reshape.patch @@ -46971,6 +46978,7 @@ patches.drivers/mmc-core-Verify-SD-bus-width.patch patches.drivers/mmc-mmci-Prevent-polling-for-busy-detection-in-IRQ-c.patch patches.drivers/mmc-core-Fix-tag-set-memory-leak.patch + patches.drivers/mmc-sdhci-pci-Fix-BYT-OCP-setting.patch patches.drivers/drivers-fix-a-typo-in-the-kernel-doc-for-devm_platfo.patch patches.drivers/iio-common-ssp_sensors-Initialize-calculated_time-in.patch patches.drivers/iio-hmc5843-fix-potential-NULL-pointer-dereferences.patch @@ -47457,6 +47465,7 @@ patches.drivers/scsi-qla2xxx-Fix-read-offset-in-qla24xx_load_risc_fl.patch patches.drivers/scsi-libcxgbi-find-cxgbi-device-by-mac-address patches.drivers/scsi-libcxgbi-update-route-finding-logic + patches.drivers/scsi-cxgb4i-fix-incorrect-spelling-reveive-receive patches.fixes/scsi-qedf-remove-memset-memcpy-to-nfunc-and-use-func-instead patches.drivers/scsi-lpfc-Make-lpfc_sli4_oas_verify-static.patch patches.drivers/scsi-qedf-change-msi-x-load-error-message @@ -47767,6 +47776,13 @@ patches.fixes/nvme-fc-use-separate-work-queue-to-avoid-warning.patch patches.fixes/nvme-multipath-avoid-crash-on-invalid-subsystem-cntl.patch patches.arch/kvm-x86-skip-efer-vs-guest-cpuid-checks-for-host-initiated-writes + patches.suse/kvm-s390-add-vector-enhancements-facility-2-to-cpumodel + patches.suse/kvm-s390-add-vector-bcd-enhancements-facility-to-cpumodel + patches.suse/kvm-s390-add-msa9-to-cpumodel + patches.suse/kvm-s390-provide-query-function-for-instructions-returning-32-byte + patches.suse/kvm-s390-add-enhanced-sort-facilty-to-cpu-model + patches.suse/kvm-s390-add-deflate-conversion-facilty-to-cpu-model + patches.suse/kvm-s390-enable-msa9-keywrapping-functions-depending-on-cpu-model patches.fixes/KVM-polling-add-architecture-backend-to-disable-poll.patch patches.fixes/KVM-s390-provide-kvm_arch_no_poll-function.patch patches.arch/KVM-PPC-Book3S-HV-Avoid-lockdep-debugging-in-TCE-rea.patch @@ -48411,6 +48427,7 @@ patches.drivers/scsi-mpt3sas-Use-configured-PCIe-link-speed-not-max.patch patches.drivers/scsi-mpt3sas-Determine-smp-affinity-on-per-HBA-basis.patch patches.drivers/scsi-mpt3sas-Fix-msix-load-balance-on-and-off-settin.patch + patches.drivers/scsi-pmcraid-use-sg-helper-to-iterate-over-scatterli.patch patches.drivers/scsi-lib-sg_pool.c-improve-APIs-for-allocating-sg-po.patch patches.drivers/scsi-core-avoid-preallocating-big-SGL-for-protection.patch patches.drivers/scsi-core-avoid-preallocating-big-SGL-for-data.patch @@ -48425,6 +48442,7 @@ patches.drivers/VMCI-Fix-integer-overflow-in-VMCI-handle-arrays.patch patches.drivers/intel_th-msu-Fix-single-mode-with-disabled-IOMMU.patch patches.drivers/intel_th-pci-Add-Ice-Lake-NNPI-support.patch + patches.fixes/staging-fsl-dpaa2-ethsw-fix-memory-leak-of-switchdev.patch patches.drivers/staging-rtl8712-reduce-stack-usage-again.patch patches.drivers/staging-comedi-amplc_pci230-fix-null-pointer-deref-o.patch patches.drivers/staging-comedi-dt282x-fix-a-null-pointer-deref-on-in.patch @@ -48641,11 +48659,15 @@ patches.drivers/sky2-Disable-MSI-on-ASUS-P6T.patch patches.drivers/0003-can-rcar_canfd-fix-possible-IRQ-storm-on-high-load.patch patches.drivers/0004-can-peak_usb-fix-potential-double-kfree_skb.patch + patches.fixes/nl-mac-80211-fix-interface-combinations-on-crypto-co.patch patches.drivers/0005-can-peak_usb-pcan_usb_fd-Fix-info-leaks-to-USB-devic.patch patches.drivers/0006-can-peak_usb-pcan_usb_pro-Fix-info-leaks-to-USB-devi.patch patches.drivers/mwifiex-fix-802.11n-WPA-detection.patch patches.fixes/0001-iwlwifi-mvm-don-t-send-GEO_TX_POWER_LIMIT-on-version.patch patches.fixes/0001-iwlwifi-mvm-fix-version-check-for-GEO_TX_POWER_LIMIT.patch + patches.drivers/ALSA-usb-audio-fix-a-memory-leak-bug.patch + patches.drm/drm-rockchip-Suspend-DP-late.patch + patches.drm/drm-i915-Fix-wrong-escape-clock-divisor-init-for-GLK.patch # tip/tip patches.fixes/x86-kconfig-remove-x86_direct_gbpages-dependency-on-debug_pagealloc.patch