commit: 853f38b92d0ff318a3b47e71a46e4308460830c6 Author: Alice Ferrazzi <alicef <AT> gentoo <DOT> org> AuthorDate: Fri Dec 29 17:13:57 2017 +0000 Commit: Alice Ferrazzi <alicef <AT> gentoo <DOT> org> CommitDate: Fri Dec 29 17:13:57 2017 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=853f38b9
linux kernel 4.9.73 0000_README | 4 + 1072_linux-4.9.73.patch | 661 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 665 insertions(+) diff --git a/0000_README b/0000_README index 532ba73..a3e2751 100644 --- a/0000_README +++ b/0000_README @@ -331,6 +331,10 @@ Patch: 1071_linux-4.9.72.patch From: http://www.kernel.org Desc: Linux 4.9.72 +Patch: 1072_linux-4.9.73.patch +From: http://www.kernel.org +Desc: Linux 4.9.73 + Patch: 1500_XATTR_USER_PREFIX.patch From: https://bugs.gentoo.org/show_bug.cgi?id=470644 Desc: Support for namespace user.pax.* on tmpfs. diff --git a/1072_linux-4.9.73.patch b/1072_linux-4.9.73.patch new file mode 100644 index 0000000..e66bdd3 --- /dev/null +++ b/1072_linux-4.9.73.patch @@ -0,0 +1,661 @@ +diff --git a/Makefile b/Makefile +index 78dde51d9d74..64eb0bf614ee 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,6 +1,6 @@ + VERSION = 4 + PATCHLEVEL = 9 +-SUBLEVEL = 72 ++SUBLEVEL = 73 + EXTRAVERSION = + NAME = Roaring Lionus + +diff --git a/arch/powerpc/perf/core-book3s.c b/arch/powerpc/perf/core-book3s.c +index 72c27b8d2cf3..083f92746951 100644 +--- a/arch/powerpc/perf/core-book3s.c ++++ b/arch/powerpc/perf/core-book3s.c +@@ -401,8 +401,12 @@ static __u64 power_pmu_bhrb_to(u64 addr) + int ret; + __u64 target; + +- if (is_kernel_addr(addr)) +- return branch_target((unsigned int *)addr); ++ if (is_kernel_addr(addr)) { ++ if (probe_kernel_read(&instr, (void *)addr, sizeof(instr))) ++ return 0; ++ ++ return branch_target(&instr); ++ } + + /* Userspace: need copy instruction here then translate it */ + pagefault_disable(); +diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c +index 72b737b8c9d6..c8f8dd8ca0a1 100644 +--- a/arch/x86/kvm/emulate.c ++++ b/arch/x86/kvm/emulate.c +@@ -2395,9 +2395,21 @@ static int rsm_load_seg_64(struct x86_emulate_ctxt *ctxt, u64 smbase, int n) + } + + static int rsm_enter_protected_mode(struct x86_emulate_ctxt *ctxt, +- u64 cr0, u64 cr4) ++ u64 cr0, u64 cr3, u64 cr4) + { + int bad; ++ u64 pcid; ++ ++ /* In order to later set CR4.PCIDE, CR3[11:0] must be zero. */ ++ pcid = 0; ++ if (cr4 & X86_CR4_PCIDE) { ++ pcid = cr3 & 0xfff; ++ cr3 &= ~0xfff; ++ } ++ ++ bad = ctxt->ops->set_cr(ctxt, 3, cr3); ++ if (bad) ++ return X86EMUL_UNHANDLEABLE; + + /* + * First enable PAE, long mode needs it before CR0.PG = 1 is set. +@@ -2416,6 +2428,12 @@ static int rsm_enter_protected_mode(struct x86_emulate_ctxt *ctxt, + bad = ctxt->ops->set_cr(ctxt, 4, cr4); + if (bad) + return X86EMUL_UNHANDLEABLE; ++ if (pcid) { ++ bad = ctxt->ops->set_cr(ctxt, 3, cr3 | pcid); ++ if (bad) ++ return X86EMUL_UNHANDLEABLE; ++ } ++ + } + + return X86EMUL_CONTINUE; +@@ -2426,11 +2444,11 @@ static int rsm_load_state_32(struct x86_emulate_ctxt *ctxt, u64 smbase) + struct desc_struct desc; + struct desc_ptr dt; + u16 selector; +- u32 val, cr0, cr4; ++ u32 val, cr0, cr3, cr4; + int i; + + cr0 = GET_SMSTATE(u32, smbase, 0x7ffc); +- ctxt->ops->set_cr(ctxt, 3, GET_SMSTATE(u32, smbase, 0x7ff8)); ++ cr3 = GET_SMSTATE(u32, smbase, 0x7ff8); + ctxt->eflags = GET_SMSTATE(u32, smbase, 0x7ff4) | X86_EFLAGS_FIXED; + ctxt->_eip = GET_SMSTATE(u32, smbase, 0x7ff0); + +@@ -2472,14 +2490,14 @@ static int rsm_load_state_32(struct x86_emulate_ctxt *ctxt, u64 smbase) + + ctxt->ops->set_smbase(ctxt, GET_SMSTATE(u32, smbase, 0x7ef8)); + +- return rsm_enter_protected_mode(ctxt, cr0, cr4); ++ return rsm_enter_protected_mode(ctxt, cr0, cr3, cr4); + } + + static int rsm_load_state_64(struct x86_emulate_ctxt *ctxt, u64 smbase) + { + struct desc_struct desc; + struct desc_ptr dt; +- u64 val, cr0, cr4; ++ u64 val, cr0, cr3, cr4; + u32 base3; + u16 selector; + int i, r; +@@ -2496,7 +2514,7 @@ static int rsm_load_state_64(struct x86_emulate_ctxt *ctxt, u64 smbase) + ctxt->ops->set_dr(ctxt, 7, (val & DR7_VOLATILE) | DR7_FIXED_1); + + cr0 = GET_SMSTATE(u64, smbase, 0x7f58); +- ctxt->ops->set_cr(ctxt, 3, GET_SMSTATE(u64, smbase, 0x7f50)); ++ cr3 = GET_SMSTATE(u64, smbase, 0x7f50); + cr4 = GET_SMSTATE(u64, smbase, 0x7f48); + ctxt->ops->set_smbase(ctxt, GET_SMSTATE(u32, smbase, 0x7f00)); + val = GET_SMSTATE(u64, smbase, 0x7ed0); +@@ -2524,7 +2542,7 @@ static int rsm_load_state_64(struct x86_emulate_ctxt *ctxt, u64 smbase) + dt.address = GET_SMSTATE(u64, smbase, 0x7e68); + ctxt->ops->set_gdt(ctxt, &dt); + +- r = rsm_enter_protected_mode(ctxt, cr0, cr4); ++ r = rsm_enter_protected_mode(ctxt, cr0, cr3, cr4); + if (r != X86EMUL_CONTINUE) + return r; + +diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c +index f4d893713d54..7e28e6c877d9 100644 +--- a/arch/x86/kvm/x86.c ++++ b/arch/x86/kvm/x86.c +@@ -7132,7 +7132,7 @@ int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) + #endif + + kvm_rip_write(vcpu, regs->rip); +- kvm_set_rflags(vcpu, regs->rflags); ++ kvm_set_rflags(vcpu, regs->rflags | X86_EFLAGS_FIXED); + + vcpu->arch.exception.pending = false; + +diff --git a/crypto/mcryptd.c b/crypto/mcryptd.c +index c207458d6299..a14100e74754 100644 +--- a/crypto/mcryptd.c ++++ b/crypto/mcryptd.c +@@ -80,6 +80,7 @@ static int mcryptd_init_queue(struct mcryptd_queue *queue, + pr_debug("cpu_queue #%d %p\n", cpu, queue->cpu_queue); + crypto_init_queue(&cpu_queue->queue, max_cpu_qlen); + INIT_WORK(&cpu_queue->work, mcryptd_queue_worker); ++ spin_lock_init(&cpu_queue->q_lock); + } + return 0; + } +@@ -103,15 +104,16 @@ static int mcryptd_enqueue_request(struct mcryptd_queue *queue, + int cpu, err; + struct mcryptd_cpu_queue *cpu_queue; + +- cpu = get_cpu(); +- cpu_queue = this_cpu_ptr(queue->cpu_queue); +- rctx->tag.cpu = cpu; ++ cpu_queue = raw_cpu_ptr(queue->cpu_queue); ++ spin_lock(&cpu_queue->q_lock); ++ cpu = smp_processor_id(); ++ rctx->tag.cpu = smp_processor_id(); + + err = crypto_enqueue_request(&cpu_queue->queue, request); + pr_debug("enqueue request: cpu %d cpu_queue %p request %p\n", + cpu, cpu_queue, request); ++ spin_unlock(&cpu_queue->q_lock); + queue_work_on(cpu, kcrypto_wq, &cpu_queue->work); +- put_cpu(); + + return err; + } +@@ -160,16 +162,11 @@ static void mcryptd_queue_worker(struct work_struct *work) + cpu_queue = container_of(work, struct mcryptd_cpu_queue, work); + i = 0; + while (i < MCRYPTD_BATCH || single_task_running()) { +- /* +- * preempt_disable/enable is used to prevent +- * being preempted by mcryptd_enqueue_request() +- */ +- local_bh_disable(); +- preempt_disable(); ++ ++ spin_lock_bh(&cpu_queue->q_lock); + backlog = crypto_get_backlog(&cpu_queue->queue); + req = crypto_dequeue_request(&cpu_queue->queue); +- preempt_enable(); +- local_bh_enable(); ++ spin_unlock_bh(&cpu_queue->q_lock); + + if (!req) { + mcryptd_opportunistic_flush(); +@@ -184,7 +181,7 @@ static void mcryptd_queue_worker(struct work_struct *work) + ++i; + } + if (cpu_queue->queue.qlen) +- queue_work(kcrypto_wq, &cpu_queue->work); ++ queue_work_on(smp_processor_id(), kcrypto_wq, &cpu_queue->work); + } + + void mcryptd_flusher(struct work_struct *__work) +diff --git a/drivers/acpi/apei/erst.c b/drivers/acpi/apei/erst.c +index ec4f507b524f..4558cc73abf3 100644 +--- a/drivers/acpi/apei/erst.c ++++ b/drivers/acpi/apei/erst.c +@@ -1020,7 +1020,7 @@ static ssize_t erst_reader(u64 *id, enum pstore_type_id *type, int *count, + /* The record may be cleared by others, try read next record */ + if (len == -ENOENT) + goto skip; +- else if (len < sizeof(*rcd)) { ++ else if (len < 0 || len < sizeof(*rcd)) { + rc = -EIO; + goto out; + } +diff --git a/drivers/acpi/nfit/core.c b/drivers/acpi/nfit/core.c +index f3bc901ac930..fe03d00de22b 100644 +--- a/drivers/acpi/nfit/core.c ++++ b/drivers/acpi/nfit/core.c +@@ -1390,6 +1390,11 @@ static int acpi_nfit_add_dimm(struct acpi_nfit_desc *acpi_desc, + dev_name(&adev_dimm->dev)); + return -ENXIO; + } ++ /* ++ * Record nfit_mem for the notification path to track back to ++ * the nfit sysfs attributes for this dimm device object. ++ */ ++ dev_set_drvdata(&adev_dimm->dev, nfit_mem); + + /* + * Until standardization materializes we need to consider 4 +@@ -1446,9 +1451,11 @@ static void shutdown_dimm_notify(void *data) + sysfs_put(nfit_mem->flags_attr); + nfit_mem->flags_attr = NULL; + } +- if (adev_dimm) ++ if (adev_dimm) { + acpi_remove_notify_handler(adev_dimm->handle, + ACPI_DEVICE_NOTIFY, acpi_nvdimm_notify); ++ dev_set_drvdata(&adev_dimm->dev, NULL); ++ } + } + mutex_unlock(&acpi_desc->init_mutex); + } +diff --git a/drivers/clk/sunxi/clk-sun9i-mmc.c b/drivers/clk/sunxi/clk-sun9i-mmc.c +index 6041bdba2e97..f69f9e8c6f38 100644 +--- a/drivers/clk/sunxi/clk-sun9i-mmc.c ++++ b/drivers/clk/sunxi/clk-sun9i-mmc.c +@@ -16,6 +16,7 @@ + + #include <linux/clk.h> + #include <linux/clk-provider.h> ++#include <linux/delay.h> + #include <linux/init.h> + #include <linux/of.h> + #include <linux/of_device.h> +@@ -83,9 +84,20 @@ static int sun9i_mmc_reset_deassert(struct reset_controller_dev *rcdev, + return 0; + } + ++static int sun9i_mmc_reset_reset(struct reset_controller_dev *rcdev, ++ unsigned long id) ++{ ++ sun9i_mmc_reset_assert(rcdev, id); ++ udelay(10); ++ sun9i_mmc_reset_deassert(rcdev, id); ++ ++ return 0; ++} ++ + static const struct reset_control_ops sun9i_mmc_reset_ops = { + .assert = sun9i_mmc_reset_assert, + .deassert = sun9i_mmc_reset_deassert, ++ .reset = sun9i_mmc_reset_reset, + }; + + static int sun9i_a80_mmc_config_clk_probe(struct platform_device *pdev) +diff --git a/drivers/mfd/cros_ec_spi.c b/drivers/mfd/cros_ec_spi.c +index a518832ed5f5..59dbdaa24c28 100644 +--- a/drivers/mfd/cros_ec_spi.c ++++ b/drivers/mfd/cros_ec_spi.c +@@ -664,6 +664,7 @@ static int cros_ec_spi_probe(struct spi_device *spi) + sizeof(struct ec_response_get_protocol_info); + ec_dev->dout_size = sizeof(struct ec_host_request); + ++ ec_spi->last_transfer_ns = ktime_get_ns(); + + err = cros_ec_register(ec_dev); + if (err) { +diff --git a/drivers/mfd/twl4030-audio.c b/drivers/mfd/twl4030-audio.c +index 0a1606480023..cc832d309599 100644 +--- a/drivers/mfd/twl4030-audio.c ++++ b/drivers/mfd/twl4030-audio.c +@@ -159,13 +159,18 @@ unsigned int twl4030_audio_get_mclk(void) + EXPORT_SYMBOL_GPL(twl4030_audio_get_mclk); + + static bool twl4030_audio_has_codec(struct twl4030_audio_data *pdata, +- struct device_node *node) ++ struct device_node *parent) + { ++ struct device_node *node; ++ + if (pdata && pdata->codec) + return true; + +- if (of_find_node_by_name(node, "codec")) ++ node = of_get_child_by_name(parent, "codec"); ++ if (node) { ++ of_node_put(node); + return true; ++ } + + return false; + } +diff --git a/drivers/mfd/twl6040.c b/drivers/mfd/twl6040.c +index d66502d36ba0..dd19f17a1b63 100644 +--- a/drivers/mfd/twl6040.c ++++ b/drivers/mfd/twl6040.c +@@ -97,12 +97,16 @@ static struct reg_sequence twl6040_patch[] = { + }; + + +-static bool twl6040_has_vibra(struct device_node *node) ++static bool twl6040_has_vibra(struct device_node *parent) + { +-#ifdef CONFIG_OF +- if (of_find_node_by_name(node, "vibra")) ++ struct device_node *node; ++ ++ node = of_get_child_by_name(parent, "vibra"); ++ if (node) { ++ of_node_put(node); + return true; +-#endif ++ } ++ + return false; + } + +diff --git a/drivers/net/ethernet/marvell/mvneta.c b/drivers/net/ethernet/marvell/mvneta.c +index 6ea10a9f33e8..fa463268d019 100644 +--- a/drivers/net/ethernet/marvell/mvneta.c ++++ b/drivers/net/ethernet/marvell/mvneta.c +@@ -1182,6 +1182,10 @@ static void mvneta_port_disable(struct mvneta_port *pp) + val &= ~MVNETA_GMAC0_PORT_ENABLE; + mvreg_write(pp, MVNETA_GMAC_CTRL_0, val); + ++ pp->link = 0; ++ pp->duplex = -1; ++ pp->speed = 0; ++ + udelay(200); + } + +@@ -1905,9 +1909,9 @@ static int mvneta_rx_swbm(struct mvneta_port *pp, int rx_todo, + + if (!mvneta_rxq_desc_is_first_last(rx_status) || + (rx_status & MVNETA_RXD_ERR_SUMMARY)) { ++ mvneta_rx_error(pp, rx_desc); + err_drop_frame: + dev->stats.rx_errors++; +- mvneta_rx_error(pp, rx_desc); + /* leave the descriptor untouched */ + continue; + } +@@ -2922,7 +2926,7 @@ static void mvneta_cleanup_rxqs(struct mvneta_port *pp) + { + int queue; + +- for (queue = 0; queue < txq_number; queue++) ++ for (queue = 0; queue < rxq_number; queue++) + mvneta_rxq_deinit(pp, &pp->rxqs[queue]); + } + +diff --git a/drivers/nvdimm/pfn_devs.c b/drivers/nvdimm/pfn_devs.c +index 71eb6c637b60..42abdd2391c9 100644 +--- a/drivers/nvdimm/pfn_devs.c ++++ b/drivers/nvdimm/pfn_devs.c +@@ -352,9 +352,9 @@ struct device *nd_pfn_create(struct nd_region *nd_region) + int nd_pfn_validate(struct nd_pfn *nd_pfn, const char *sig) + { + u64 checksum, offset; +- unsigned long align; + enum nd_pfn_mode mode; + struct nd_namespace_io *nsio; ++ unsigned long align, start_pad; + struct nd_pfn_sb *pfn_sb = nd_pfn->pfn_sb; + struct nd_namespace_common *ndns = nd_pfn->ndns; + const u8 *parent_uuid = nd_dev_to_uuid(&ndns->dev); +@@ -398,6 +398,7 @@ int nd_pfn_validate(struct nd_pfn *nd_pfn, const char *sig) + + align = le32_to_cpu(pfn_sb->align); + offset = le64_to_cpu(pfn_sb->dataoff); ++ start_pad = le32_to_cpu(pfn_sb->start_pad); + if (align == 0) + align = 1UL << ilog2(offset); + mode = le32_to_cpu(pfn_sb->mode); +@@ -456,7 +457,7 @@ int nd_pfn_validate(struct nd_pfn *nd_pfn, const char *sig) + return -EBUSY; + } + +- if ((align && !IS_ALIGNED(offset, align)) ++ if ((align && !IS_ALIGNED(nsio->res.start + offset + start_pad, align)) + || !IS_ALIGNED(offset, PAGE_SIZE)) { + dev_err(&nd_pfn->dev, + "bad offset: %#llx dax disabled align: %#lx\n", +diff --git a/drivers/parisc/lba_pci.c b/drivers/parisc/lba_pci.c +index bc286cbbbc9b..1cced1d039d7 100644 +--- a/drivers/parisc/lba_pci.c ++++ b/drivers/parisc/lba_pci.c +@@ -1656,3 +1656,36 @@ void lba_set_iregs(struct parisc_device *lba, u32 ibase, u32 imask) + iounmap(base_addr); + } + ++ ++/* ++ * The design of the Diva management card in rp34x0 machines (rp3410, rp3440) ++ * seems rushed, so that many built-in components simply don't work. ++ * The following quirks disable the serial AUX port and the built-in ATI RV100 ++ * Radeon 7000 graphics card which both don't have any external connectors and ++ * thus are useless, and even worse, e.g. the AUX port occupies ttyS0 and as ++ * such makes those machines the only PARISC machines on which we can't use ++ * ttyS0 as boot console. ++ */ ++static void quirk_diva_ati_card(struct pci_dev *dev) ++{ ++ if (dev->subsystem_vendor != PCI_VENDOR_ID_HP || ++ dev->subsystem_device != 0x1292) ++ return; ++ ++ dev_info(&dev->dev, "Hiding Diva built-in ATI card"); ++ dev->device = 0; ++} ++DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_RADEON_QY, ++ quirk_diva_ati_card); ++ ++static void quirk_diva_aux_disable(struct pci_dev *dev) ++{ ++ if (dev->subsystem_vendor != PCI_VENDOR_ID_HP || ++ dev->subsystem_device != 0x1291) ++ return; ++ ++ dev_info(&dev->dev, "Hiding Diva built-in AUX serial device"); ++ dev->device = 0; ++} ++DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_DIVA_AUX, ++ quirk_diva_aux_disable); +diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c +index 8a68e2b554e1..802997e2ddcc 100644 +--- a/drivers/pci/pci-driver.c ++++ b/drivers/pci/pci-driver.c +@@ -953,7 +953,12 @@ static int pci_pm_thaw_noirq(struct device *dev) + if (pci_has_legacy_pm_support(pci_dev)) + return pci_legacy_resume_early(dev); + +- pci_update_current_state(pci_dev, PCI_D0); ++ /* ++ * pci_restore_state() requires the device to be in D0 (because of MSI ++ * restoration among other things), so force it into D0 in case the ++ * driver's "freeze" callbacks put it into a low-power state directly. ++ */ ++ pci_set_power_state(pci_dev, PCI_D0); + pci_restore_state(pci_dev); + + if (drv && drv->pm && drv->pm->thaw_noirq) +diff --git a/drivers/pinctrl/intel/pinctrl-cherryview.c b/drivers/pinctrl/intel/pinctrl-cherryview.c +index 0d34d8a4ab14..e8c08eb97530 100644 +--- a/drivers/pinctrl/intel/pinctrl-cherryview.c ++++ b/drivers/pinctrl/intel/pinctrl-cherryview.c +@@ -1594,6 +1594,22 @@ static int chv_gpio_probe(struct chv_pinctrl *pctrl, int irq) + clear_bit(i, chip->irq_valid_mask); + } + ++ /* ++ * The same set of machines in chv_no_valid_mask[] have incorrectly ++ * configured GPIOs that generate spurious interrupts so we use ++ * this same list to apply another quirk for them. ++ * ++ * See also https://bugzilla.kernel.org/show_bug.cgi?id=197953. ++ */ ++ if (!need_valid_mask) { ++ /* ++ * Mask all interrupts the community is able to generate ++ * but leave the ones that can only generate GPEs unmasked. ++ */ ++ chv_writel(GENMASK(31, pctrl->community->nirqs), ++ pctrl->regs + CHV_INTMASK); ++ } ++ + /* Clear all interrupts */ + chv_writel(0xffff, pctrl->regs + CHV_INTSTAT); + +diff --git a/drivers/spi/spi-xilinx.c b/drivers/spi/spi-xilinx.c +index bc7100b93dfc..e0b9fe1d0e37 100644 +--- a/drivers/spi/spi-xilinx.c ++++ b/drivers/spi/spi-xilinx.c +@@ -271,6 +271,7 @@ static int xilinx_spi_txrx_bufs(struct spi_device *spi, struct spi_transfer *t) + while (remaining_words) { + int n_words, tx_words, rx_words; + u32 sr; ++ int stalled; + + n_words = min(remaining_words, xspi->buffer_size); + +@@ -299,7 +300,17 @@ static int xilinx_spi_txrx_bufs(struct spi_device *spi, struct spi_transfer *t) + + /* Read out all the data from the Rx FIFO */ + rx_words = n_words; ++ stalled = 10; + while (rx_words) { ++ if (rx_words == n_words && !(stalled--) && ++ !(sr & XSPI_SR_TX_EMPTY_MASK) && ++ (sr & XSPI_SR_RX_EMPTY_MASK)) { ++ dev_err(&spi->dev, ++ "Detected stall. Check C_SPI_MODE and C_SPI_MEMORY\n"); ++ xspi_init_hw(xspi); ++ return -EIO; ++ } ++ + if ((sr & XSPI_SR_TX_EMPTY_MASK) && (rx_words > 1)) { + xilinx_spi_rx(xspi); + rx_words--; +diff --git a/include/crypto/mcryptd.h b/include/crypto/mcryptd.h +index 4a53c0d38cd2..e045722a69aa 100644 +--- a/include/crypto/mcryptd.h ++++ b/include/crypto/mcryptd.h +@@ -26,6 +26,7 @@ static inline struct mcryptd_ahash *__mcryptd_ahash_cast( + + struct mcryptd_cpu_queue { + struct crypto_queue queue; ++ spinlock_t q_lock; + struct work_struct work; + }; + +diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c +index 8b1ebe4c6aba..d7eeebfafe8d 100644 +--- a/kernel/bpf/verifier.c ++++ b/kernel/bpf/verifier.c +@@ -2722,11 +2722,12 @@ static bool states_equal(struct bpf_verifier_env *env, + + /* If we didn't map access then again we don't care about the + * mismatched range values and it's ok if our old type was +- * UNKNOWN and we didn't go to a NOT_INIT'ed reg. ++ * UNKNOWN and we didn't go to a NOT_INIT'ed or pointer reg. + */ + if (rold->type == NOT_INIT || + (!varlen_map_access && rold->type == UNKNOWN_VALUE && +- rcur->type != NOT_INIT)) ++ rcur->type != NOT_INIT && ++ !__is_pointer_value(env->allow_ptr_leaks, rcur))) + continue; + + /* Don't care about the reg->id in this case. */ +diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c +index b450a27588c8..16f8124b1150 100644 +--- a/sound/core/rawmidi.c ++++ b/sound/core/rawmidi.c +@@ -579,15 +579,14 @@ static int snd_rawmidi_info_user(struct snd_rawmidi_substream *substream, + return 0; + } + +-int snd_rawmidi_info_select(struct snd_card *card, struct snd_rawmidi_info *info) ++static int __snd_rawmidi_info_select(struct snd_card *card, ++ struct snd_rawmidi_info *info) + { + struct snd_rawmidi *rmidi; + struct snd_rawmidi_str *pstr; + struct snd_rawmidi_substream *substream; + +- mutex_lock(®ister_mutex); + rmidi = snd_rawmidi_search(card, info->device); +- mutex_unlock(®ister_mutex); + if (!rmidi) + return -ENXIO; + if (info->stream < 0 || info->stream > 1) +@@ -603,6 +602,16 @@ int snd_rawmidi_info_select(struct snd_card *card, struct snd_rawmidi_info *info + } + return -ENXIO; + } ++ ++int snd_rawmidi_info_select(struct snd_card *card, struct snd_rawmidi_info *info) ++{ ++ int ret; ++ ++ mutex_lock(®ister_mutex); ++ ret = __snd_rawmidi_info_select(card, info); ++ mutex_unlock(®ister_mutex); ++ return ret; ++} + EXPORT_SYMBOL(snd_rawmidi_info_select); + + static int snd_rawmidi_info_select_user(struct snd_card *card, +diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c +index 24c897f0b571..08015c139116 100644 +--- a/sound/usb/mixer.c ++++ b/sound/usb/mixer.c +@@ -2167,20 +2167,25 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, + kctl->private_value = (unsigned long)namelist; + kctl->private_free = usb_mixer_selector_elem_free; + +- nameid = uac_selector_unit_iSelector(desc); ++ /* check the static mapping table at first */ + len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name)); +- if (len) +- ; +- else if (nameid) +- len = snd_usb_copy_string_desc(state, nameid, kctl->id.name, +- sizeof(kctl->id.name)); +- else +- len = get_term_name(state, &state->oterm, +- kctl->id.name, sizeof(kctl->id.name), 0); +- + if (!len) { +- strlcpy(kctl->id.name, "USB", sizeof(kctl->id.name)); ++ /* no mapping ? */ ++ /* if iSelector is given, use it */ ++ nameid = uac_selector_unit_iSelector(desc); ++ if (nameid) ++ len = snd_usb_copy_string_desc(state, nameid, ++ kctl->id.name, ++ sizeof(kctl->id.name)); ++ /* ... or pick up the terminal name at next */ ++ if (!len) ++ len = get_term_name(state, &state->oterm, ++ kctl->id.name, sizeof(kctl->id.name), 0); ++ /* ... or use the fixed string "USB" as the last resort */ ++ if (!len) ++ strlcpy(kctl->id.name, "USB", sizeof(kctl->id.name)); + ++ /* and add the proper suffix */ + if (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR) + append_ctl_name(kctl, " Clock Source"); + else if ((state->oterm.type & 0xff00) == 0x0100) +diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c +index 7613b9e07b5c..1cd7f8b0bf77 100644 +--- a/sound/usb/quirks.c ++++ b/sound/usb/quirks.c +@@ -1170,10 +1170,11 @@ static bool is_marantz_denon_dac(unsigned int id) + /* TEAC UD-501/UD-503/NT-503 USB DACs need a vendor cmd to switch + * between PCM/DOP and native DSD mode + */ +-static bool is_teac_50X_dac(unsigned int id) ++static bool is_teac_dsd_dac(unsigned int id) + { + switch (id) { + case USB_ID(0x0644, 0x8043): /* TEAC UD-501/UD-503/NT-503 */ ++ case USB_ID(0x0644, 0x8044): /* Esoteric D-05X */ + return true; + } + return false; +@@ -1206,7 +1207,7 @@ int snd_usb_select_mode_quirk(struct snd_usb_substream *subs, + break; + } + mdelay(20); +- } else if (is_teac_50X_dac(subs->stream->chip->usb_id)) { ++ } else if (is_teac_dsd_dac(subs->stream->chip->usb_id)) { + /* Vendor mode switch cmd is required. */ + switch (fmt->altsetting) { + case 3: /* DSD mode (DSD_U32) requested */ +@@ -1376,7 +1377,7 @@ u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip, + } + + /* TEAC devices with USB DAC functionality */ +- if (is_teac_50X_dac(chip->usb_id)) { ++ if (is_teac_dsd_dac(chip->usb_id)) { + if (fp->altsetting == 3) + return SNDRV_PCM_FMTBIT_DSD_U32_BE; + }
