commit: 646db9af4d1ca4d7ada5c5f3c6788a556e923f5f Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Fri Nov 25 17:04:58 2022 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Fri Nov 25 17:04:58 2022 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=646db9af
Linux patch 5.4.225 Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> 0000_README | 4 + 1224_linux-5.4.225.patch | 3990 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 3994 insertions(+) diff --git a/0000_README b/0000_README index 60c86d23..3fe0ab2a 100644 --- a/0000_README +++ b/0000_README @@ -939,6 +939,10 @@ Patch: 1223_linux-5.4.224.patch From: http://www.kernel.org Desc: Linux 5.4.224 +Patch: 1224_linux-5.4.225.patch +From: http://www.kernel.org +Desc: Linux 5.4.225 + 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/1224_linux-5.4.225.patch b/1224_linux-5.4.225.patch new file mode 100644 index 00000000..a076a38c --- /dev/null +++ b/1224_linux-5.4.225.patch @@ -0,0 +1,3990 @@ +diff --git a/Documentation/process/code-of-conduct-interpretation.rst b/Documentation/process/code-of-conduct-interpretation.rst +index 4f8a06b00f608..43da2cc2e3b9b 100644 +--- a/Documentation/process/code-of-conduct-interpretation.rst ++++ b/Documentation/process/code-of-conduct-interpretation.rst +@@ -51,7 +51,7 @@ the Technical Advisory Board (TAB) or other maintainers if you're + uncertain how to handle situations that come up. It will not be + considered a violation report unless you want it to be. If you are + uncertain about approaching the TAB or any other maintainers, please +-reach out to our conflict mediator, Joanna Lee <[email protected]>. ++reach out to our conflict mediator, Joanna Lee <[email protected]>. + + In the end, "be kind to each other" is really what the end goal is for + everybody. We know everyone is human and we all fail at times, but the +diff --git a/Makefile b/Makefile +index 3d46653e4b1cb..bf33b3febbbc5 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 4 +-SUBLEVEL = 224 ++SUBLEVEL = 225 + EXTRAVERSION = + NAME = Kleptomaniac Octopus + +diff --git a/arch/arm64/boot/dts/freescale/imx8mm.dtsi b/arch/arm64/boot/dts/freescale/imx8mm.dtsi +index 7b178a77cc712..304399686c5ae 100644 +--- a/arch/arm64/boot/dts/freescale/imx8mm.dtsi ++++ b/arch/arm64/boot/dts/freescale/imx8mm.dtsi +@@ -838,10 +838,10 @@ + clocks = <&clk IMX8MM_CLK_NAND_USDHC_BUS_RAWNAND_CLK>; + }; + +- gpmi: nand-controller@33002000{ ++ gpmi: nand-controller@33002000 { + compatible = "fsl,imx8mm-gpmi-nand", "fsl,imx7d-gpmi-nand"; + #address-cells = <1>; +- #size-cells = <1>; ++ #size-cells = <0>; + reg = <0x33002000 0x2000>, <0x33004000 0x4000>; + reg-names = "gpmi-nand", "bch"; + interrupts = <GIC_SPI 14 IRQ_TYPE_LEVEL_HIGH>; +diff --git a/arch/arm64/boot/dts/freescale/imx8mn.dtsi b/arch/arm64/boot/dts/freescale/imx8mn.dtsi +index 546511b373d43..31c017736a057 100644 +--- a/arch/arm64/boot/dts/freescale/imx8mn.dtsi ++++ b/arch/arm64/boot/dts/freescale/imx8mn.dtsi +@@ -695,7 +695,7 @@ + gpmi: nand-controller@33002000 { + compatible = "fsl,imx8mn-gpmi-nand", "fsl,imx7d-gpmi-nand"; + #address-cells = <1>; +- #size-cells = <1>; ++ #size-cells = <0>; + reg = <0x33002000 0x2000>, <0x33004000 0x4000>; + reg-names = "gpmi-nand", "bch"; + interrupts = <GIC_SPI 14 IRQ_TYPE_LEVEL_HIGH>; +diff --git a/arch/arm64/kernel/efi.c b/arch/arm64/kernel/efi.c +index d0cf596db82c6..14b7352bc05eb 100644 +--- a/arch/arm64/kernel/efi.c ++++ b/arch/arm64/kernel/efi.c +@@ -12,6 +12,14 @@ + + #include <asm/efi.h> + ++static bool region_is_misaligned(const efi_memory_desc_t *md) ++{ ++ if (PAGE_SIZE == EFI_PAGE_SIZE) ++ return false; ++ return !PAGE_ALIGNED(md->phys_addr) || ++ !PAGE_ALIGNED(md->num_pages << EFI_PAGE_SHIFT); ++} ++ + /* + * Only regions of type EFI_RUNTIME_SERVICES_CODE need to be + * executable, everything else can be mapped with the XN bits +@@ -25,14 +33,22 @@ static __init pteval_t create_mapping_protection(efi_memory_desc_t *md) + if (type == EFI_MEMORY_MAPPED_IO) + return PROT_DEVICE_nGnRE; + +- if (WARN_ONCE(!PAGE_ALIGNED(md->phys_addr), +- "UEFI Runtime regions are not aligned to 64 KB -- buggy firmware?")) ++ if (region_is_misaligned(md)) { ++ static bool __initdata code_is_misaligned; ++ + /* +- * If the region is not aligned to the page size of the OS, we +- * can not use strict permissions, since that would also affect +- * the mapping attributes of the adjacent regions. ++ * Regions that are not aligned to the OS page size cannot be ++ * mapped with strict permissions, as those might interfere ++ * with the permissions that are needed by the adjacent ++ * region's mapping. However, if we haven't encountered any ++ * misaligned runtime code regions so far, we can safely use ++ * non-executable permissions for non-code regions. + */ +- return pgprot_val(PAGE_KERNEL_EXEC); ++ code_is_misaligned |= (type == EFI_RUNTIME_SERVICES_CODE); ++ ++ return code_is_misaligned ? pgprot_val(PAGE_KERNEL_EXEC) ++ : pgprot_val(PAGE_KERNEL); ++ } + + /* R-- */ + if ((attr & (EFI_MEMORY_XP | EFI_MEMORY_RO)) == +@@ -62,19 +78,16 @@ int __init efi_create_mapping(struct mm_struct *mm, efi_memory_desc_t *md) + bool page_mappings_only = (md->type == EFI_RUNTIME_SERVICES_CODE || + md->type == EFI_RUNTIME_SERVICES_DATA); + +- if (!PAGE_ALIGNED(md->phys_addr) || +- !PAGE_ALIGNED(md->num_pages << EFI_PAGE_SHIFT)) { +- /* +- * If the end address of this region is not aligned to page +- * size, the mapping is rounded up, and may end up sharing a +- * page frame with the next UEFI memory region. If we create +- * a block entry now, we may need to split it again when mapping +- * the next region, and support for that is going to be removed +- * from the MMU routines. So avoid block mappings altogether in +- * that case. +- */ ++ /* ++ * If this region is not aligned to the page size used by the OS, the ++ * mapping will be rounded outwards, and may end up sharing a page ++ * frame with an adjacent runtime memory region. Given that the page ++ * table descriptor covering the shared page will be rewritten when the ++ * adjacent region gets mapped, we must avoid block mappings here so we ++ * don't have to worry about splitting them when that happens. ++ */ ++ if (region_is_misaligned(md)) + page_mappings_only = true; +- } + + create_pgd_mapping(mm, md->phys_addr, md->virt_addr, + md->num_pages << EFI_PAGE_SHIFT, +@@ -101,6 +114,9 @@ int __init efi_set_mapping_permissions(struct mm_struct *mm, + BUG_ON(md->type != EFI_RUNTIME_SERVICES_CODE && + md->type != EFI_RUNTIME_SERVICES_DATA); + ++ if (region_is_misaligned(md)) ++ return 0; ++ + /* + * Calling apply_to_page_range() is only safe on regions that are + * guaranteed to be mapped down to pages. Since we are only called +diff --git a/arch/mips/kernel/jump_label.c b/arch/mips/kernel/jump_label.c +index 662c8db9f45ba..9f5b1247b4ba4 100644 +--- a/arch/mips/kernel/jump_label.c ++++ b/arch/mips/kernel/jump_label.c +@@ -56,7 +56,7 @@ void arch_jump_label_transform(struct jump_entry *e, + * The branch offset must fit in the instruction's 26 + * bit field. + */ +- WARN_ON((offset >= BIT(25)) || ++ WARN_ON((offset >= (long)BIT(25)) || + (offset < -(long)BIT(25))); + + insn.j_format.opcode = bc6_op; +diff --git a/arch/riscv/kernel/process.c b/arch/riscv/kernel/process.c +index 330b34706aa02..9d4b4098874bb 100644 +--- a/arch/riscv/kernel/process.c ++++ b/arch/riscv/kernel/process.c +@@ -104,6 +104,8 @@ int copy_thread_tls(unsigned long clone_flags, unsigned long usp, + { + struct pt_regs *childregs = task_pt_regs(p); + ++ memset(&p->thread.s, 0, sizeof(p->thread.s)); ++ + /* p->thread holds context to be restored by __switch_to() */ + if (unlikely(p->flags & PF_KTHREAD)) { + /* Kernel thread */ +diff --git a/arch/x86/include/asm/msr-index.h b/arch/x86/include/asm/msr-index.h +index 713886d5493a8..7fa0b213b0079 100644 +--- a/arch/x86/include/asm/msr-index.h ++++ b/arch/x86/include/asm/msr-index.h +@@ -454,6 +454,11 @@ + #define MSR_AMD64_OSVW_STATUS 0xc0010141 + #define MSR_AMD64_LS_CFG 0xc0011020 + #define MSR_AMD64_DC_CFG 0xc0011022 ++ ++#define MSR_AMD64_DE_CFG 0xc0011029 ++#define MSR_AMD64_DE_CFG_LFENCE_SERIALIZE_BIT 1 ++#define MSR_AMD64_DE_CFG_LFENCE_SERIALIZE BIT_ULL(MSR_AMD64_DE_CFG_LFENCE_SERIALIZE_BIT) ++ + #define MSR_AMD64_BU_CFG2 0xc001102a + #define MSR_AMD64_IBSFETCHCTL 0xc0011030 + #define MSR_AMD64_IBSFETCHLINAD 0xc0011031 +@@ -522,9 +527,6 @@ + #define FAM10H_MMIO_CONF_BASE_MASK 0xfffffffULL + #define FAM10H_MMIO_CONF_BASE_SHIFT 20 + #define MSR_FAM10H_NODE_ID 0xc001100c +-#define MSR_F10H_DECFG 0xc0011029 +-#define MSR_F10H_DECFG_LFENCE_SERIALIZE_BIT 1 +-#define MSR_F10H_DECFG_LFENCE_SERIALIZE BIT_ULL(MSR_F10H_DECFG_LFENCE_SERIALIZE_BIT) + + /* K8 MSRs */ + #define MSR_K8_TOP_MEM1 0xc001001a +diff --git a/arch/x86/kernel/cpu/amd.c b/arch/x86/kernel/cpu/amd.c +index 5571b28d35b60..bc6cd29ddf163 100644 +--- a/arch/x86/kernel/cpu/amd.c ++++ b/arch/x86/kernel/cpu/amd.c +@@ -794,8 +794,6 @@ static void init_amd_gh(struct cpuinfo_x86 *c) + set_cpu_bug(c, X86_BUG_AMD_TLB_MMATCH); + } + +-#define MSR_AMD64_DE_CFG 0xC0011029 +- + static void init_amd_ln(struct cpuinfo_x86 *c) + { + /* +@@ -965,8 +963,8 @@ static void init_amd(struct cpuinfo_x86 *c) + * msr_set_bit() uses the safe accessors, too, even if the MSR + * is not present. + */ +- msr_set_bit(MSR_F10H_DECFG, +- MSR_F10H_DECFG_LFENCE_SERIALIZE_BIT); ++ msr_set_bit(MSR_AMD64_DE_CFG, ++ MSR_AMD64_DE_CFG_LFENCE_SERIALIZE_BIT); + + /* A serializing LFENCE stops RDTSC speculation */ + set_cpu_cap(c, X86_FEATURE_LFENCE_RDTSC); +diff --git a/arch/x86/kernel/cpu/hygon.c b/arch/x86/kernel/cpu/hygon.c +index b232bd0be78d6..232c9d683b38d 100644 +--- a/arch/x86/kernel/cpu/hygon.c ++++ b/arch/x86/kernel/cpu/hygon.c +@@ -335,8 +335,8 @@ static void init_hygon(struct cpuinfo_x86 *c) + * msr_set_bit() uses the safe accessors, too, even if the MSR + * is not present. + */ +- msr_set_bit(MSR_F10H_DECFG, +- MSR_F10H_DECFG_LFENCE_SERIALIZE_BIT); ++ msr_set_bit(MSR_AMD64_DE_CFG, ++ MSR_AMD64_DE_CFG_LFENCE_SERIALIZE_BIT); + + /* A serializing LFENCE stops RDTSC speculation */ + set_cpu_cap(c, X86_FEATURE_LFENCE_RDTSC); +diff --git a/arch/x86/kvm/svm.c b/arch/x86/kvm/svm.c +index 3db407e3c4166..c5a9de8d07250 100644 +--- a/arch/x86/kvm/svm.c ++++ b/arch/x86/kvm/svm.c +@@ -4180,9 +4180,9 @@ static int svm_get_msr_feature(struct kvm_msr_entry *msr) + msr->data = 0; + + switch (msr->index) { +- case MSR_F10H_DECFG: +- if (boot_cpu_has(X86_FEATURE_LFENCE_RDTSC)) +- msr->data |= MSR_F10H_DECFG_LFENCE_SERIALIZE; ++ case MSR_AMD64_DE_CFG: ++ if (cpu_feature_enabled(X86_FEATURE_LFENCE_RDTSC)) ++ msr->data |= MSR_AMD64_DE_CFG_LFENCE_SERIALIZE; + break; + default: + return 1; +@@ -4284,7 +4284,7 @@ static int svm_get_msr(struct kvm_vcpu *vcpu, struct msr_data *msr_info) + msr_info->data = 0x1E; + } + break; +- case MSR_F10H_DECFG: ++ case MSR_AMD64_DE_CFG: + msr_info->data = svm->msr_decfg; + break; + default: +@@ -4451,7 +4451,7 @@ static int svm_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr) + case MSR_VM_IGNNE: + vcpu_unimpl(vcpu, "unimplemented wrmsr: 0x%x data 0x%llx\n", ecx, data); + break; +- case MSR_F10H_DECFG: { ++ case MSR_AMD64_DE_CFG: { + struct kvm_msr_entry msr_entry; + + msr_entry.index = msr->index; +diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c +index c431a34522d6c..93727f8092ee4 100644 +--- a/arch/x86/kvm/x86.c ++++ b/arch/x86/kvm/x86.c +@@ -1337,7 +1337,7 @@ static const u32 msr_based_features_all[] = { + MSR_IA32_VMX_EPT_VPID_CAP, + MSR_IA32_VMX_VMFUNC, + +- MSR_F10H_DECFG, ++ MSR_AMD64_DE_CFG, + MSR_IA32_UCODE_REV, + MSR_IA32_ARCH_CAPABILITIES, + }; +diff --git a/arch/x86/power/cpu.c b/arch/x86/power/cpu.c +index 20dd7023132fb..313ce4ce79082 100644 +--- a/arch/x86/power/cpu.c ++++ b/arch/x86/power/cpu.c +@@ -528,6 +528,7 @@ static void pm_save_spec_msr(void) + MSR_TSX_FORCE_ABORT, + MSR_IA32_MCU_OPT_CTRL, + MSR_AMD64_LS_CFG, ++ MSR_AMD64_DE_CFG, + }; + + msr_build_context(spec_msr_id, ARRAY_SIZE(spec_msr_id)); +diff --git a/block/sed-opal.c b/block/sed-opal.c +index b4c761973ac10..401d33ae01580 100644 +--- a/block/sed-opal.c ++++ b/block/sed-opal.c +@@ -88,8 +88,8 @@ struct opal_dev { + u64 lowest_lba; + + size_t pos; +- u8 cmd[IO_BUFFER_LENGTH]; +- u8 resp[IO_BUFFER_LENGTH]; ++ u8 *cmd; ++ u8 *resp; + + struct parsed_resp parsed; + size_t prev_d_len; +@@ -2019,6 +2019,8 @@ void free_opal_dev(struct opal_dev *dev) + return; + + clean_opal_dev(dev); ++ kfree(dev->resp); ++ kfree(dev->cmd); + kfree(dev); + } + EXPORT_SYMBOL(free_opal_dev); +@@ -2031,17 +2033,39 @@ struct opal_dev *init_opal_dev(void *data, sec_send_recv *send_recv) + if (!dev) + return NULL; + ++ /* ++ * Presumably DMA-able buffers must be cache-aligned. Kmalloc makes ++ * sure the allocated buffer is DMA-safe in that regard. ++ */ ++ dev->cmd = kmalloc(IO_BUFFER_LENGTH, GFP_KERNEL); ++ if (!dev->cmd) ++ goto err_free_dev; ++ ++ dev->resp = kmalloc(IO_BUFFER_LENGTH, GFP_KERNEL); ++ if (!dev->resp) ++ goto err_free_cmd; ++ + INIT_LIST_HEAD(&dev->unlk_lst); + mutex_init(&dev->dev_lock); + dev->data = data; + dev->send_recv = send_recv; + if (check_opal_support(dev) != 0) { + pr_debug("Opal is not supported on this device\n"); +- kfree(dev); +- return NULL; ++ goto err_free_resp; + } + + return dev; ++ ++err_free_resp: ++ kfree(dev->resp); ++ ++err_free_cmd: ++ kfree(dev->cmd); ++ ++err_free_dev: ++ kfree(dev); ++ ++ return NULL; + } + EXPORT_SYMBOL(init_opal_dev); + +diff --git a/drivers/ata/libata-transport.c b/drivers/ata/libata-transport.c +index c4f36312b8a42..1069cda6ff367 100644 +--- a/drivers/ata/libata-transport.c ++++ b/drivers/ata/libata-transport.c +@@ -317,7 +317,6 @@ int ata_tport_add(struct device *parent, + tport_err: + transport_destroy_device(dev); + put_device(dev); +- ata_host_put(ap->host); + return error; + } + +diff --git a/drivers/block/drbd/drbd_main.c b/drivers/block/drbd/drbd_main.c +index 5ece2fd70d9cf..f3a96c76f5a48 100644 +--- a/drivers/block/drbd/drbd_main.c ++++ b/drivers/block/drbd/drbd_main.c +@@ -2778,7 +2778,7 @@ static int init_submitter(struct drbd_device *device) + enum drbd_ret_code drbd_create_device(struct drbd_config_context *adm_ctx, unsigned int minor) + { + struct drbd_resource *resource = adm_ctx->resource; +- struct drbd_connection *connection; ++ struct drbd_connection *connection, *n; + struct drbd_device *device; + struct drbd_peer_device *peer_device, *tmp_peer_device; + struct gendisk *disk; +@@ -2906,7 +2906,7 @@ enum drbd_ret_code drbd_create_device(struct drbd_config_context *adm_ctx, unsig + out_idr_remove_vol: + idr_remove(&connection->peer_devices, vnr); + out_idr_remove_from_resource: +- for_each_connection(connection, resource) { ++ for_each_connection_safe(connection, n, resource) { + peer_device = idr_remove(&connection->peer_devices, vnr); + if (peer_device) + kref_put(&connection->kref, drbd_destroy_connection); +diff --git a/drivers/dma/at_hdmac.c b/drivers/dma/at_hdmac.c +index 303bc3e601a1c..a430975775734 100644 +--- a/drivers/dma/at_hdmac.c ++++ b/drivers/dma/at_hdmac.c +@@ -246,6 +246,8 @@ static void atc_dostart(struct at_dma_chan *atchan, struct at_desc *first) + ATC_SPIP_BOUNDARY(first->boundary)); + channel_writel(atchan, DPIP, ATC_DPIP_HOLE(first->dst_hole) | + ATC_DPIP_BOUNDARY(first->boundary)); ++ /* Don't allow CPU to reorder channel enable. */ ++ wmb(); + dma_writel(atdma, CHER, atchan->mask); + + vdbg_dump_regs(atchan); +@@ -306,7 +308,8 @@ static int atc_get_bytes_left(struct dma_chan *chan, dma_cookie_t cookie) + struct at_desc *desc_first = atc_first_active(atchan); + struct at_desc *desc; + int ret; +- u32 ctrla, dscr, trials; ++ u32 ctrla, dscr; ++ unsigned int i; + + /* + * If the cookie doesn't match to the currently running transfer then +@@ -376,7 +379,7 @@ static int atc_get_bytes_left(struct dma_chan *chan, dma_cookie_t cookie) + dscr = channel_readl(atchan, DSCR); + rmb(); /* ensure DSCR is read before CTRLA */ + ctrla = channel_readl(atchan, CTRLA); +- for (trials = 0; trials < ATC_MAX_DSCR_TRIALS; ++trials) { ++ for (i = 0; i < ATC_MAX_DSCR_TRIALS; ++i) { + u32 new_dscr; + + rmb(); /* ensure DSCR is read after CTRLA */ +@@ -402,7 +405,7 @@ static int atc_get_bytes_left(struct dma_chan *chan, dma_cookie_t cookie) + rmb(); /* ensure DSCR is read before CTRLA */ + ctrla = channel_readl(atchan, CTRLA); + } +- if (unlikely(trials >= ATC_MAX_DSCR_TRIALS)) ++ if (unlikely(i == ATC_MAX_DSCR_TRIALS)) + return -ETIMEDOUT; + + /* for the first descriptor we can be more accurate */ +@@ -550,10 +553,6 @@ static void atc_handle_error(struct at_dma_chan *atchan) + bad_desc = atc_first_active(atchan); + list_del_init(&bad_desc->desc_node); + +- /* As we are stopped, take advantage to push queued descriptors +- * in active_list */ +- list_splice_init(&atchan->queue, atchan->active_list.prev); +- + /* Try to restart the controller */ + if (!list_empty(&atchan->active_list)) + atc_dostart(atchan, atc_first_active(atchan)); +@@ -674,19 +673,11 @@ static dma_cookie_t atc_tx_submit(struct dma_async_tx_descriptor *tx) + spin_lock_irqsave(&atchan->lock, flags); + cookie = dma_cookie_assign(tx); + +- if (list_empty(&atchan->active_list)) { +- dev_vdbg(chan2dev(tx->chan), "tx_submit: started %u\n", +- desc->txd.cookie); +- atc_dostart(atchan, desc); +- list_add_tail(&desc->desc_node, &atchan->active_list); +- } else { +- dev_vdbg(chan2dev(tx->chan), "tx_submit: queued %u\n", +- desc->txd.cookie); +- list_add_tail(&desc->desc_node, &atchan->queue); +- } +- ++ list_add_tail(&desc->desc_node, &atchan->queue); + spin_unlock_irqrestore(&atchan->lock, flags); + ++ dev_vdbg(chan2dev(tx->chan), "tx_submit: queued %u\n", ++ desc->txd.cookie); + return cookie; + } + +@@ -1957,7 +1948,11 @@ static int __init at_dma_probe(struct platform_device *pdev) + dma_has_cap(DMA_SLAVE, atdma->dma_common.cap_mask) ? "slave " : "", + plat_dat->nr_channels); + +- dma_async_device_register(&atdma->dma_common); ++ err = dma_async_device_register(&atdma->dma_common); ++ if (err) { ++ dev_err(&pdev->dev, "Unable to register: %d.\n", err); ++ goto err_dma_async_device_register; ++ } + + /* + * Do not return an error if the dmac node is not present in order to +@@ -1977,6 +1972,7 @@ static int __init at_dma_probe(struct platform_device *pdev) + + err_of_dma_controller_register: + dma_async_device_unregister(&atdma->dma_common); ++err_dma_async_device_register: + dma_pool_destroy(atdma->memset_pool); + err_memset_pool_create: + dma_pool_destroy(atdma->dma_desc_pool); +diff --git a/drivers/dma/at_hdmac_regs.h b/drivers/dma/at_hdmac_regs.h +index fe8a5853ec491..65fa3e395bf0d 100644 +--- a/drivers/dma/at_hdmac_regs.h ++++ b/drivers/dma/at_hdmac_regs.h +@@ -164,13 +164,13 @@ + /* LLI == Linked List Item; aka DMA buffer descriptor */ + struct at_lli { + /* values that are not changed by hardware */ +- dma_addr_t saddr; +- dma_addr_t daddr; ++ u32 saddr; ++ u32 daddr; + /* value that may get written back: */ +- u32 ctrla; ++ u32 ctrla; + /* more values that are not changed by hardware */ +- u32 ctrlb; +- dma_addr_t dscr; /* chain to next lli */ ++ u32 ctrlb; ++ u32 dscr; /* chain to next lli */ + }; + + /** +diff --git a/drivers/dma/mv_xor_v2.c b/drivers/dma/mv_xor_v2.c +index 889a94af4c851..3fa884145eb1e 100644 +--- a/drivers/dma/mv_xor_v2.c ++++ b/drivers/dma/mv_xor_v2.c +@@ -895,6 +895,7 @@ static int mv_xor_v2_remove(struct platform_device *pdev) + tasklet_kill(&xor_dev->irq_tasklet); + + clk_disable_unprepare(xor_dev->clk); ++ clk_disable_unprepare(xor_dev->reg_clk); + + return 0; + } +diff --git a/drivers/dma/pxa_dma.c b/drivers/dma/pxa_dma.c +index b4ef4f19f7dec..68d9d60c051d9 100644 +--- a/drivers/dma/pxa_dma.c ++++ b/drivers/dma/pxa_dma.c +@@ -1249,14 +1249,14 @@ static int pxad_init_phys(struct platform_device *op, + return -ENOMEM; + + for (i = 0; i < nb_phy_chans; i++) +- if (platform_get_irq(op, i) > 0) ++ if (platform_get_irq_optional(op, i) > 0) + nr_irq++; + + for (i = 0; i < nb_phy_chans; i++) { + phy = &pdev->phys[i]; + phy->base = pdev->base; + phy->idx = i; +- irq = platform_get_irq(op, i); ++ irq = platform_get_irq_optional(op, i); + if ((nr_irq > 1) && (irq > 0)) + ret = devm_request_irq(&op->dev, irq, + pxad_chan_handler, +diff --git a/drivers/gpu/drm/i915/gem/i915_gem_dmabuf.c b/drivers/gpu/drm/i915/gem/i915_gem_dmabuf.c +index 96ce95c8ac5a4..8826358b17415 100644 +--- a/drivers/gpu/drm/i915/gem/i915_gem_dmabuf.c ++++ b/drivers/gpu/drm/i915/gem/i915_gem_dmabuf.c +@@ -36,13 +36,13 @@ static struct sg_table *i915_gem_map_dma_buf(struct dma_buf_attachment *attachme + goto err_unpin_pages; + } + +- ret = sg_alloc_table(st, obj->mm.pages->nents, GFP_KERNEL); ++ ret = sg_alloc_table(st, obj->mm.pages->orig_nents, GFP_KERNEL); + if (ret) + goto err_free; + + src = obj->mm.pages->sgl; + dst = st->sgl; +- for (i = 0; i < obj->mm.pages->nents; i++) { ++ for (i = 0; i < obj->mm.pages->orig_nents; i++) { + sg_set_page(dst, sg_page(src), src->length, 0); + dst = sg_next(dst); + src = sg_next(src); +diff --git a/drivers/gpu/drm/imx/imx-tve.c b/drivers/gpu/drm/imx/imx-tve.c +index f91c3eb7697bc..cc300ed456e13 100644 +--- a/drivers/gpu/drm/imx/imx-tve.c ++++ b/drivers/gpu/drm/imx/imx-tve.c +@@ -237,8 +237,9 @@ static int imx_tve_connector_get_modes(struct drm_connector *connector) + return ret; + } + +-static int imx_tve_connector_mode_valid(struct drm_connector *connector, +- struct drm_display_mode *mode) ++static enum drm_mode_status ++imx_tve_connector_mode_valid(struct drm_connector *connector, ++ struct drm_display_mode *mode) + { + struct imx_tve *tve = con_to_tve(connector); + unsigned long rate; +diff --git a/drivers/gpu/drm/vc4/vc4_drv.c b/drivers/gpu/drm/vc4/vc4_drv.c +index 0d78ba017a29b..36688a56c91c5 100644 +--- a/drivers/gpu/drm/vc4/vc4_drv.c ++++ b/drivers/gpu/drm/vc4/vc4_drv.c +@@ -392,7 +392,12 @@ static int __init vc4_drm_register(void) + if (ret) + return ret; + +- return platform_driver_register(&vc4_platform_driver); ++ ret = platform_driver_register(&vc4_platform_driver); ++ if (ret) ++ platform_unregister_drivers(component_drivers, ++ ARRAY_SIZE(component_drivers)); ++ ++ return ret; + } + + static void __exit vc4_drm_unregister(void) +diff --git a/drivers/hid/hid-hyperv.c b/drivers/hid/hid-hyperv.c +index 79a28fc915216..5928e934d7343 100644 +--- a/drivers/hid/hid-hyperv.c ++++ b/drivers/hid/hid-hyperv.c +@@ -492,7 +492,7 @@ static int mousevsc_probe(struct hv_device *device, + + ret = hid_add_device(hid_dev); + if (ret) +- goto probe_err1; ++ goto probe_err2; + + + ret = hid_parse(hid_dev); +diff --git a/drivers/i2c/busses/i2c-i801.c b/drivers/i2c/busses/i2c-i801.c +index 4e6d0b722ddcd..2b84db59ab3ce 100644 +--- a/drivers/i2c/busses/i2c-i801.c ++++ b/drivers/i2c/busses/i2c-i801.c +@@ -1253,6 +1253,7 @@ static const struct { + * Additional individual entries were added after verification. + */ + { "Vostro V131", 0x1d }, ++ { "Vostro 5568", 0x29 }, + }; + + static void register_dell_lis3lv02d_i2c_device(struct i801_priv *priv) +diff --git a/drivers/iio/adc/at91_adc.c b/drivers/iio/adc/at91_adc.c +index abe99856c823a..cc81b35ca47a2 100644 +--- a/drivers/iio/adc/at91_adc.c ++++ b/drivers/iio/adc/at91_adc.c +@@ -616,8 +616,10 @@ static struct iio_trigger *at91_adc_allocate_trigger(struct iio_dev *idev, + trig->ops = &at91_adc_trigger_ops; + + ret = iio_trigger_register(trig); +- if (ret) ++ if (ret) { ++ iio_trigger_free(trig); + return NULL; ++ } + + return trig; + } +diff --git a/drivers/iio/pressure/ms5611_spi.c b/drivers/iio/pressure/ms5611_spi.c +index b463eaa799ab4..c3854594cd268 100644 +--- a/drivers/iio/pressure/ms5611_spi.c ++++ b/drivers/iio/pressure/ms5611_spi.c +@@ -92,7 +92,7 @@ static int ms5611_spi_probe(struct spi_device *spi) + spi_set_drvdata(spi, indio_dev); + + spi->mode = SPI_MODE_0; +- spi->max_speed_hz = 20000000; ++ spi->max_speed_hz = min(spi->max_speed_hz, 20000000U); + spi->bits_per_word = 8; + ret = spi_setup(spi); + if (ret < 0) +diff --git a/drivers/iio/trigger/iio-trig-sysfs.c b/drivers/iio/trigger/iio-trig-sysfs.c +index 2277d6336ac06..9ed5b9405ade0 100644 +--- a/drivers/iio/trigger/iio-trig-sysfs.c ++++ b/drivers/iio/trigger/iio-trig-sysfs.c +@@ -209,9 +209,13 @@ static int iio_sysfs_trigger_remove(int id) + + static int __init iio_sysfs_trig_init(void) + { ++ int ret; + device_initialize(&iio_sysfs_trig_dev); + dev_set_name(&iio_sysfs_trig_dev, "iio_sysfs_trigger"); +- return device_add(&iio_sysfs_trig_dev); ++ ret = device_add(&iio_sysfs_trig_dev); ++ if (ret) ++ put_device(&iio_sysfs_trig_dev); ++ return ret; + } + module_init(iio_sysfs_trig_init); + +diff --git a/drivers/input/joystick/iforce/iforce-main.c b/drivers/input/joystick/iforce/iforce-main.c +index b86de1312512b..84b87526b7ba3 100644 +--- a/drivers/input/joystick/iforce/iforce-main.c ++++ b/drivers/input/joystick/iforce/iforce-main.c +@@ -273,22 +273,22 @@ int iforce_init_device(struct device *parent, u16 bustype, + * Get device info. + */ + +- if (!iforce_get_id_packet(iforce, 'M', buf, &len) || len < 3) ++ if (!iforce_get_id_packet(iforce, 'M', buf, &len) && len >= 3) + input_dev->id.vendor = get_unaligned_le16(buf + 1); + else + dev_warn(&iforce->dev->dev, "Device does not respond to id packet M\n"); + +- if (!iforce_get_id_packet(iforce, 'P', buf, &len) || len < 3) ++ if (!iforce_get_id_packet(iforce, 'P', buf, &len) && len >= 3) + input_dev->id.product = get_unaligned_le16(buf + 1); + else + dev_warn(&iforce->dev->dev, "Device does not respond to id packet P\n"); + +- if (!iforce_get_id_packet(iforce, 'B', buf, &len) || len < 3) ++ if (!iforce_get_id_packet(iforce, 'B', buf, &len) && len >= 3) + iforce->device_memory.end = get_unaligned_le16(buf + 1); + else + dev_warn(&iforce->dev->dev, "Device does not respond to id packet B\n"); + +- if (!iforce_get_id_packet(iforce, 'N', buf, &len) || len < 2) ++ if (!iforce_get_id_packet(iforce, 'N', buf, &len) && len >= 2) + ff_effects = buf[1]; + else + dev_warn(&iforce->dev->dev, "Device does not respond to id packet N\n"); +diff --git a/drivers/input/serio/i8042.c b/drivers/input/serio/i8042.c +index bb76ff2f6b1d8..dc40f6099dcfd 100644 +--- a/drivers/input/serio/i8042.c ++++ b/drivers/input/serio/i8042.c +@@ -1540,8 +1540,6 @@ static int i8042_probe(struct platform_device *dev) + { + int error; + +- i8042_platform_device = dev; +- + if (i8042_reset == I8042_RESET_ALWAYS) { + error = i8042_controller_selftest(); + if (error) +@@ -1579,7 +1577,6 @@ static int i8042_probe(struct platform_device *dev) + i8042_free_aux_ports(); /* in case KBD failed but AUX not */ + i8042_free_irqs(); + i8042_controller_reset(false); +- i8042_platform_device = NULL; + + return error; + } +@@ -1589,7 +1586,6 @@ static int i8042_remove(struct platform_device *dev) + i8042_unregister_ports(); + i8042_free_irqs(); + i8042_controller_reset(false); +- i8042_platform_device = NULL; + + return 0; + } +diff --git a/drivers/isdn/mISDN/core.c b/drivers/isdn/mISDN/core.c +index 7ea0100f218a0..90ee56d07a6e9 100644 +--- a/drivers/isdn/mISDN/core.c ++++ b/drivers/isdn/mISDN/core.c +@@ -222,7 +222,7 @@ mISDN_register_device(struct mISDNdevice *dev, + + err = get_free_devid(); + if (err < 0) +- goto error1; ++ return err; + dev->id = err; + + device_initialize(&dev->dev); +diff --git a/drivers/isdn/mISDN/dsp_pipeline.c b/drivers/isdn/mISDN/dsp_pipeline.c +index 40588692cec74..cd9bc11e8dfb2 100644 +--- a/drivers/isdn/mISDN/dsp_pipeline.c ++++ b/drivers/isdn/mISDN/dsp_pipeline.c +@@ -80,6 +80,7 @@ int mISDN_dsp_element_register(struct mISDN_dsp_element *elem) + if (!entry) + return -ENOMEM; + ++ INIT_LIST_HEAD(&entry->list); + entry->elem = elem; + + entry->dev.class = elements_class; +@@ -114,7 +115,7 @@ err2: + device_unregister(&entry->dev); + return ret; + err1: +- kfree(entry); ++ put_device(&entry->dev); + return ret; + } + EXPORT_SYMBOL(mISDN_dsp_element_register); +diff --git a/drivers/md/dm-ioctl.c b/drivers/md/dm-ioctl.c +index 7a73f2fa0ad72..bcb282f110531 100644 +--- a/drivers/md/dm-ioctl.c ++++ b/drivers/md/dm-ioctl.c +@@ -573,7 +573,7 @@ static void list_version_get_needed(struct target_type *tt, void *needed_param) + size_t *needed = needed_param; + + *needed += sizeof(struct dm_target_versions); +- *needed += strlen(tt->name); ++ *needed += strlen(tt->name) + 1; + *needed += ALIGN_MASK; + } + +@@ -638,7 +638,7 @@ static int __list_versions(struct dm_ioctl *param, size_t param_size, const char + iter_info.old_vers = NULL; + iter_info.vers = vers; + iter_info.flags = 0; +- iter_info.end = (char *)vers+len; ++ iter_info.end = (char *)vers + needed; + + /* + * Now loop through filling out the names & versions. +diff --git a/drivers/misc/vmw_vmci/vmci_queue_pair.c b/drivers/misc/vmw_vmci/vmci_queue_pair.c +index a49782dd903cd..d4d388f021ccd 100644 +--- a/drivers/misc/vmw_vmci/vmci_queue_pair.c ++++ b/drivers/misc/vmw_vmci/vmci_queue_pair.c +@@ -852,6 +852,7 @@ static int qp_notify_peer_local(bool attach, struct vmci_handle handle) + u32 context_id = vmci_get_context_id(); + struct vmci_event_qp ev; + ++ memset(&ev, 0, sizeof(ev)); + ev.msg.hdr.dst = vmci_make_handle(context_id, VMCI_EVENT_HANDLER); + ev.msg.hdr.src = vmci_make_handle(VMCI_HYPERVISOR_CONTEXT_ID, + VMCI_CONTEXT_RESOURCE_ID); +@@ -1465,6 +1466,7 @@ static int qp_notify_peer(bool attach, + * kernel. + */ + ++ memset(&ev, 0, sizeof(ev)); + ev.msg.hdr.dst = vmci_make_handle(peer_id, VMCI_EVENT_HANDLER); + ev.msg.hdr.src = vmci_make_handle(VMCI_HYPERVISOR_CONTEXT_ID, + VMCI_CONTEXT_RESOURCE_ID); +diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c +index d7bda1fa0a6e2..5ff4f179204a4 100644 +--- a/drivers/mmc/core/core.c ++++ b/drivers/mmc/core/core.c +@@ -1145,7 +1145,13 @@ u32 mmc_select_voltage(struct mmc_host *host, u32 ocr) + mmc_power_cycle(host, ocr); + } else { + bit = fls(ocr) - 1; +- ocr &= 3 << bit; ++ /* ++ * The bit variable represents the highest voltage bit set in ++ * the OCR register. ++ * To keep a range of 2 values (e.g. 3.2V/3.3V and 3.3V/3.4V), ++ * we must shift the mask '3' with (bit - 1). ++ */ ++ ocr &= 3 << (bit - 1); + if (bit != host->ios.vdd) + dev_warn(mmc_dev(host), "exceeding card's volts\n"); + } +diff --git a/drivers/mmc/host/sdhci-cqhci.h b/drivers/mmc/host/sdhci-cqhci.h +new file mode 100644 +index 0000000000000..cf8e7ba71bbd7 +--- /dev/null ++++ b/drivers/mmc/host/sdhci-cqhci.h +@@ -0,0 +1,24 @@ ++/* SPDX-License-Identifier: GPL-2.0-only */ ++/* ++ * Copyright 2022 The Chromium OS Authors ++ * ++ * Support that applies to the combination of SDHCI and CQHCI, while not ++ * expressing a dependency between the two modules. ++ */ ++ ++#ifndef __MMC_HOST_SDHCI_CQHCI_H__ ++#define __MMC_HOST_SDHCI_CQHCI_H__ ++ ++#include "cqhci.h" ++#include "sdhci.h" ++ ++static inline void sdhci_and_cqhci_reset(struct sdhci_host *host, u8 mask) ++{ ++ if ((host->mmc->caps2 & MMC_CAP2_CQE) && (mask & SDHCI_RESET_ALL) && ++ host->mmc->cqe_private) ++ cqhci_deactivate(host->mmc); ++ ++ sdhci_reset(host, mask); ++} ++ ++#endif /* __MMC_HOST_SDHCI_CQHCI_H__ */ +diff --git a/drivers/mmc/host/sdhci-of-arasan.c b/drivers/mmc/host/sdhci-of-arasan.c +index dd10f7abf5a71..aa2467495404f 100644 +--- a/drivers/mmc/host/sdhci-of-arasan.c ++++ b/drivers/mmc/host/sdhci-of-arasan.c +@@ -24,6 +24,7 @@ + #include <linux/of.h> + + #include "cqhci.h" ++#include "sdhci-cqhci.h" + #include "sdhci-pltfm.h" + + #define SDHCI_ARASAN_VENDOR_REGISTER 0x78 +@@ -264,7 +265,7 @@ static void sdhci_arasan_reset(struct sdhci_host *host, u8 mask) + struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); + struct sdhci_arasan_data *sdhci_arasan = sdhci_pltfm_priv(pltfm_host); + +- sdhci_reset(host, mask); ++ sdhci_and_cqhci_reset(host, mask); + + if (sdhci_arasan->quirks & SDHCI_ARASAN_QUIRK_FORCE_CDTEST) { + ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL); +diff --git a/drivers/mmc/host/sdhci-pci-core.c b/drivers/mmc/host/sdhci-pci-core.c +index 1e19c0d0bca80..892c10950c81e 100644 +--- a/drivers/mmc/host/sdhci-pci-core.c ++++ b/drivers/mmc/host/sdhci-pci-core.c +@@ -1795,6 +1795,8 @@ static int amd_probe(struct sdhci_pci_chip *chip) + } + } + ++ pci_dev_put(smbus_dev); ++ + if (gen == AMD_CHIPSET_BEFORE_ML || gen == AMD_CHIPSET_CZ) + chip->quirks2 |= SDHCI_QUIRK2_CLEAR_TRANSFERMODE_REG_BEFORE_CMD; + +diff --git a/drivers/mmc/host/sdhci-pci-o2micro.c b/drivers/mmc/host/sdhci-pci-o2micro.c +index 3170c19683c49..4b639e819e03a 100644 +--- a/drivers/mmc/host/sdhci-pci-o2micro.c ++++ b/drivers/mmc/host/sdhci-pci-o2micro.c +@@ -31,6 +31,7 @@ + #define O2_SD_CAPS 0xE0 + #define O2_SD_ADMA1 0xE2 + #define O2_SD_ADMA2 0xE7 ++#define O2_SD_MISC_CTRL2 0xF0 + #define O2_SD_INF_MOD 0xF1 + #define O2_SD_MISC_CTRL4 0xFC + #define O2_SD_TUNING_CTRL 0x300 +@@ -777,6 +778,12 @@ int sdhci_pci_o2_probe(struct sdhci_pci_chip *chip) + /* Set Tuning Windows to 5 */ + pci_write_config_byte(chip->pdev, + O2_SD_TUNING_CTRL, 0x55); ++ //Adjust 1st and 2nd CD debounce time ++ pci_read_config_dword(chip->pdev, O2_SD_MISC_CTRL2, &scratch_32); ++ scratch_32 &= 0xFFE7FFFF; ++ scratch_32 |= 0x00180000; ++ pci_write_config_dword(chip->pdev, O2_SD_MISC_CTRL2, scratch_32); ++ pci_write_config_dword(chip->pdev, O2_SD_DETECT_SETTING, 1); + /* Lock WP */ + ret = pci_read_config_byte(chip->pdev, + O2_SD_LOCK_WP, &scratch); +diff --git a/drivers/mmc/host/sdhci-tegra.c b/drivers/mmc/host/sdhci-tegra.c +index 65dfe75120ed6..d58383767a6eb 100644 +--- a/drivers/mmc/host/sdhci-tegra.c ++++ b/drivers/mmc/host/sdhci-tegra.c +@@ -24,6 +24,7 @@ + #include <linux/gpio/consumer.h> + #include <linux/ktime.h> + ++#include "sdhci-cqhci.h" + #include "sdhci-pltfm.h" + #include "cqhci.h" + +@@ -347,7 +348,7 @@ static void tegra_sdhci_reset(struct sdhci_host *host, u8 mask) + const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data; + u32 misc_ctrl, clk_ctrl, pad_ctrl; + +- sdhci_reset(host, mask); ++ sdhci_and_cqhci_reset(host, mask); + + if (!(mask & SDHCI_RESET_ALL)) + return; +diff --git a/drivers/mtd/spi-nor/intel-spi.c b/drivers/mtd/spi-nor/intel-spi.c +index 43e55a2e9b271..21b98c82e1960 100644 +--- a/drivers/mtd/spi-nor/intel-spi.c ++++ b/drivers/mtd/spi-nor/intel-spi.c +@@ -113,7 +113,7 @@ + #define ERASE_OPCODE_SHIFT 8 + #define ERASE_OPCODE_MASK (0xff << ERASE_OPCODE_SHIFT) + #define ERASE_64K_OPCODE_SHIFT 16 +-#define ERASE_64K_OPCODE_MASK (0xff << ERASE_OPCODE_SHIFT) ++#define ERASE_64K_OPCODE_MASK (0xff << ERASE_64K_OPCODE_SHIFT) + + #define INTEL_SPI_TIMEOUT 5000 /* ms */ + #define INTEL_SPI_FIFO_SZ 64 +diff --git a/drivers/net/ethernet/apm/xgene/xgene_enet_main.c b/drivers/net/ethernet/apm/xgene/xgene_enet_main.c +index ce4e617a6ec49..29fcc4deb4dad 100644 +--- a/drivers/net/ethernet/apm/xgene/xgene_enet_main.c ++++ b/drivers/net/ethernet/apm/xgene/xgene_enet_main.c +@@ -1004,8 +1004,10 @@ static int xgene_enet_open(struct net_device *ndev) + + xgene_enet_napi_enable(pdata); + ret = xgene_enet_register_irq(ndev); +- if (ret) ++ if (ret) { ++ xgene_enet_napi_disable(pdata); + return ret; ++ } + + if (ndev->phydev) { + phy_start(ndev->phydev); +diff --git a/drivers/net/ethernet/broadcom/bgmac.c b/drivers/net/ethernet/broadcom/bgmac.c +index 979af8e878e3a..193722334d931 100644 +--- a/drivers/net/ethernet/broadcom/bgmac.c ++++ b/drivers/net/ethernet/broadcom/bgmac.c +@@ -1564,7 +1564,6 @@ void bgmac_enet_remove(struct bgmac *bgmac) + phy_disconnect(bgmac->net_dev->phydev); + netif_napi_del(&bgmac->napi); + bgmac_dma_free(bgmac); +- free_netdev(bgmac->net_dev); + } + EXPORT_SYMBOL_GPL(bgmac_enet_remove); + +diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.c b/drivers/net/ethernet/broadcom/bnxt/bnxt.c +index 5a7d5e7f3b238..3636849f63656 100644 +--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.c ++++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.c +@@ -11182,8 +11182,8 @@ static int bnxt_rx_flow_steer(struct net_device *dev, const struct sk_buff *skb, + rcu_read_lock(); + hlist_for_each_entry_rcu(fltr, head, hash) { + if (bnxt_fltr_match(fltr, new_fltr)) { ++ rc = fltr->sw_id; + rcu_read_unlock(); +- rc = 0; + goto err_free; + } + } +@@ -12232,8 +12232,16 @@ static struct pci_driver bnxt_pci_driver = { + + static int __init bnxt_init(void) + { ++ int err; ++ + bnxt_debug_init(); +- return pci_register_driver(&bnxt_pci_driver); ++ err = pci_register_driver(&bnxt_pci_driver); ++ if (err) { ++ bnxt_debug_exit(); ++ return err; ++ } ++ ++ return 0; + } + + static void __exit bnxt_exit(void) +diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c b/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c +index d74c6a34b936a..24282a4264816 100644 +--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c ++++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c +@@ -124,7 +124,7 @@ static int bnxt_set_coalesce(struct net_device *dev, + } + + reset_coalesce: +- if (netif_running(dev)) { ++ if (test_bit(BNXT_STATE_OPEN, &bp->state)) { + if (update_stats) { + rc = bnxt_close_nic(bp, true, false); + if (!rc) +diff --git a/drivers/net/ethernet/cavium/liquidio/lio_main.c b/drivers/net/ethernet/cavium/liquidio/lio_main.c +index d0c77ff9dbb11..69878589213a0 100644 +--- a/drivers/net/ethernet/cavium/liquidio/lio_main.c ++++ b/drivers/net/ethernet/cavium/liquidio/lio_main.c +@@ -1836,13 +1836,10 @@ static int liquidio_open(struct net_device *netdev) + + ifstate_set(lio, LIO_IFSTATE_RUNNING); + +- if (OCTEON_CN23XX_PF(oct)) { +- if (!oct->msix_on) +- if (setup_tx_poll_fn(netdev)) +- return -1; +- } else { +- if (setup_tx_poll_fn(netdev)) +- return -1; ++ if (!OCTEON_CN23XX_PF(oct) || (OCTEON_CN23XX_PF(oct) && !oct->msix_on)) { ++ ret = setup_tx_poll_fn(netdev); ++ if (ret) ++ goto err_poll; + } + + netif_tx_start_all_queues(netdev); +@@ -1855,7 +1852,7 @@ static int liquidio_open(struct net_device *netdev) + /* tell Octeon to start forwarding packets to host */ + ret = send_rx_ctrl_cmd(lio, 1); + if (ret) +- return ret; ++ goto err_rx_ctrl; + + /* start periodical statistics fetch */ + INIT_DELAYED_WORK(&lio->stats_wk.work, lio_fetch_stats); +@@ -1866,6 +1863,27 @@ static int liquidio_open(struct net_device *netdev) + dev_info(&oct->pci_dev->dev, "%s interface is opened\n", + netdev->name); + ++ return 0; ++ ++err_rx_ctrl: ++ if (!OCTEON_CN23XX_PF(oct) || (OCTEON_CN23XX_PF(oct) && !oct->msix_on)) ++ cleanup_tx_poll_fn(netdev); ++err_poll: ++ if (lio->ptp_clock) { ++ ptp_clock_unregister(lio->ptp_clock); ++ lio->ptp_clock = NULL; ++ } ++ ++ if (oct->props[lio->ifidx].napi_enabled == 1) { ++ list_for_each_entry_safe(napi, n, &netdev->napi_list, dev_list) ++ napi_disable(napi); ++ ++ oct->props[lio->ifidx].napi_enabled = 0; ++ ++ if (OCTEON_CN23XX_PF(oct)) ++ oct->droq[0]->ops.poll_mode = 0; ++ } ++ + return ret; + } + +diff --git a/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c b/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c +index 97ff8608f0ab2..b0fd22cbeef4e 100644 +--- a/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c ++++ b/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c +@@ -1303,6 +1303,7 @@ static int cxgb_up(struct adapter *adap) + if (ret < 0) { + CH_ERR(adap, "failed to bind qsets, err %d\n", ret); + t3_intr_disable(adap); ++ quiesce_rx(adap); + free_irq_resources(adap); + err = ret; + goto out; +diff --git a/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c b/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c +index f4d41f968afa2..97963d9a6d16d 100644 +--- a/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c ++++ b/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c +@@ -860,7 +860,7 @@ static int cxgb4vf_open(struct net_device *dev) + */ + err = t4vf_update_port_info(pi); + if (err < 0) +- return err; ++ goto err_unwind; + + /* + * Note that this interface is up and start everything up ... +diff --git a/drivers/net/ethernet/freescale/fman/mac.c b/drivers/net/ethernet/freescale/fman/mac.c +index 147126e79986c..8e2a243aa1021 100644 +--- a/drivers/net/ethernet/freescale/fman/mac.c ++++ b/drivers/net/ethernet/freescale/fman/mac.c +@@ -885,12 +885,21 @@ _return: + return err; + } + ++static int mac_remove(struct platform_device *pdev) ++{ ++ struct mac_device *mac_dev = platform_get_drvdata(pdev); ++ ++ platform_device_unregister(mac_dev->priv->eth_dev); ++ return 0; ++} ++ + static struct platform_driver mac_driver = { + .driver = { + .name = KBUILD_MODNAME, + .of_match_table = mac_match, + }, + .probe = mac_probe, ++ .remove = mac_remove, + }; + + builtin_platform_driver(mac_driver); +diff --git a/drivers/net/ethernet/marvell/mv643xx_eth.c b/drivers/net/ethernet/marvell/mv643xx_eth.c +index 82ea55ae5053d..10e5c4c596579 100644 +--- a/drivers/net/ethernet/marvell/mv643xx_eth.c ++++ b/drivers/net/ethernet/marvell/mv643xx_eth.c +@@ -2476,6 +2476,7 @@ out_free: + for (i = 0; i < mp->rxq_count; i++) + rxq_deinit(mp->rxq + i); + out: ++ napi_disable(&mp->napi); + free_irq(dev->irq, dev); + + return err; +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/cmd.c b/drivers/net/ethernet/mellanox/mlx5/core/cmd.c +index 4fdc97304f69a..e00a8eb7716fc 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/cmd.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/cmd.c +@@ -1682,12 +1682,17 @@ void mlx5_cmd_flush(struct mlx5_core_dev *dev) + struct mlx5_cmd *cmd = &dev->cmd; + int i; + +- for (i = 0; i < cmd->max_reg_cmds; i++) +- while (down_trylock(&cmd->sem)) ++ for (i = 0; i < cmd->max_reg_cmds; i++) { ++ while (down_trylock(&cmd->sem)) { + mlx5_cmd_trigger_completions(dev); ++ cond_resched(); ++ } ++ } + +- while (down_trylock(&cmd->pages_sem)) ++ while (down_trylock(&cmd->pages_sem)) { + mlx5_cmd_trigger_completions(dev); ++ cond_resched(); ++ } + + /* Unlock cmdif */ + up(&cmd->pages_sem); +diff --git a/drivers/net/ethernet/neterion/s2io.c b/drivers/net/ethernet/neterion/s2io.c +index 71ab4e9c9a171..69316ddcf067f 100644 +--- a/drivers/net/ethernet/neterion/s2io.c ++++ b/drivers/net/ethernet/neterion/s2io.c +@@ -7122,9 +7122,8 @@ static int s2io_card_up(struct s2io_nic *sp) + if (ret) { + DBG_PRINT(ERR_DBG, "%s: Out of memory in Open\n", + dev->name); +- s2io_reset(sp); +- free_rx_buffers(sp); +- return -ENOMEM; ++ ret = -ENOMEM; ++ goto err_fill_buff; + } + DBG_PRINT(INFO_DBG, "Buf in ring:%d is %d:\n", i, + ring->rx_bufs_left); +@@ -7162,18 +7161,16 @@ static int s2io_card_up(struct s2io_nic *sp) + /* Enable Rx Traffic and interrupts on the NIC */ + if (start_nic(sp)) { + DBG_PRINT(ERR_DBG, "%s: Starting NIC failed\n", dev->name); +- s2io_reset(sp); +- free_rx_buffers(sp); +- return -ENODEV; ++ ret = -ENODEV; ++ goto err_out; + } + + /* Add interrupt service routine */ + if (s2io_add_isr(sp) != 0) { + if (sp->config.intr_type == MSI_X) + s2io_rem_isr(sp); +- s2io_reset(sp); +- free_rx_buffers(sp); +- return -ENODEV; ++ ret = -ENODEV; ++ goto err_out; + } + + timer_setup(&sp->alarm_timer, s2io_alarm_handle, 0); +@@ -7193,6 +7190,20 @@ static int s2io_card_up(struct s2io_nic *sp) + } + + return 0; ++ ++err_out: ++ if (config->napi) { ++ if (config->intr_type == MSI_X) { ++ for (i = 0; i < sp->config.rx_ring_num; i++) ++ napi_disable(&sp->mac_control.rings[i].napi); ++ } else { ++ napi_disable(&sp->napi); ++ } ++ } ++err_fill_buff: ++ s2io_reset(sp); ++ free_rx_buffers(sp); ++ return ret; + } + + /** +diff --git a/drivers/net/ethernet/ni/nixge.c b/drivers/net/ethernet/ni/nixge.c +index 56f285985b432..ffd44edfffbf3 100644 +--- a/drivers/net/ethernet/ni/nixge.c ++++ b/drivers/net/ethernet/ni/nixge.c +@@ -899,6 +899,7 @@ static int nixge_open(struct net_device *ndev) + err_rx_irq: + free_irq(priv->tx_irq, ndev); + err_tx_irq: ++ napi_disable(&priv->napi); + phy_stop(phy); + phy_disconnect(phy); + tasklet_kill(&priv->dma_err_tasklet); +diff --git a/drivers/net/ethernet/ti/cpsw.c b/drivers/net/ethernet/ti/cpsw.c +index 33eca554424a5..774a72db7c969 100644 +--- a/drivers/net/ethernet/ti/cpsw.c ++++ b/drivers/net/ethernet/ti/cpsw.c +@@ -1753,6 +1753,8 @@ static int cpsw_ndo_open(struct net_device *ndev) + + err_cleanup: + if (!cpsw->usage_count) { ++ napi_disable(&cpsw->napi_rx); ++ napi_disable(&cpsw->napi_tx); + cpdma_ctlr_stop(cpsw->dma); + cpsw_destroy_xdp_rxqs(cpsw); + } +diff --git a/drivers/net/ethernet/tundra/tsi108_eth.c b/drivers/net/ethernet/tundra/tsi108_eth.c +index c62f474b6d08e..fcebd2418dbd3 100644 +--- a/drivers/net/ethernet/tundra/tsi108_eth.c ++++ b/drivers/net/ethernet/tundra/tsi108_eth.c +@@ -1302,12 +1302,15 @@ static int tsi108_open(struct net_device *dev) + + data->rxring = dma_alloc_coherent(&data->pdev->dev, rxring_size, + &data->rxdma, GFP_KERNEL); +- if (!data->rxring) ++ if (!data->rxring) { ++ free_irq(data->irq_num, dev); + return -ENOMEM; ++ } + + data->txring = dma_alloc_coherent(&data->pdev->dev, txring_size, + &data->txdma, GFP_KERNEL); + if (!data->txring) { ++ free_irq(data->irq_num, dev); + dma_free_coherent(&data->pdev->dev, rxring_size, data->rxring, + data->rxdma); + return -ENOMEM; +diff --git a/drivers/net/hamradio/bpqether.c b/drivers/net/hamradio/bpqether.c +index e2ad3c2e8df5e..e0b9823170bfb 100644 +--- a/drivers/net/hamradio/bpqether.c ++++ b/drivers/net/hamradio/bpqether.c +@@ -511,7 +511,7 @@ static int bpq_device_event(struct notifier_block *this, + if (!net_eq(dev_net(dev), &init_net)) + return NOTIFY_DONE; + +- if (!dev_is_ethdev(dev)) ++ if (!dev_is_ethdev(dev) && !bpq_get_ax25_dev(dev)) + return NOTIFY_DONE; + + switch (event) { +diff --git a/drivers/net/macvlan.c b/drivers/net/macvlan.c +index 07622cf8765ae..545d181453504 100644 +--- a/drivers/net/macvlan.c ++++ b/drivers/net/macvlan.c +@@ -138,7 +138,7 @@ static struct macvlan_source_entry *macvlan_hash_lookup_source( + u32 idx = macvlan_eth_hash(addr); + struct hlist_head *h = &vlan->port->vlan_source_hash[idx]; + +- hlist_for_each_entry_rcu(entry, h, hlist) { ++ hlist_for_each_entry_rcu(entry, h, hlist, lockdep_rtnl_is_held()) { + if (ether_addr_equal_64bits(entry->addr, addr) && + entry->vlan == vlan) + return entry; +@@ -1166,7 +1166,7 @@ void macvlan_common_setup(struct net_device *dev) + { + ether_setup(dev); + +- dev->min_mtu = 0; ++ /* ether_setup() has set dev->min_mtu to ETH_MIN_MTU. */ + dev->max_mtu = ETH_MAX_MTU; + dev->priv_flags &= ~IFF_TX_SKB_SHARING; + netif_keep_dst(dev); +@@ -1499,8 +1499,10 @@ destroy_macvlan_port: + /* the macvlan port may be freed by macvlan_uninit when fail to register. + * so we destroy the macvlan port only when it's valid. + */ +- if (create && macvlan_port_get_rtnl(lowerdev)) ++ if (create && macvlan_port_get_rtnl(lowerdev)) { ++ macvlan_flush_sources(port, vlan); + macvlan_port_destroy(port->dev); ++ } + return err; + } + EXPORT_SYMBOL_GPL(macvlan_common_newlink); +@@ -1602,7 +1604,7 @@ static int macvlan_fill_info_macaddr(struct sk_buff *skb, + struct hlist_head *h = &vlan->port->vlan_source_hash[i]; + struct macvlan_source_entry *entry; + +- hlist_for_each_entry_rcu(entry, h, hlist) { ++ hlist_for_each_entry_rcu(entry, h, hlist, lockdep_rtnl_is_held()) { + if (entry->vlan != vlan) + continue; + if (nla_put(skb, IFLA_MACVLAN_MACADDR, ETH_ALEN, entry->addr)) +diff --git a/drivers/net/thunderbolt.c b/drivers/net/thunderbolt.c +index dacb4f680fd48..ce7f0f604a5ea 100644 +--- a/drivers/net/thunderbolt.c ++++ b/drivers/net/thunderbolt.c +@@ -1339,12 +1339,21 @@ static int __init tbnet_init(void) + TBNET_MATCH_FRAGS_ID); + + ret = tb_register_property_dir("network", tbnet_dir); +- if (ret) { +- tb_property_free_dir(tbnet_dir); +- return ret; +- } ++ if (ret) ++ goto err_free_dir; ++ ++ ret = tb_register_service_driver(&tbnet_driver); ++ if (ret) ++ goto err_unregister; + +- return tb_register_service_driver(&tbnet_driver); ++ return 0; ++ ++err_unregister: ++ tb_unregister_property_dir("network", tbnet_dir); ++err_free_dir: ++ tb_property_free_dir(tbnet_dir); ++ ++ return ret; + } + module_init(tbnet_init); + +diff --git a/drivers/net/tun.c b/drivers/net/tun.c +index 22a46a1382bae..f01db73dab05d 100644 +--- a/drivers/net/tun.c ++++ b/drivers/net/tun.c +@@ -2002,17 +2002,25 @@ drop: + skb_headlen(skb)); + + if (unlikely(headlen > skb_headlen(skb))) { ++ WARN_ON_ONCE(1); ++ err = -ENOMEM; + this_cpu_inc(tun->pcpu_stats->rx_dropped); ++napi_busy: + napi_free_frags(&tfile->napi); + rcu_read_unlock(); + mutex_unlock(&tfile->napi_mutex); +- WARN_ON(1); +- return -ENOMEM; ++ return err; + } + +- local_bh_disable(); +- napi_gro_frags(&tfile->napi); +- local_bh_enable(); ++ if (likely(napi_schedule_prep(&tfile->napi))) { ++ local_bh_disable(); ++ napi_gro_frags(&tfile->napi); ++ napi_complete(&tfile->napi); ++ local_bh_enable(); ++ } else { ++ err = -EBUSY; ++ goto napi_busy; ++ } + mutex_unlock(&tfile->napi_mutex); + } else if (tfile->napi_enabled) { + struct sk_buff_head *queue = &tfile->sk.sk_write_queue; +diff --git a/drivers/net/wan/lapbether.c b/drivers/net/wan/lapbether.c +index 4e42954d8cbf0..bbcd8ef2873f6 100644 +--- a/drivers/net/wan/lapbether.c ++++ b/drivers/net/wan/lapbether.c +@@ -403,7 +403,7 @@ static int lapbeth_device_event(struct notifier_block *this, + if (dev_net(dev) != &init_net) + return NOTIFY_DONE; + +- if (!dev_is_ethdev(dev)) ++ if (!dev_is_ethdev(dev) && !lapbeth_get_x25_dev(dev)) + return NOTIFY_DONE; + + switch (event) { +diff --git a/drivers/parport/parport_pc.c b/drivers/parport/parport_pc.c +index 1f17a39eabe8c..3bc0027b7844b 100644 +--- a/drivers/parport/parport_pc.c ++++ b/drivers/parport/parport_pc.c +@@ -475,7 +475,7 @@ static size_t parport_pc_fifo_write_block_pio(struct parport *port, + const unsigned char *bufp = buf; + size_t left = length; + unsigned long expire = jiffies + port->physport->cad->timeout; +- const int fifo = FIFO(port); ++ const unsigned long fifo = FIFO(port); + int poll_for = 8; /* 80 usecs */ + const struct parport_pc_private *priv = port->physport->private_data; + const int fifo_depth = priv->fifo_depth; +diff --git a/drivers/phy/st/phy-stm32-usbphyc.c b/drivers/phy/st/phy-stm32-usbphyc.c +index 56bdea4b0bd90..e643c21c12173 100644 +--- a/drivers/phy/st/phy-stm32-usbphyc.c ++++ b/drivers/phy/st/phy-stm32-usbphyc.c +@@ -393,6 +393,8 @@ static int stm32_usbphyc_probe(struct platform_device *pdev) + ret = of_property_read_u32(child, "reg", &index); + if (ret || index > usbphyc->nphys) { + dev_err(&phy->dev, "invalid reg property: %d\n", ret); ++ if (!ret) ++ ret = -EINVAL; + goto put_child; + } + +diff --git a/drivers/pinctrl/devicetree.c b/drivers/pinctrl/devicetree.c +index dbaacde1b36af..362d84c2ead44 100644 +--- a/drivers/pinctrl/devicetree.c ++++ b/drivers/pinctrl/devicetree.c +@@ -223,6 +223,8 @@ int pinctrl_dt_to_map(struct pinctrl *p, struct pinctrl_dev *pctldev) + for (state = 0; ; state++) { + /* Retrieve the pinctrl-* property */ + propname = kasprintf(GFP_KERNEL, "pinctrl-%d", state); ++ if (!propname) ++ return -ENOMEM; + prop = of_find_property(np, propname, &size); + kfree(propname); + if (!prop) { +diff --git a/drivers/platform/x86/hp-wmi.c b/drivers/platform/x86/hp-wmi.c +index c3fdb0ecad96e..a67773eca3acf 100644 +--- a/drivers/platform/x86/hp-wmi.c ++++ b/drivers/platform/x86/hp-wmi.c +@@ -880,8 +880,16 @@ static int __init hp_wmi_bios_setup(struct platform_device *device) + wwan_rfkill = NULL; + rfkill2_count = 0; + +- if (hp_wmi_rfkill_setup(device)) +- hp_wmi_rfkill2_setup(device); ++ /* ++ * In pre-2009 BIOS, command 1Bh return 0x4 to indicate that ++ * BIOS no longer controls the power for the wireless ++ * devices. All features supported by this command will no ++ * longer be supported. ++ */ ++ if (!hp_wmi_bios_2009_later()) { ++ if (hp_wmi_rfkill_setup(device)) ++ hp_wmi_rfkill2_setup(device); ++ } + + return 0; + } +diff --git a/drivers/platform/x86/intel_pmc_core_pltdrv.c b/drivers/platform/x86/intel_pmc_core_pltdrv.c +index e1266f5c63593..42ed02ab8a618 100644 +--- a/drivers/platform/x86/intel_pmc_core_pltdrv.c ++++ b/drivers/platform/x86/intel_pmc_core_pltdrv.c +@@ -18,6 +18,8 @@ + #include <asm/cpu_device_id.h> + #include <asm/intel-family.h> + ++#include <xen/xen.h> ++ + static void intel_pmc_core_release(struct device *dev) + { + /* Nothing to do. */ +@@ -56,6 +58,13 @@ static int __init pmc_core_platform_init(void) + if (acpi_dev_present("INT33A1", NULL, -1)) + return -ENODEV; + ++ /* ++ * Skip forcefully attaching the device for VMs. Make an exception for ++ * Xen dom0, which does have full hardware access. ++ */ ++ if (cpu_feature_enabled(X86_FEATURE_HYPERVISOR) && !xen_initial_domain()) ++ return -ENODEV; ++ + if (!x86_match_cpu(intel_pmc_core_platform_ids)) + return -ENODEV; + +diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c +index 67dac3931634e..3fddf851bddcb 100644 +--- a/drivers/s390/scsi/zfcp_fsf.c ++++ b/drivers/s390/scsi/zfcp_fsf.c +@@ -755,7 +755,7 @@ static int zfcp_fsf_req_send(struct zfcp_fsf_req *req) + const bool is_srb = zfcp_fsf_req_is_status_read_buffer(req); + struct zfcp_adapter *adapter = req->adapter; + struct zfcp_qdio *qdio = adapter->qdio; +- int req_id = req->req_id; ++ unsigned long req_id = req->req_id; + + zfcp_reqlist_add(adapter->req_list, req); + +diff --git a/drivers/siox/siox-core.c b/drivers/siox/siox-core.c +index f8c08fb9891d7..e0ffef6e93865 100644 +--- a/drivers/siox/siox-core.c ++++ b/drivers/siox/siox-core.c +@@ -835,6 +835,8 @@ static struct siox_device *siox_device_add(struct siox_master *smaster, + + err_device_register: + /* don't care to make the buffer smaller again */ ++ put_device(&sdevice->dev); ++ sdevice = NULL; + + err_buf_alloc: + siox_master_unlock(smaster); +diff --git a/drivers/slimbus/stream.c b/drivers/slimbus/stream.c +index 75f87b3d8b953..73a2aa3629572 100644 +--- a/drivers/slimbus/stream.c ++++ b/drivers/slimbus/stream.c +@@ -67,10 +67,10 @@ static const int slim_presence_rate_table[] = { + 384000, + 768000, + 0, /* Reserved */ +- 110250, +- 220500, +- 441000, +- 882000, ++ 11025, ++ 22050, ++ 44100, ++ 88200, + 176400, + 352800, + 705600, +diff --git a/drivers/spi/spi-stm32.c b/drivers/spi/spi-stm32.c +index 9ae16092206df..a1961a9738390 100644 +--- a/drivers/spi/spi-stm32.c ++++ b/drivers/spi/spi-stm32.c +@@ -937,6 +937,7 @@ static irqreturn_t stm32h7_spi_irq_thread(int irq, void *dev_id) + static DEFINE_RATELIMIT_STATE(rs, + DEFAULT_RATELIMIT_INTERVAL * 10, + 1); ++ ratelimit_set_flags(&rs, RATELIMIT_MSG_ON_RELEASE); + if (__ratelimit(&rs)) + dev_dbg_ratelimited(spi->dev, "Communication suspended\n"); + if (!spi->cur_usedma && (spi->rx_buf && (spi->rx_len > 0))) +diff --git a/drivers/staging/speakup/main.c b/drivers/staging/speakup/main.c +index 81ecfd1a200dd..11c3b47b8a22a 100644 +--- a/drivers/staging/speakup/main.c ++++ b/drivers/staging/speakup/main.c +@@ -1781,7 +1781,7 @@ static void speakup_con_update(struct vc_data *vc) + { + unsigned long flags; + +- if (!speakup_console[vc->vc_num] || spk_parked) ++ if (!speakup_console[vc->vc_num] || spk_parked || !synth) + return; + if (!spin_trylock_irqsave(&speakup_info.spinlock, flags)) + /* Speakup output, discard */ +diff --git a/drivers/target/loopback/tcm_loop.c b/drivers/target/loopback/tcm_loop.c +index 16d5a4e117a27..5ae5d94c5b931 100644 +--- a/drivers/target/loopback/tcm_loop.c ++++ b/drivers/target/loopback/tcm_loop.c +@@ -394,6 +394,7 @@ static int tcm_loop_setup_hba_bus(struct tcm_loop_hba *tl_hba, int tcm_loop_host + ret = device_register(&tl_hba->dev); + if (ret) { + pr_err("device_register() failed for tl_hba->dev: %d\n", ret); ++ put_device(&tl_hba->dev); + return -ENODEV; + } + +@@ -1072,7 +1073,7 @@ check_len: + */ + ret = tcm_loop_setup_hba_bus(tl_hba, tcm_loop_hba_no_cnt); + if (ret) +- goto out; ++ return ERR_PTR(ret); + + sh = tl_hba->sh; + tcm_loop_hba_no_cnt++; +diff --git a/drivers/tty/n_gsm.c b/drivers/tty/n_gsm.c +index 22da644530548..98c67ddf2fd90 100644 +--- a/drivers/tty/n_gsm.c ++++ b/drivers/tty/n_gsm.c +@@ -1413,7 +1413,7 @@ static struct gsm_control *gsm_control_send(struct gsm_mux *gsm, + unsigned int command, u8 *data, int clen) + { + struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control), +- GFP_KERNEL); ++ GFP_ATOMIC); + unsigned long flags; + if (ctrl == NULL) + return NULL; +diff --git a/drivers/tty/serial/8250/8250_lpss.c b/drivers/tty/serial/8250/8250_lpss.c +index 5f72ef3ea574b..406af8b1d87ee 100644 +--- a/drivers/tty/serial/8250/8250_lpss.c ++++ b/drivers/tty/serial/8250/8250_lpss.c +@@ -258,8 +258,13 @@ static int lpss8250_dma_setup(struct lpss8250 *lpss, struct uart_8250_port *port + struct dw_dma_slave *rx_param, *tx_param; + struct device *dev = port->port.dev; + +- if (!lpss->dma_param.dma_dev) ++ if (!lpss->dma_param.dma_dev) { ++ dma = port->dma; ++ if (dma) ++ goto out_configuration_only; ++ + return 0; ++ } + + rx_param = devm_kzalloc(dev, sizeof(*rx_param), GFP_KERNEL); + if (!rx_param) +@@ -270,16 +275,18 @@ static int lpss8250_dma_setup(struct lpss8250 *lpss, struct uart_8250_port *port + return -ENOMEM; + + *rx_param = lpss->dma_param; +- dma->rxconf.src_maxburst = lpss->dma_maxburst; +- + *tx_param = lpss->dma_param; +- dma->txconf.dst_maxburst = lpss->dma_maxburst; + + dma->fn = lpss8250_dma_filter; + dma->rx_param = rx_param; + dma->tx_param = tx_param; + + port->dma = dma; ++ ++out_configuration_only: ++ dma->rxconf.src_maxburst = lpss->dma_maxburst; ++ dma->txconf.dst_maxburst = lpss->dma_maxburst; ++ + return 0; + } + +diff --git a/drivers/tty/serial/8250/8250_omap.c b/drivers/tty/serial/8250/8250_omap.c +index efe793a2fc65d..3d6a159c87f44 100644 +--- a/drivers/tty/serial/8250/8250_omap.c ++++ b/drivers/tty/serial/8250/8250_omap.c +@@ -169,27 +169,10 @@ static void omap8250_set_mctrl(struct uart_port *port, unsigned int mctrl) + static void omap_8250_mdr1_errataset(struct uart_8250_port *up, + struct omap8250_priv *priv) + { +- u8 timeout = 255; +- + serial_out(up, UART_OMAP_MDR1, priv->mdr1); + udelay(2); + serial_out(up, UART_FCR, up->fcr | UART_FCR_CLEAR_XMIT | + UART_FCR_CLEAR_RCVR); +- /* +- * Wait for FIFO to empty: when empty, RX_FIFO_E bit is 0 and +- * TX_FIFO_E bit is 1. +- */ +- while (UART_LSR_THRE != (serial_in(up, UART_LSR) & +- (UART_LSR_THRE | UART_LSR_DR))) { +- timeout--; +- if (!timeout) { +- /* Should *never* happen. we warn and carry on */ +- dev_crit(up->port.dev, "Errata i202: timedout %x\n", +- serial_in(up, UART_LSR)); +- break; +- } +- udelay(1); +- } + } + + static void omap_8250_get_divisor(struct uart_port *port, unsigned int baud, +@@ -1290,9 +1273,15 @@ err: + static int omap8250_remove(struct platform_device *pdev) + { + struct omap8250_priv *priv = platform_get_drvdata(pdev); ++ int err; ++ ++ err = pm_runtime_resume_and_get(&pdev->dev); ++ if (err) ++ return err; + + pm_runtime_dont_use_autosuspend(&pdev->dev); + pm_runtime_put_sync(&pdev->dev); ++ flush_work(&priv->qos_work); + pm_runtime_disable(&pdev->dev); + serial8250_unregister_port(priv->line); + pm_qos_remove_request(&priv->pm_qos_request); +diff --git a/drivers/tty/serial/8250/8250_port.c b/drivers/tty/serial/8250/8250_port.c +index c1551319684f8..907130244e1f5 100644 +--- a/drivers/tty/serial/8250/8250_port.c ++++ b/drivers/tty/serial/8250/8250_port.c +@@ -1820,10 +1820,13 @@ EXPORT_SYMBOL_GPL(serial8250_modem_status); + static bool handle_rx_dma(struct uart_8250_port *up, unsigned int iir) + { + switch (iir & 0x3f) { ++ case UART_IIR_RDI: ++ if (!up->dma->rx_running) ++ break; ++ fallthrough; ++ case UART_IIR_RLSI: + case UART_IIR_RX_TIMEOUT: + serial8250_rx_dma_flush(up); +- /* fall-through */ +- case UART_IIR_RLSI: + return true; + } + return up->dma->rx_dma(up); +diff --git a/drivers/tty/serial/imx.c b/drivers/tty/serial/imx.c +index 8b41a783b37ee..3f5878e367c74 100644 +--- a/drivers/tty/serial/imx.c ++++ b/drivers/tty/serial/imx.c +@@ -2551,6 +2551,7 @@ static const struct dev_pm_ops imx_uart_pm_ops = { + .suspend_noirq = imx_uart_suspend_noirq, + .resume_noirq = imx_uart_resume_noirq, + .freeze_noirq = imx_uart_suspend_noirq, ++ .thaw_noirq = imx_uart_resume_noirq, + .restore_noirq = imx_uart_resume_noirq, + .suspend = imx_uart_suspend, + .resume = imx_uart_resume, +diff --git a/drivers/usb/chipidea/otg_fsm.c b/drivers/usb/chipidea/otg_fsm.c +index 6ed4b00dba961..7a2a9559693fb 100644 +--- a/drivers/usb/chipidea/otg_fsm.c ++++ b/drivers/usb/chipidea/otg_fsm.c +@@ -256,8 +256,10 @@ static void ci_otg_del_timer(struct ci_hdrc *ci, enum otg_fsm_timer t) + ci->enabled_otg_timer_bits &= ~(1 << t); + if (ci->next_otg_timer == t) { + if (ci->enabled_otg_timer_bits == 0) { ++ spin_unlock_irqrestore(&ci->lock, flags); + /* No enabled timers after delete it */ + hrtimer_cancel(&ci->otg_fsm_hrtimer); ++ spin_lock_irqsave(&ci->lock, flags); + ci->next_otg_timer = NUM_OTG_FSM_TIMERS; + } else { + /* Find the next timer */ +diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c +index 62a063ed8220a..35a11f7bcb658 100644 +--- a/drivers/usb/core/quirks.c ++++ b/drivers/usb/core/quirks.c +@@ -362,6 +362,9 @@ static const struct usb_device_id usb_quirk_list[] = { + { USB_DEVICE(0x0781, 0x5583), .driver_info = USB_QUIRK_NO_LPM }, + { USB_DEVICE(0x0781, 0x5591), .driver_info = USB_QUIRK_NO_LPM }, + ++ /* Realforce 87U Keyboard */ ++ { USB_DEVICE(0x0853, 0x011b), .driver_info = USB_QUIRK_NO_LPM }, ++ + /* M-Systems Flash Disk Pioneers */ + { USB_DEVICE(0x08ec, 0x1000), .driver_info = USB_QUIRK_RESET_RESUME }, + +diff --git a/drivers/usb/dwc3/host.c b/drivers/usb/dwc3/host.c +index a4eacc5cf58af..38bcb079ffc74 100644 +--- a/drivers/usb/dwc3/host.c ++++ b/drivers/usb/dwc3/host.c +@@ -9,13 +9,8 @@ + + #include <linux/platform_device.h> + +-#include "../host/xhci-plat.h" + #include "core.h" + +-static const struct xhci_plat_priv dwc3_xhci_plat_priv = { +- .quirks = XHCI_SKIP_PHY_INIT, +-}; +- + static int dwc3_host_get_irq(struct dwc3 *dwc) + { + struct platform_device *dwc3_pdev = to_platform_device(dwc->dev); +@@ -90,11 +85,6 @@ int dwc3_host_init(struct dwc3 *dwc) + goto err; + } + +- ret = platform_device_add_data(xhci, &dwc3_xhci_plat_priv, +- sizeof(dwc3_xhci_plat_priv)); +- if (ret) +- goto err; +- + memset(props, 0, sizeof(struct property_entry) * ARRAY_SIZE(props)); + + if (dwc->usb3_lpm_capable) +diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c +index 14aa8500221b8..263548af24838 100644 +--- a/drivers/usb/serial/option.c ++++ b/drivers/usb/serial/option.c +@@ -162,6 +162,8 @@ static void option_instat_callback(struct urb *urb); + #define NOVATELWIRELESS_PRODUCT_G2 0xA010 + #define NOVATELWIRELESS_PRODUCT_MC551 0xB001 + ++#define UBLOX_VENDOR_ID 0x1546 ++ + /* AMOI PRODUCTS */ + #define AMOI_VENDOR_ID 0x1614 + #define AMOI_PRODUCT_H01 0x0800 +@@ -240,7 +242,6 @@ static void option_instat_callback(struct urb *urb); + #define QUECTEL_PRODUCT_UC15 0x9090 + /* These u-blox products use Qualcomm's vendor ID */ + #define UBLOX_PRODUCT_R410M 0x90b2 +-#define UBLOX_PRODUCT_R6XX 0x90fa + /* These Yuga products use Qualcomm's vendor ID */ + #define YUGA_PRODUCT_CLM920_NC5 0x9625 + +@@ -581,6 +582,9 @@ static void option_instat_callback(struct urb *urb); + #define OPPO_VENDOR_ID 0x22d9 + #define OPPO_PRODUCT_R11 0x276c + ++/* Sierra Wireless products */ ++#define SIERRA_VENDOR_ID 0x1199 ++#define SIERRA_PRODUCT_EM9191 0x90d3 + + /* Device flags */ + +@@ -1124,8 +1128,16 @@ static const struct usb_device_id option_ids[] = { + /* u-blox products using Qualcomm vendor ID */ + { USB_DEVICE(QUALCOMM_VENDOR_ID, UBLOX_PRODUCT_R410M), + .driver_info = RSVD(1) | RSVD(3) }, +- { USB_DEVICE(QUALCOMM_VENDOR_ID, UBLOX_PRODUCT_R6XX), ++ { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x908b), /* u-blox LARA-R6 00B */ ++ .driver_info = RSVD(4) }, ++ { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x90fa), + .driver_info = RSVD(3) }, ++ /* u-blox products */ ++ { USB_DEVICE(UBLOX_VENDOR_ID, 0x1341) }, /* u-blox LARA-L6 */ ++ { USB_DEVICE(UBLOX_VENDOR_ID, 0x1342), /* u-blox LARA-L6 (RMNET) */ ++ .driver_info = RSVD(4) }, ++ { USB_DEVICE(UBLOX_VENDOR_ID, 0x1343), /* u-blox LARA-L6 (ECM) */ ++ .driver_info = RSVD(4) }, + /* Quectel products using Quectel vendor ID */ + { USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EC21, 0xff, 0xff, 0xff), + .driver_info = NUMEP2 }, +@@ -2167,6 +2179,7 @@ static const struct usb_device_id option_ids[] = { + { USB_DEVICE_INTERFACE_CLASS(0x2cb7, 0x010a, 0xff) }, /* Fibocom MA510 (ECM mode) */ + { USB_DEVICE_AND_INTERFACE_INFO(0x2cb7, 0x010b, 0xff, 0xff, 0x30) }, /* Fibocom FG150 Diag */ + { USB_DEVICE_AND_INTERFACE_INFO(0x2cb7, 0x010b, 0xff, 0, 0) }, /* Fibocom FG150 AT */ ++ { USB_DEVICE_INTERFACE_CLASS(0x2cb7, 0x0111, 0xff) }, /* Fibocom FM160 (MBIM mode) */ + { USB_DEVICE_INTERFACE_CLASS(0x2cb7, 0x01a0, 0xff) }, /* Fibocom NL668-AM/NL652-EU (laptop MBIM) */ + { USB_DEVICE_INTERFACE_CLASS(0x2cb7, 0x01a2, 0xff) }, /* Fibocom FM101-GL (laptop MBIM) */ + { USB_DEVICE_INTERFACE_CLASS(0x2cb7, 0x01a4, 0xff), /* Fibocom FM101-GL (laptop MBIM) */ +@@ -2176,6 +2189,8 @@ static const struct usb_device_id option_ids[] = { + { USB_DEVICE_INTERFACE_CLASS(0x305a, 0x1405, 0xff) }, /* GosunCn GM500 MBIM */ + { USB_DEVICE_INTERFACE_CLASS(0x305a, 0x1406, 0xff) }, /* GosunCn GM500 ECM/NCM */ + { USB_DEVICE_AND_INTERFACE_INFO(OPPO_VENDOR_ID, OPPO_PRODUCT_R11, 0xff, 0xff, 0x30) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(SIERRA_VENDOR_ID, SIERRA_PRODUCT_EM9191, 0xff, 0xff, 0x30) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(SIERRA_VENDOR_ID, SIERRA_PRODUCT_EM9191, 0xff, 0, 0) }, + { } /* Terminating entry */ + }; + MODULE_DEVICE_TABLE(usb, option_ids); +diff --git a/drivers/xen/pcpu.c b/drivers/xen/pcpu.c +index cdc6daa7a9f66..9cf7085a260b4 100644 +--- a/drivers/xen/pcpu.c ++++ b/drivers/xen/pcpu.c +@@ -228,7 +228,7 @@ static int register_pcpu(struct pcpu *pcpu) + + err = device_register(dev); + if (err) { +- pcpu_release(dev); ++ put_device(dev); + return err; + } + +diff --git a/fs/btrfs/tests/btrfs-tests.c b/fs/btrfs/tests/btrfs-tests.c +index 98f9684e7ffcc..8e413c82190e8 100644 +--- a/fs/btrfs/tests/btrfs-tests.c ++++ b/fs/btrfs/tests/btrfs-tests.c +@@ -189,7 +189,7 @@ void btrfs_free_dummy_fs_info(struct btrfs_fs_info *fs_info) + + void btrfs_free_dummy_root(struct btrfs_root *root) + { +- if (!root) ++ if (IS_ERR_OR_NULL(root)) + return; + /* Will be freed by btrfs_free_fs_roots */ + if (WARN_ON(test_bit(BTRFS_ROOT_IN_RADIX, &root->state))) +diff --git a/fs/btrfs/tests/qgroup-tests.c b/fs/btrfs/tests/qgroup-tests.c +index f312ed5abb19d..f6169bece7c05 100644 +--- a/fs/btrfs/tests/qgroup-tests.c ++++ b/fs/btrfs/tests/qgroup-tests.c +@@ -230,7 +230,6 @@ static int test_no_shared_qgroup(struct btrfs_root *root, + ret = btrfs_find_all_roots(&trans, fs_info, nodesize, 0, &old_roots, + false); + if (ret) { +- ulist_free(old_roots); + test_err("couldn't find old roots: %d", ret); + return ret; + } +@@ -246,7 +245,6 @@ static int test_no_shared_qgroup(struct btrfs_root *root, + false); + if (ret) { + ulist_free(old_roots); +- ulist_free(new_roots); + test_err("couldn't find old roots: %d", ret); + return ret; + } +@@ -258,18 +256,19 @@ static int test_no_shared_qgroup(struct btrfs_root *root, + return ret; + } + ++ /* btrfs_qgroup_account_extent() always frees the ulists passed to it. */ ++ old_roots = NULL; ++ new_roots = NULL; ++ + if (btrfs_verify_qgroup_counts(fs_info, BTRFS_FS_TREE_OBJECTID, + nodesize, nodesize)) { + test_err("qgroup counts didn't match expected values"); + return -EINVAL; + } +- old_roots = NULL; +- new_roots = NULL; + + ret = btrfs_find_all_roots(&trans, fs_info, nodesize, 0, &old_roots, + false); + if (ret) { +- ulist_free(old_roots); + test_err("couldn't find old roots: %d", ret); + return ret; + } +@@ -284,7 +283,6 @@ static int test_no_shared_qgroup(struct btrfs_root *root, + false); + if (ret) { + ulist_free(old_roots); +- ulist_free(new_roots); + test_err("couldn't find old roots: %d", ret); + return ret; + } +@@ -335,7 +333,6 @@ static int test_multiple_refs(struct btrfs_root *root, + ret = btrfs_find_all_roots(&trans, fs_info, nodesize, 0, &old_roots, + false); + if (ret) { +- ulist_free(old_roots); + test_err("couldn't find old roots: %d", ret); + return ret; + } +@@ -351,7 +348,6 @@ static int test_multiple_refs(struct btrfs_root *root, + false); + if (ret) { + ulist_free(old_roots); +- ulist_free(new_roots); + test_err("couldn't find old roots: %d", ret); + return ret; + } +@@ -372,7 +368,6 @@ static int test_multiple_refs(struct btrfs_root *root, + ret = btrfs_find_all_roots(&trans, fs_info, nodesize, 0, &old_roots, + false); + if (ret) { +- ulist_free(old_roots); + test_err("couldn't find old roots: %d", ret); + return ret; + } +@@ -388,7 +383,6 @@ static int test_multiple_refs(struct btrfs_root *root, + false); + if (ret) { + ulist_free(old_roots); +- ulist_free(new_roots); + test_err("couldn't find old roots: %d", ret); + return ret; + } +@@ -415,7 +409,6 @@ static int test_multiple_refs(struct btrfs_root *root, + ret = btrfs_find_all_roots(&trans, fs_info, nodesize, 0, &old_roots, + false); + if (ret) { +- ulist_free(old_roots); + test_err("couldn't find old roots: %d", ret); + return ret; + } +@@ -431,7 +424,6 @@ static int test_multiple_refs(struct btrfs_root *root, + false); + if (ret) { + ulist_free(old_roots); +- ulist_free(new_roots); + test_err("couldn't find old roots: %d", ret); + return ret; + } +diff --git a/fs/buffer.c b/fs/buffer.c +index 0d7bd7712076d..4ec88d08d04ec 100644 +--- a/fs/buffer.c ++++ b/fs/buffer.c +@@ -2318,7 +2318,7 @@ int generic_cont_expand_simple(struct inode *inode, loff_t size) + { + struct address_space *mapping = inode->i_mapping; + struct page *page; +- void *fsdata; ++ void *fsdata = NULL; + int err; + + err = inode_newsize_ok(inode, size); +@@ -2344,7 +2344,7 @@ static int cont_expand_zero(struct file *file, struct address_space *mapping, + struct inode *inode = mapping->host; + unsigned int blocksize = i_blocksize(inode); + struct page *page; +- void *fsdata; ++ void *fsdata = NULL; + pgoff_t index, curidx; + loff_t curpos; + unsigned zerofrom, offset, len; +diff --git a/fs/cifs/ioctl.c b/fs/cifs/ioctl.c +index 1a01e108d75e5..9266dddd4b1eb 100644 +--- a/fs/cifs/ioctl.c ++++ b/fs/cifs/ioctl.c +@@ -191,7 +191,7 @@ long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg) + rc = put_user(ExtAttrBits & + FS_FL_USER_VISIBLE, + (int __user *)arg); +- if (rc != EOPNOTSUPP) ++ if (rc != -EOPNOTSUPP) + break; + } + #endif /* CONFIG_CIFS_POSIX */ +@@ -220,7 +220,7 @@ long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg) + * pSMBFile->fid.netfid, + * extAttrBits, + * &ExtAttrMask); +- * if (rc != EOPNOTSUPP) ++ * if (rc != -EOPNOTSUPP) + * break; + */ + +diff --git a/fs/cifs/smb2ops.c b/fs/cifs/smb2ops.c +index 6039b0cdfe04e..d67676545a421 100644 +--- a/fs/cifs/smb2ops.c ++++ b/fs/cifs/smb2ops.c +@@ -1216,6 +1216,8 @@ smb2_set_ea(const unsigned int xid, struct cifs_tcon *tcon, + COMPOUND_FID, current->tgid, + FILE_FULL_EA_INFORMATION, + SMB2_O_INFO_FILE, 0, data, size); ++ if (rc) ++ goto sea_exit; + smb2_set_next_command(tcon, &rqst[1]); + smb2_set_related(&rqst[1]); + +diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c +index 29b27d769860c..2112ff7a01725 100644 +--- a/fs/gfs2/ops_fstype.c ++++ b/fs/gfs2/ops_fstype.c +@@ -180,7 +180,10 @@ static int gfs2_check_sb(struct gfs2_sbd *sdp, int silent) + pr_warn("Invalid superblock size\n"); + return -EINVAL; + } +- ++ if (sb->sb_bsize_shift != ffs(sb->sb_bsize) - 1) { ++ pr_warn("Invalid block size shift\n"); ++ return -EINVAL; ++ } + return 0; + } + +@@ -377,8 +380,10 @@ static int init_names(struct gfs2_sbd *sdp, int silent) + if (!table[0]) + table = sdp->sd_vfs->s_id; + +- strlcpy(sdp->sd_proto_name, proto, GFS2_FSNAME_LEN); +- strlcpy(sdp->sd_table_name, table, GFS2_FSNAME_LEN); ++ BUILD_BUG_ON(GFS2_LOCKNAME_LEN > GFS2_FSNAME_LEN); ++ ++ strscpy(sdp->sd_proto_name, proto, GFS2_LOCKNAME_LEN); ++ strscpy(sdp->sd_table_name, table, GFS2_LOCKNAME_LEN); + + table = sdp->sd_table_name; + while ((table = strchr(table, '/'))) +@@ -1349,13 +1354,13 @@ static int gfs2_parse_param(struct fs_context *fc, struct fs_parameter *param) + + switch (o) { + case Opt_lockproto: +- strlcpy(args->ar_lockproto, param->string, GFS2_LOCKNAME_LEN); ++ strscpy(args->ar_lockproto, param->string, GFS2_LOCKNAME_LEN); + break; + case Opt_locktable: +- strlcpy(args->ar_locktable, param->string, GFS2_LOCKNAME_LEN); ++ strscpy(args->ar_locktable, param->string, GFS2_LOCKNAME_LEN); + break; + case Opt_hostdata: +- strlcpy(args->ar_hostdata, param->string, GFS2_LOCKNAME_LEN); ++ strscpy(args->ar_hostdata, param->string, GFS2_LOCKNAME_LEN); + break; + case Opt_spectator: + args->ar_spectator = 1; +diff --git a/fs/namei.c b/fs/namei.c +index 22d13732e61d7..d220df830c499 100644 +--- a/fs/namei.c ++++ b/fs/namei.c +@@ -4819,7 +4819,7 @@ int __page_symlink(struct inode *inode, const char *symname, int len, int nofs) + { + struct address_space *mapping = inode->i_mapping; + struct page *page; +- void *fsdata; ++ void *fsdata = NULL; + int err; + unsigned int flags = 0; + if (nofs) +diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c +index 7c5dfed0437f7..77c2c88621bee 100644 +--- a/fs/nfs/nfs4proc.c ++++ b/fs/nfs/nfs4proc.c +@@ -6854,6 +6854,7 @@ static void nfs4_lock_done(struct rpc_task *task, void *calldata) + { + struct nfs4_lockdata *data = calldata; + struct nfs4_lock_state *lsp = data->lsp; ++ struct nfs_server *server = NFS_SERVER(d_inode(data->ctx->dentry)); + + dprintk("%s: begin!\n", __func__); + +@@ -6863,8 +6864,7 @@ static void nfs4_lock_done(struct rpc_task *task, void *calldata) + data->rpc_status = task->tk_status; + switch (task->tk_status) { + case 0: +- renew_lease(NFS_SERVER(d_inode(data->ctx->dentry)), +- data->timestamp); ++ renew_lease(server, data->timestamp); + if (data->arg.new_lock && !data->cancelled) { + data->fl.fl_flags &= ~(FL_SLEEP | FL_ACCESS); + if (locks_lock_inode_wait(lsp->ls_state->inode, &data->fl) < 0) +@@ -6885,6 +6885,8 @@ static void nfs4_lock_done(struct rpc_task *task, void *calldata) + if (!nfs4_stateid_match(&data->arg.open_stateid, + &lsp->ls_state->open_stateid)) + goto out_restart; ++ else if (nfs4_async_handle_error(task, server, lsp->ls_state, NULL) == -EAGAIN) ++ goto out_restart; + } else if (!nfs4_stateid_match(&data->arg.lock_stateid, + &lsp->ls_stateid)) + goto out_restart; +diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c +index 535543ab4e26a..11914b3585b34 100644 +--- a/fs/nilfs2/segment.c ++++ b/fs/nilfs2/segment.c +@@ -322,7 +322,7 @@ void nilfs_relax_pressure_in_lock(struct super_block *sb) + struct the_nilfs *nilfs = sb->s_fs_info; + struct nilfs_sc_info *sci = nilfs->ns_writer; + +- if (!sci || !sci->sc_flush_request) ++ if (sb_rdonly(sb) || unlikely(!sci) || !sci->sc_flush_request) + return; + + set_bit(NILFS_SC_PRIOR_FLUSH, &sci->sc_flags); +@@ -2243,7 +2243,7 @@ int nilfs_construct_segment(struct super_block *sb) + struct nilfs_transaction_info *ti; + int err; + +- if (!sci) ++ if (sb_rdonly(sb) || unlikely(!sci)) + return -EROFS; + + /* A call inside transactions causes a deadlock. */ +@@ -2282,7 +2282,7 @@ int nilfs_construct_dsync_segment(struct super_block *sb, struct inode *inode, + struct nilfs_transaction_info ti; + int err = 0; + +- if (!sci) ++ if (sb_rdonly(sb) || unlikely(!sci)) + return -EROFS; + + nilfs_transaction_lock(sb, &ti, 0); +@@ -2778,11 +2778,12 @@ int nilfs_attach_log_writer(struct super_block *sb, struct nilfs_root *root) + + if (nilfs->ns_writer) { + /* +- * This happens if the filesystem was remounted +- * read/write after nilfs_error degenerated it into a +- * read-only mount. ++ * This happens if the filesystem is made read-only by ++ * __nilfs_error or nilfs_remount and then remounted ++ * read/write. In these cases, reuse the existing ++ * writer. + */ +- nilfs_detach_log_writer(sb); ++ return 0; + } + + nilfs->ns_writer = nilfs_segctor_new(sb, root); +diff --git a/fs/nilfs2/super.c b/fs/nilfs2/super.c +index b5bc9f0c6a406..049768a22388e 100644 +--- a/fs/nilfs2/super.c ++++ b/fs/nilfs2/super.c +@@ -1131,8 +1131,6 @@ static int nilfs_remount(struct super_block *sb, int *flags, char *data) + if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb)) + goto out; + if (*flags & SB_RDONLY) { +- /* Shutting down log writer */ +- nilfs_detach_log_writer(sb); + sb->s_flags |= SB_RDONLY; + + /* +diff --git a/fs/nilfs2/the_nilfs.c b/fs/nilfs2/the_nilfs.c +index 931870768556c..fb61c33c60045 100644 +--- a/fs/nilfs2/the_nilfs.c ++++ b/fs/nilfs2/the_nilfs.c +@@ -695,9 +695,7 @@ int nilfs_count_free_blocks(struct the_nilfs *nilfs, sector_t *nblocks) + { + unsigned long ncleansegs; + +- down_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem); + ncleansegs = nilfs_sufile_get_ncleansegs(nilfs->ns_sufile); +- up_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem); + *nblocks = (sector_t)ncleansegs * nilfs->ns_blocks_per_segment; + return 0; + } +diff --git a/fs/ntfs/attrib.c b/fs/ntfs/attrib.c +index 914e991731300..c0881d39d36a9 100644 +--- a/fs/ntfs/attrib.c ++++ b/fs/ntfs/attrib.c +@@ -594,17 +594,37 @@ static int ntfs_attr_find(const ATTR_TYPE type, const ntfschar *name, + for (;; a = (ATTR_RECORD*)((u8*)a + le32_to_cpu(a->length))) { + u8 *mrec_end = (u8 *)ctx->mrec + + le32_to_cpu(ctx->mrec->bytes_allocated); +- u8 *name_end = (u8 *)a + le16_to_cpu(a->name_offset) + +- a->name_length * sizeof(ntfschar); +- if ((u8*)a < (u8*)ctx->mrec || (u8*)a > mrec_end || +- name_end > mrec_end) ++ u8 *name_end; ++ ++ /* check whether ATTR_RECORD wrap */ ++ if ((u8 *)a < (u8 *)ctx->mrec) ++ break; ++ ++ /* check whether Attribute Record Header is within bounds */ ++ if ((u8 *)a > mrec_end || ++ (u8 *)a + sizeof(ATTR_RECORD) > mrec_end) ++ break; ++ ++ /* check whether ATTR_RECORD's name is within bounds */ ++ name_end = (u8 *)a + le16_to_cpu(a->name_offset) + ++ a->name_length * sizeof(ntfschar); ++ if (name_end > mrec_end) + break; ++ + ctx->attr = a; + if (unlikely(le32_to_cpu(a->type) > le32_to_cpu(type) || + a->type == AT_END)) + return -ENOENT; + if (unlikely(!a->length)) + break; ++ ++ /* check whether ATTR_RECORD's length wrap */ ++ if ((u8 *)a + le32_to_cpu(a->length) < (u8 *)a) ++ break; ++ /* check whether ATTR_RECORD's length is within bounds */ ++ if ((u8 *)a + le32_to_cpu(a->length) > mrec_end) ++ break; ++ + if (a->type != type) + continue; + /* +diff --git a/fs/ntfs/inode.c b/fs/ntfs/inode.c +index cf222c9225d6d..645c4b1b23de1 100644 +--- a/fs/ntfs/inode.c ++++ b/fs/ntfs/inode.c +@@ -1829,6 +1829,13 @@ int ntfs_read_inode_mount(struct inode *vi) + goto err_out; + } + ++ /* Sanity check offset to the first attribute */ ++ if (le16_to_cpu(m->attrs_offset) >= le32_to_cpu(m->bytes_allocated)) { ++ ntfs_error(sb, "Incorrect mft offset to the first attribute %u in superblock.", ++ le16_to_cpu(m->attrs_offset)); ++ goto err_out; ++ } ++ + /* Need this to sanity check attribute list references to $MFT. */ + vi->i_generation = ni->seq_no = le16_to_cpu(m->sequence_number); + +diff --git a/fs/udf/namei.c b/fs/udf/namei.c +index 3c009562375d3..1f418d68e2ee5 100644 +--- a/fs/udf/namei.c ++++ b/fs/udf/namei.c +@@ -241,7 +241,7 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir, + poffset - lfi); + else { + if (!copy_name) { +- copy_name = kmalloc(UDF_NAME_LEN, ++ copy_name = kmalloc(UDF_NAME_LEN_CS0, + GFP_NOFS); + if (!copy_name) { + fi = ERR_PTR(-ENOMEM); +diff --git a/fs/xfs/libxfs/xfs_bmap.h b/fs/xfs/libxfs/xfs_bmap.h +index 640dcc036ea94..a51c2b13a51ad 100644 +--- a/fs/xfs/libxfs/xfs_bmap.h ++++ b/fs/xfs/libxfs/xfs_bmap.h +@@ -158,17 +158,22 @@ static inline int xfs_bmapi_whichfork(int bmapi_flags) + { BMAP_ATTRFORK, "ATTR" }, \ + { BMAP_COWFORK, "COW" } + ++/* Return true if the extent is an allocated extent, written or not. */ ++static inline bool xfs_bmap_is_real_extent(struct xfs_bmbt_irec *irec) ++{ ++ return irec->br_startblock != HOLESTARTBLOCK && ++ irec->br_startblock != DELAYSTARTBLOCK && ++ !isnullstartblock(irec->br_startblock); ++} + + /* + * Return true if the extent is a real, allocated extent, or false if it is a + * delayed allocation, and unwritten extent or a hole. + */ +-static inline bool xfs_bmap_is_real_extent(struct xfs_bmbt_irec *irec) ++static inline bool xfs_bmap_is_written_extent(struct xfs_bmbt_irec *irec) + { +- return irec->br_state != XFS_EXT_UNWRITTEN && +- irec->br_startblock != HOLESTARTBLOCK && +- irec->br_startblock != DELAYSTARTBLOCK && +- !isnullstartblock(irec->br_startblock); ++ return xfs_bmap_is_real_extent(irec) && ++ irec->br_state != XFS_EXT_UNWRITTEN; + } + + /* +diff --git a/fs/xfs/libxfs/xfs_rtbitmap.c b/fs/xfs/libxfs/xfs_rtbitmap.c +index 85f123b3dfcc1..cf99e4cab6277 100644 +--- a/fs/xfs/libxfs/xfs_rtbitmap.c ++++ b/fs/xfs/libxfs/xfs_rtbitmap.c +@@ -70,7 +70,7 @@ xfs_rtbuf_get( + if (error) + return error; + +- if (nmap == 0 || !xfs_bmap_is_real_extent(&map)) { ++ if (nmap == 0 || !xfs_bmap_is_written_extent(&map)) { + XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp); + return -EFSCORRUPTED; + } +diff --git a/fs/xfs/libxfs/xfs_shared.h b/fs/xfs/libxfs/xfs_shared.h +index c45acbd3add94..708feb8eac766 100644 +--- a/fs/xfs/libxfs/xfs_shared.h ++++ b/fs/xfs/libxfs/xfs_shared.h +@@ -65,6 +65,7 @@ void xfs_log_get_max_trans_res(struct xfs_mount *mp, + #define XFS_TRANS_DQ_DIRTY 0x10 /* at least one dquot in trx dirty */ + #define XFS_TRANS_RESERVE 0x20 /* OK to use reserved data blocks */ + #define XFS_TRANS_NO_WRITECOUNT 0x40 /* do not elevate SB writecount */ ++#define XFS_TRANS_RES_FDBLKS 0x80 /* reserve newly freed blocks */ + /* + * LOWMODE is used by the allocator to activate the lowspace algorithm - when + * free space is running low the extent allocator may choose to allocate an +diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c +index 12c12c2ef2416..5eab15dde4e61 100644 +--- a/fs/xfs/xfs_bmap_util.c ++++ b/fs/xfs/xfs_bmap_util.c +@@ -1740,6 +1740,7 @@ xfs_swap_extents( + int lock_flags; + uint64_t f; + int resblks = 0; ++ unsigned int flags = 0; + + /* + * Lock the inodes against other IO, page faults and truncate to +@@ -1795,17 +1796,16 @@ xfs_swap_extents( + resblks += XFS_SWAP_RMAP_SPACE_RES(mp, tipnext, w); + + /* +- * Handle the corner case where either inode might straddle the +- * btree format boundary. If so, the inode could bounce between +- * btree <-> extent format on unmap -> remap cycles, freeing and +- * allocating a bmapbt block each time. ++ * If either inode straddles a bmapbt block allocation boundary, ++ * the rmapbt algorithm triggers repeated allocs and frees as ++ * extents are remapped. This can exhaust the block reservation ++ * prematurely and cause shutdown. Return freed blocks to the ++ * transaction reservation to counter this behavior. + */ +- if (ipnext == (XFS_IFORK_MAXEXT(ip, w) + 1)) +- resblks += XFS_IFORK_MAXEXT(ip, w); +- if (tipnext == (XFS_IFORK_MAXEXT(tip, w) + 1)) +- resblks += XFS_IFORK_MAXEXT(tip, w); ++ flags |= XFS_TRANS_RES_FDBLKS; + } +- error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0, 0, &tp); ++ error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0, flags, ++ &tp); + if (error) + goto out_unlock; + +diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c +index c67fab2c37c58..b651715da8c6c 100644 +--- a/fs/xfs/xfs_file.c ++++ b/fs/xfs/xfs_file.c +@@ -1267,10 +1267,23 @@ xfs_filemap_pfn_mkwrite( + return __xfs_filemap_fault(vmf, PE_SIZE_PTE, true); + } + ++static void ++xfs_filemap_map_pages( ++ struct vm_fault *vmf, ++ pgoff_t start_pgoff, ++ pgoff_t end_pgoff) ++{ ++ struct inode *inode = file_inode(vmf->vma->vm_file); ++ ++ xfs_ilock(XFS_I(inode), XFS_MMAPLOCK_SHARED); ++ filemap_map_pages(vmf, start_pgoff, end_pgoff); ++ xfs_iunlock(XFS_I(inode), XFS_MMAPLOCK_SHARED); ++} ++ + static const struct vm_operations_struct xfs_file_vm_ops = { + .fault = xfs_filemap_fault, + .huge_fault = xfs_filemap_huge_fault, +- .map_pages = filemap_map_pages, ++ .map_pages = xfs_filemap_map_pages, + .page_mkwrite = xfs_filemap_page_mkwrite, + .pfn_mkwrite = xfs_filemap_pfn_mkwrite, + }; +diff --git a/fs/xfs/xfs_reflink.c b/fs/xfs/xfs_reflink.c +index dfbf3f8f1ec86..01191ff46647d 100644 +--- a/fs/xfs/xfs_reflink.c ++++ b/fs/xfs/xfs_reflink.c +@@ -181,7 +181,7 @@ xfs_reflink_trim_around_shared( + int error = 0; + + /* Holes, unwritten, and delalloc extents cannot be shared */ +- if (!xfs_is_cow_inode(ip) || !xfs_bmap_is_real_extent(irec)) { ++ if (!xfs_is_cow_inode(ip) || !xfs_bmap_is_written_extent(irec)) { + *shared = false; + return 0; + } +@@ -657,7 +657,7 @@ xfs_reflink_end_cow_extent( + * preallocations can leak into the range we are called upon, and we + * need to skip them. + */ +- if (!xfs_bmap_is_real_extent(&got)) { ++ if (!xfs_bmap_is_written_extent(&got)) { + *end_fsb = del.br_startoff; + goto out_cancel; + } +@@ -986,41 +986,28 @@ xfs_reflink_ag_has_free_space( + } + + /* +- * Unmap a range of blocks from a file, then map other blocks into the hole. +- * The range to unmap is (destoff : destoff + srcioff + irec->br_blockcount). +- * The extent irec is mapped into dest at irec->br_startoff. ++ * Remap the given extent into the file. The dmap blockcount will be set to ++ * the number of blocks that were actually remapped. + */ + STATIC int + xfs_reflink_remap_extent( + struct xfs_inode *ip, +- struct xfs_bmbt_irec *irec, +- xfs_fileoff_t destoff, ++ struct xfs_bmbt_irec *dmap, + xfs_off_t new_isize) + { ++ struct xfs_bmbt_irec smap; + struct xfs_mount *mp = ip->i_mount; +- bool real_extent = xfs_bmap_is_real_extent(irec); + struct xfs_trans *tp; +- unsigned int resblks; +- struct xfs_bmbt_irec uirec; +- xfs_filblks_t rlen; +- xfs_filblks_t unmap_len; + xfs_off_t newlen; +- int64_t qres; ++ int64_t qres, qdelta; ++ unsigned int resblks; ++ bool smap_real; ++ bool dmap_written = xfs_bmap_is_written_extent(dmap); ++ int nimaps; + int error; + +- unmap_len = irec->br_startoff + irec->br_blockcount - destoff; +- trace_xfs_reflink_punch_range(ip, destoff, unmap_len); +- +- /* No reflinking if we're low on space */ +- if (real_extent) { +- error = xfs_reflink_ag_has_free_space(mp, +- XFS_FSB_TO_AGNO(mp, irec->br_startblock)); +- if (error) +- goto out; +- } +- + /* Start a rolling transaction to switch the mappings */ +- resblks = XFS_EXTENTADD_SPACE_RES(ip->i_mount, XFS_DATA_FORK); ++ resblks = XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK); + error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0, 0, &tp); + if (error) + goto out; +@@ -1029,92 +1016,121 @@ xfs_reflink_remap_extent( + xfs_trans_ijoin(tp, ip, 0); + + /* +- * Reserve quota for this operation. We don't know if the first unmap +- * in the dest file will cause a bmap btree split, so we always reserve +- * at least enough blocks for that split. If the extent being mapped +- * in is written, we need to reserve quota for that too. ++ * Read what's currently mapped in the destination file into smap. ++ * If smap isn't a hole, we will have to remove it before we can add ++ * dmap to the destination file. + */ +- qres = XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK); +- if (real_extent) +- qres += irec->br_blockcount; +- error = xfs_trans_reserve_quota_nblks(tp, ip, qres, 0, +- XFS_QMOPT_RES_REGBLKS); ++ nimaps = 1; ++ error = xfs_bmapi_read(ip, dmap->br_startoff, dmap->br_blockcount, ++ &smap, &nimaps, 0); + if (error) + goto out_cancel; ++ ASSERT(nimaps == 1 && smap.br_startoff == dmap->br_startoff); ++ smap_real = xfs_bmap_is_real_extent(&smap); + +- trace_xfs_reflink_remap(ip, irec->br_startoff, +- irec->br_blockcount, irec->br_startblock); ++ /* ++ * We can only remap as many blocks as the smaller of the two extent ++ * maps, because we can only remap one extent at a time. ++ */ ++ dmap->br_blockcount = min(dmap->br_blockcount, smap.br_blockcount); ++ ASSERT(dmap->br_blockcount == smap.br_blockcount); + +- /* Unmap the old blocks in the data fork. */ +- rlen = unmap_len; +- while (rlen) { +- ASSERT(tp->t_firstblock == NULLFSBLOCK); +- error = __xfs_bunmapi(tp, ip, destoff, &rlen, 0, 1); ++ trace_xfs_reflink_remap_extent_dest(ip, &smap); ++ ++ /* No reflinking if the AG of the dest mapping is low on space. */ ++ if (dmap_written) { ++ error = xfs_reflink_ag_has_free_space(mp, ++ XFS_FSB_TO_AGNO(mp, dmap->br_startblock)); + if (error) + goto out_cancel; ++ } + ++ /* ++ * Compute quota reservation if we think the quota block counter for ++ * this file could increase. ++ * ++ * We start by reserving enough blocks to handle a bmbt split. ++ * ++ * If we are mapping a written extent into the file, we need to have ++ * enough quota block count reservation to handle the blocks in that ++ * extent. ++ * ++ * Note that if we're replacing a delalloc reservation with a written ++ * extent, we have to take the full quota reservation because removing ++ * the delalloc reservation gives the block count back to the quota ++ * count. This is suboptimal, but the VFS flushed the dest range ++ * before we started. That should have removed all the delalloc ++ * reservations, but we code defensively. ++ */ ++ qdelta = 0; ++ qres = XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK); ++ if (dmap_written) ++ qres += dmap->br_blockcount; ++ error = xfs_trans_reserve_quota_nblks(tp, ip, qres, 0, ++ XFS_QMOPT_RES_REGBLKS); ++ if (error) ++ goto out_cancel; ++ ++ if (smap_real) { + /* +- * Trim the extent to whatever got unmapped. +- * Remember, bunmapi works backwards. ++ * If the extent we're unmapping is backed by storage (written ++ * or not), unmap the extent and drop its refcount. + */ +- uirec.br_startblock = irec->br_startblock + rlen; +- uirec.br_startoff = irec->br_startoff + rlen; +- uirec.br_blockcount = unmap_len - rlen; +- uirec.br_state = irec->br_state; +- unmap_len = rlen; +- +- /* If this isn't a real mapping, we're done. */ +- if (!real_extent || uirec.br_blockcount == 0) +- goto next_extent; +- +- trace_xfs_reflink_remap(ip, uirec.br_startoff, +- uirec.br_blockcount, uirec.br_startblock); ++ xfs_bmap_unmap_extent(tp, ip, &smap); ++ xfs_refcount_decrease_extent(tp, &smap); ++ qdelta -= smap.br_blockcount; ++ } else if (smap.br_startblock == DELAYSTARTBLOCK) { ++ xfs_filblks_t len = smap.br_blockcount; + +- /* Update the refcount tree */ +- xfs_refcount_increase_extent(tp, &uirec); +- +- /* Map the new blocks into the data fork. */ +- xfs_bmap_map_extent(tp, ip, &uirec); ++ /* ++ * If the extent we're unmapping is a delalloc reservation, ++ * we can use the regular bunmapi function to release the ++ * incore state. Dropping the delalloc reservation takes care ++ * of the quota reservation for us. ++ */ ++ error = __xfs_bunmapi(NULL, ip, smap.br_startoff, &len, 0, 1); ++ if (error) ++ goto out_cancel; ++ ASSERT(len == 0); ++ } + +- /* Update quota accounting. */ +- xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, +- uirec.br_blockcount); ++ /* ++ * If the extent we're sharing is backed by written storage, increase ++ * its refcount and map it into the file. ++ */ ++ if (dmap_written) { ++ xfs_refcount_increase_extent(tp, dmap); ++ xfs_bmap_map_extent(tp, ip, dmap); ++ qdelta += dmap->br_blockcount; ++ } + +- /* Update dest isize if needed. */ +- newlen = XFS_FSB_TO_B(mp, +- uirec.br_startoff + uirec.br_blockcount); +- newlen = min_t(xfs_off_t, newlen, new_isize); +- if (newlen > i_size_read(VFS_I(ip))) { +- trace_xfs_reflink_update_inode_size(ip, newlen); +- i_size_write(VFS_I(ip), newlen); +- ip->i_d.di_size = newlen; +- xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); +- } ++ xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, qdelta); + +-next_extent: +- /* Process all the deferred stuff. */ +- error = xfs_defer_finish(&tp); +- if (error) +- goto out_cancel; ++ /* Update dest isize if needed. */ ++ newlen = XFS_FSB_TO_B(mp, dmap->br_startoff + dmap->br_blockcount); ++ newlen = min_t(xfs_off_t, newlen, new_isize); ++ if (newlen > i_size_read(VFS_I(ip))) { ++ trace_xfs_reflink_update_inode_size(ip, newlen); ++ i_size_write(VFS_I(ip), newlen); ++ ip->i_d.di_size = newlen; ++ xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); + } + ++ /* Commit everything and unlock. */ + error = xfs_trans_commit(tp); +- xfs_iunlock(ip, XFS_ILOCK_EXCL); +- if (error) +- goto out; +- return 0; ++ goto out_unlock; + + out_cancel: + xfs_trans_cancel(tp); ++out_unlock: + xfs_iunlock(ip, XFS_ILOCK_EXCL); + out: +- trace_xfs_reflink_remap_extent_error(ip, error, _RET_IP_); ++ if (error) ++ trace_xfs_reflink_remap_extent_error(ip, error, _RET_IP_); + return error; + } + +-/* +- * Iteratively remap one file's extents (and holes) to another's. +- */ ++/* Remap a range of one file to the other. */ + int + xfs_reflink_remap_blocks( + struct xfs_inode *src, +@@ -1125,25 +1141,22 @@ xfs_reflink_remap_blocks( + loff_t *remapped) + { + struct xfs_bmbt_irec imap; +- xfs_fileoff_t srcoff; +- xfs_fileoff_t destoff; ++ struct xfs_mount *mp = src->i_mount; ++ xfs_fileoff_t srcoff = XFS_B_TO_FSBT(mp, pos_in); ++ xfs_fileoff_t destoff = XFS_B_TO_FSBT(mp, pos_out); + xfs_filblks_t len; +- xfs_filblks_t range_len; + xfs_filblks_t remapped_len = 0; + xfs_off_t new_isize = pos_out + remap_len; + int nimaps; + int error = 0; + +- destoff = XFS_B_TO_FSBT(src->i_mount, pos_out); +- srcoff = XFS_B_TO_FSBT(src->i_mount, pos_in); +- len = XFS_B_TO_FSB(src->i_mount, remap_len); ++ len = min_t(xfs_filblks_t, XFS_B_TO_FSB(mp, remap_len), ++ XFS_MAX_FILEOFF); + +- /* drange = (destoff, destoff + len); srange = (srcoff, srcoff + len) */ +- while (len) { +- uint lock_mode; ++ trace_xfs_reflink_remap_blocks(src, srcoff, len, dest, destoff); + +- trace_xfs_reflink_remap_blocks_loop(src, srcoff, len, +- dest, destoff); ++ while (len > 0) { ++ unsigned int lock_mode; + + /* Read extent from the source file */ + nimaps = 1; +@@ -1152,18 +1165,25 @@ xfs_reflink_remap_blocks( + xfs_iunlock(src, lock_mode); + if (error) + break; +- ASSERT(nimaps == 1); +- +- trace_xfs_reflink_remap_imap(src, srcoff, len, XFS_DATA_FORK, +- &imap); ++ /* ++ * The caller supposedly flushed all dirty pages in the source ++ * file range, which means that writeback should have allocated ++ * or deleted all delalloc reservations in that range. If we ++ * find one, that's a good sign that something is seriously ++ * wrong here. ++ */ ++ ASSERT(nimaps == 1 && imap.br_startoff == srcoff); ++ if (imap.br_startblock == DELAYSTARTBLOCK) { ++ ASSERT(imap.br_startblock != DELAYSTARTBLOCK); ++ error = -EFSCORRUPTED; ++ break; ++ } + +- /* Translate imap into the destination file. */ +- range_len = imap.br_startoff + imap.br_blockcount - srcoff; +- imap.br_startoff += destoff - srcoff; ++ trace_xfs_reflink_remap_extent_src(src, &imap); + +- /* Clear dest from destoff to the end of imap and map it in. */ +- error = xfs_reflink_remap_extent(dest, &imap, destoff, +- new_isize); ++ /* Remap into the destination file at the given offset. */ ++ imap.br_startoff = destoff; ++ error = xfs_reflink_remap_extent(dest, &imap, new_isize); + if (error) + break; + +@@ -1173,10 +1193,10 @@ xfs_reflink_remap_blocks( + } + + /* Advance drange/srange */ +- srcoff += range_len; +- destoff += range_len; +- len -= range_len; +- remapped_len += range_len; ++ srcoff += imap.br_blockcount; ++ destoff += imap.br_blockcount; ++ len -= imap.br_blockcount; ++ remapped_len += imap.br_blockcount; + } + + if (error) +@@ -1427,7 +1447,7 @@ xfs_reflink_dirty_extents( + goto out; + if (nmaps == 0) + break; +- if (!xfs_bmap_is_real_extent(&map[0])) ++ if (!xfs_bmap_is_written_extent(&map[0])) + goto next; + + map[1] = map[0]; +diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c +index 2429acbfb1324..f1407900aeef9 100644 +--- a/fs/xfs/xfs_super.c ++++ b/fs/xfs/xfs_super.c +@@ -1228,6 +1228,10 @@ xfs_fs_remount( + char *p; + int error; + ++ /* version 5 superblocks always support version counters. */ ++ if (XFS_SB_VERSION_NUM(&mp->m_sb) == XFS_SB_VERSION_5) ++ *flags |= SB_I_VERSION; ++ + /* First, check for complete junk; i.e. invalid options */ + error = xfs_test_remount_options(sb, options); + if (error) +diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h +index b5d4ca60145a5..f94908125e8f9 100644 +--- a/fs/xfs/xfs_trace.h ++++ b/fs/xfs/xfs_trace.h +@@ -3078,8 +3078,7 @@ DEFINE_EVENT(xfs_inode_irec_class, name, \ + DEFINE_INODE_EVENT(xfs_reflink_set_inode_flag); + DEFINE_INODE_EVENT(xfs_reflink_unset_inode_flag); + DEFINE_ITRUNC_EVENT(xfs_reflink_update_inode_size); +-DEFINE_IMAP_EVENT(xfs_reflink_remap_imap); +-TRACE_EVENT(xfs_reflink_remap_blocks_loop, ++TRACE_EVENT(xfs_reflink_remap_blocks, + TP_PROTO(struct xfs_inode *src, xfs_fileoff_t soffset, + xfs_filblks_t len, struct xfs_inode *dest, + xfs_fileoff_t doffset), +@@ -3110,59 +3109,14 @@ TRACE_EVENT(xfs_reflink_remap_blocks_loop, + __entry->dest_ino, + __entry->dest_lblk) + ); +-TRACE_EVENT(xfs_reflink_punch_range, +- TP_PROTO(struct xfs_inode *ip, xfs_fileoff_t lblk, +- xfs_extlen_t len), +- TP_ARGS(ip, lblk, len), +- TP_STRUCT__entry( +- __field(dev_t, dev) +- __field(xfs_ino_t, ino) +- __field(xfs_fileoff_t, lblk) +- __field(xfs_extlen_t, len) +- ), +- TP_fast_assign( +- __entry->dev = VFS_I(ip)->i_sb->s_dev; +- __entry->ino = ip->i_ino; +- __entry->lblk = lblk; +- __entry->len = len; +- ), +- TP_printk("dev %d:%d ino 0x%llx lblk 0x%llx len 0x%x", +- MAJOR(__entry->dev), MINOR(__entry->dev), +- __entry->ino, +- __entry->lblk, +- __entry->len) +-); +-TRACE_EVENT(xfs_reflink_remap, +- TP_PROTO(struct xfs_inode *ip, xfs_fileoff_t lblk, +- xfs_extlen_t len, xfs_fsblock_t new_pblk), +- TP_ARGS(ip, lblk, len, new_pblk), +- TP_STRUCT__entry( +- __field(dev_t, dev) +- __field(xfs_ino_t, ino) +- __field(xfs_fileoff_t, lblk) +- __field(xfs_extlen_t, len) +- __field(xfs_fsblock_t, new_pblk) +- ), +- TP_fast_assign( +- __entry->dev = VFS_I(ip)->i_sb->s_dev; +- __entry->ino = ip->i_ino; +- __entry->lblk = lblk; +- __entry->len = len; +- __entry->new_pblk = new_pblk; +- ), +- TP_printk("dev %d:%d ino 0x%llx lblk 0x%llx len 0x%x new_pblk %llu", +- MAJOR(__entry->dev), MINOR(__entry->dev), +- __entry->ino, +- __entry->lblk, +- __entry->len, +- __entry->new_pblk) +-); + DEFINE_DOUBLE_IO_EVENT(xfs_reflink_remap_range); + DEFINE_INODE_ERROR_EVENT(xfs_reflink_remap_range_error); + DEFINE_INODE_ERROR_EVENT(xfs_reflink_set_inode_flag_error); + DEFINE_INODE_ERROR_EVENT(xfs_reflink_update_inode_size_error); + DEFINE_INODE_ERROR_EVENT(xfs_reflink_remap_blocks_error); + DEFINE_INODE_ERROR_EVENT(xfs_reflink_remap_extent_error); ++DEFINE_INODE_IREC_EVENT(xfs_reflink_remap_extent_src); ++DEFINE_INODE_IREC_EVENT(xfs_reflink_remap_extent_dest); + + /* dedupe tracepoints */ + DEFINE_DOUBLE_IO_EVENT(xfs_reflink_compare_extents); +diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c +index 2ba9f071c5e97..47acf40960222 100644 +--- a/fs/xfs/xfs_trans.c ++++ b/fs/xfs/xfs_trans.c +@@ -107,7 +107,8 @@ xfs_trans_dup( + + ntp->t_flags = XFS_TRANS_PERM_LOG_RES | + (tp->t_flags & XFS_TRANS_RESERVE) | +- (tp->t_flags & XFS_TRANS_NO_WRITECOUNT); ++ (tp->t_flags & XFS_TRANS_NO_WRITECOUNT) | ++ (tp->t_flags & XFS_TRANS_RES_FDBLKS); + /* We gave our writer reference to the new transaction */ + tp->t_flags |= XFS_TRANS_NO_WRITECOUNT; + ntp->t_ticket = xfs_log_ticket_get(tp->t_ticket); +@@ -273,6 +274,8 @@ xfs_trans_alloc( + */ + WARN_ON(resp->tr_logres > 0 && + mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE); ++ ASSERT(!(flags & XFS_TRANS_RES_FDBLKS) || ++ xfs_sb_version_haslazysbcount(&mp->m_sb)); + atomic_inc(&mp->m_active_trans); + + tp->t_magic = XFS_TRANS_HEADER_MAGIC; +@@ -368,6 +371,20 @@ xfs_trans_mod_sb( + tp->t_blk_res_used += (uint)-delta; + if (tp->t_blk_res_used > tp->t_blk_res) + xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); ++ } else if (delta > 0 && (tp->t_flags & XFS_TRANS_RES_FDBLKS)) { ++ int64_t blkres_delta; ++ ++ /* ++ * Return freed blocks directly to the reservation ++ * instead of the global pool, being careful not to ++ * overflow the trans counter. This is used to preserve ++ * reservation across chains of transaction rolls that ++ * repeatedly free and allocate blocks. ++ */ ++ blkres_delta = min_t(int64_t, delta, ++ UINT_MAX - tp->t_blk_res); ++ tp->t_blk_res += blkres_delta; ++ delta -= blkres_delta; + } + tp->t_fdblocks_delta += delta; + if (xfs_sb_version_haslazysbcount(&mp->m_sb)) +diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c +index af782a7de21a6..a41ba155d3a35 100644 +--- a/fs/xfs/xfs_trans_ail.c ++++ b/fs/xfs/xfs_trans_ail.c +@@ -402,16 +402,10 @@ xfsaild_push( + target = ailp->ail_target; + ailp->ail_target_prev = target; + ++ /* we're done if the AIL is empty or our push has reached the end */ + lip = xfs_trans_ail_cursor_first(ailp, &cur, ailp->ail_last_pushed_lsn); +- if (!lip) { +- /* +- * If the AIL is empty or our push has reached the end we are +- * done now. +- */ +- xfs_trans_ail_cursor_done(&cur); +- spin_unlock(&ailp->ail_lock); ++ if (!lip) + goto out_done; +- } + + XFS_STATS_INC(mp, xs_push_ail); + +@@ -493,6 +487,8 @@ xfsaild_push( + break; + lsn = lip->li_lsn; + } ++ ++out_done: + xfs_trans_ail_cursor_done(&cur); + spin_unlock(&ailp->ail_lock); + +@@ -500,7 +496,6 @@ xfsaild_push( + ailp->ail_log_flush++; + + if (!count || XFS_LSN_CMP(lsn, target) >= 0) { +-out_done: + /* + * We reached the target or the AIL is empty, so wait a bit + * longer for I/O to complete and remove pushed items from the +@@ -592,7 +587,8 @@ xfsaild( + */ + smp_rmb(); + if (!xfs_ail_min(ailp) && +- ailp->ail_target == ailp->ail_target_prev) { ++ ailp->ail_target == ailp->ail_target_prev && ++ list_empty(&ailp->ail_buf_list)) { + spin_unlock(&ailp->ail_lock); + freezable_schedule(); + tout = 0; +diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h +index 77d4281815579..c3bcac22c3894 100644 +--- a/include/asm-generic/vmlinux.lds.h ++++ b/include/asm-generic/vmlinux.lds.h +@@ -273,6 +273,7 @@ + #define DATA_DATA \ + *(.xiptext) \ + *(DATA_MAIN) \ ++ *(.data..decrypted) \ + *(.ref.data) \ + *(.data..shared_aligned) /* percpu related */ \ + MEM_KEEP(init.data*) \ +@@ -883,7 +884,6 @@ + #ifdef CONFIG_AMD_MEM_ENCRYPT + #define PERCPU_DECRYPTED_SECTION \ + . = ALIGN(PAGE_SIZE); \ +- *(.data..decrypted) \ + *(.data..percpu..decrypted) \ + . = ALIGN(PAGE_SIZE); + #else +diff --git a/include/uapi/linux/capability.h b/include/uapi/linux/capability.h +index 240fdb9a60f68..6e0d68e841cdb 100644 +--- a/include/uapi/linux/capability.h ++++ b/include/uapi/linux/capability.h +@@ -376,7 +376,7 @@ struct vfs_ns_cap_data { + */ + + #define CAP_TO_INDEX(x) ((x) >> 5) /* 1 << 5 == bits in __u32 */ +-#define CAP_TO_MASK(x) (1 << ((x) & 31)) /* mask for indexed __u32 */ ++#define CAP_TO_MASK(x) (1U << ((x) & 31)) /* mask for indexed __u32 */ + + + #endif /* _UAPI_LINUX_CAPABILITY_H */ +diff --git a/kernel/kprobes.c b/kernel/kprobes.c +index f8ea8cf694c6c..3de56ca280171 100644 +--- a/kernel/kprobes.c ++++ b/kernel/kprobes.c +@@ -1792,7 +1792,13 @@ static int __unregister_kprobe_top(struct kprobe *p) + if ((list_p != p) && (list_p->post_handler)) + goto noclean; + } +- ap->post_handler = NULL; ++ /* ++ * For the kprobe-on-ftrace case, we keep the ++ * post_handler setting to identify this aggrprobe ++ * armed with kprobe_ipmodify_ops. ++ */ ++ if (!kprobe_ftrace(ap)) ++ ap->post_handler = NULL; + } + noclean: + /* +diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c +index 5374ee664ed32..61f8c78daf178 100644 +--- a/kernel/trace/ftrace.c ++++ b/kernel/trace/ftrace.c +@@ -1307,6 +1307,7 @@ static int ftrace_add_mod(struct trace_array *tr, + if (!ftrace_mod) + return -ENOMEM; + ++ INIT_LIST_HEAD(&ftrace_mod->list); + ftrace_mod->func = kstrdup(func, GFP_KERNEL); + ftrace_mod->module = kstrdup(module, GFP_KERNEL); + ftrace_mod->enable = enable; +@@ -3017,7 +3018,7 @@ static int ftrace_allocate_records(struct ftrace_page *pg, int count) + /* if we can't allocate this size, try something smaller */ + if (!order) + return -ENOMEM; +- order >>= 1; ++ order--; + goto again; + } + +@@ -6259,7 +6260,7 @@ void __init ftrace_init(void) + } + + pr_info("ftrace: allocating %ld entries in %ld pages\n", +- count, count / ENTRIES_PER_PAGE + 1); ++ count, DIV_ROUND_UP(count, ENTRIES_PER_PAGE)); + + last_ftrace_enabled = ftrace_enabled = 1; + +diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c +index b0b640d396ab3..c4234430afeac 100644 +--- a/kernel/trace/ring_buffer.c ++++ b/kernel/trace/ring_buffer.c +@@ -477,6 +477,7 @@ struct ring_buffer_per_cpu { + local_t committing; + local_t commits; + local_t pages_touched; ++ local_t pages_lost; + local_t pages_read; + long last_pages_touch; + size_t shortest_full; +@@ -544,10 +545,18 @@ size_t ring_buffer_nr_pages(struct ring_buffer *buffer, int cpu) + size_t ring_buffer_nr_dirty_pages(struct ring_buffer *buffer, int cpu) + { + size_t read; ++ size_t lost; + size_t cnt; + + read = local_read(&buffer->buffers[cpu]->pages_read); ++ lost = local_read(&buffer->buffers[cpu]->pages_lost); + cnt = local_read(&buffer->buffers[cpu]->pages_touched); ++ ++ if (WARN_ON_ONCE(cnt < lost)) ++ return 0; ++ ++ cnt -= lost; ++ + /* The reader can read an empty page, but not more than that */ + if (cnt < read) { + WARN_ON_ONCE(read > cnt + 1); +@@ -1362,9 +1371,9 @@ static void rb_free_cpu_buffer(struct ring_buffer_per_cpu *cpu_buffer) + + free_buffer_page(cpu_buffer->reader_page); + +- rb_head_page_deactivate(cpu_buffer); +- + if (head) { ++ rb_head_page_deactivate(cpu_buffer); ++ + list_for_each_entry_safe(bpage, tmp, head, list) { + list_del_init(&bpage->list); + free_buffer_page(bpage); +@@ -1599,6 +1608,7 @@ rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned long nr_pages) + */ + local_add(page_entries, &cpu_buffer->overrun); + local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes); ++ local_inc(&cpu_buffer->pages_lost); + } + + /* +@@ -2023,6 +2033,7 @@ rb_handle_head_page(struct ring_buffer_per_cpu *cpu_buffer, + */ + local_add(entries, &cpu_buffer->overrun); + local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes); ++ local_inc(&cpu_buffer->pages_lost); + + /* + * The entries will be zeroed out when we move the +@@ -4475,6 +4486,7 @@ rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer) + local_set(&cpu_buffer->committing, 0); + local_set(&cpu_buffer->commits, 0); + local_set(&cpu_buffer->pages_touched, 0); ++ local_set(&cpu_buffer->pages_lost, 0); + local_set(&cpu_buffer->pages_read, 0); + cpu_buffer->last_pages_touch = 0; + cpu_buffer->shortest_full = 0; +diff --git a/mm/filemap.c b/mm/filemap.c +index c10e237cc2c6e..c094103191a6e 100644 +--- a/mm/filemap.c ++++ b/mm/filemap.c +@@ -3281,7 +3281,7 @@ ssize_t generic_perform_write(struct file *file, + unsigned long offset; /* Offset into pagecache page */ + unsigned long bytes; /* Bytes to write to page */ + size_t copied; /* Bytes copied from user */ +- void *fsdata; ++ void *fsdata = NULL; + + offset = (pos & (PAGE_SIZE - 1)); + bytes = min_t(unsigned long, PAGE_SIZE - offset, +diff --git a/net/9p/trans_fd.c b/net/9p/trans_fd.c +index 60eb9a2b209be..b691871d9a029 100644 +--- a/net/9p/trans_fd.c ++++ b/net/9p/trans_fd.c +@@ -205,6 +205,8 @@ static void p9_conn_cancel(struct p9_conn *m, int err) + list_move(&req->req_list, &cancel_list); + } + ++ spin_unlock(&m->client->lock); ++ + list_for_each_entry_safe(req, rtmp, &cancel_list, req_list) { + p9_debug(P9_DEBUG_ERROR, "call back req %p\n", req); + list_del(&req->req_list); +@@ -212,7 +214,6 @@ static void p9_conn_cancel(struct p9_conn *m, int err) + req->t_err = err; + p9_client_cb(m->client, req, REQ_STATUS_ERROR); + } +- spin_unlock(&m->client->lock); + } + + static __poll_t +@@ -820,11 +821,14 @@ static int p9_fd_open(struct p9_client *client, int rfd, int wfd) + goto out_free_ts; + if (!(ts->rd->f_mode & FMODE_READ)) + goto out_put_rd; ++ /* prevent workers from hanging on IO when fd is a pipe */ ++ ts->rd->f_flags |= O_NONBLOCK; + ts->wr = fget(wfd); + if (!ts->wr) + goto out_put_rd; + if (!(ts->wr->f_mode & FMODE_WRITE)) + goto out_put_wr; ++ ts->wr->f_flags |= O_NONBLOCK; + + client->trans = ts; + client->status = Connected; +diff --git a/net/bluetooth/l2cap_core.c b/net/bluetooth/l2cap_core.c +index c0cdc28e1d1ed..afa7fc55555e5 100644 +--- a/net/bluetooth/l2cap_core.c ++++ b/net/bluetooth/l2cap_core.c +@@ -1833,7 +1833,7 @@ static struct l2cap_chan *l2cap_global_chan_by_psm(int state, __le16 psm, + if (link_type == LE_LINK && c->src_type == BDADDR_BREDR) + continue; + +- if (c->psm == psm) { ++ if (c->chan_type != L2CAP_CHAN_FIXED && c->psm == psm) { + int src_match, dst_match; + int src_any, dst_any; + +diff --git a/net/bpf/test_run.c b/net/bpf/test_run.c +index 5e6428cbd7580..d78c4cc30a288 100644 +--- a/net/bpf/test_run.c ++++ b/net/bpf/test_run.c +@@ -114,6 +114,7 @@ static void *bpf_test_init(const union bpf_attr *kattr, u32 size, + if (size < ETH_HLEN || size > PAGE_SIZE - headroom - tailroom) + return ERR_PTR(-EINVAL); + ++ size = SKB_DATA_ALIGN(size); + data = kzalloc(size + headroom + tailroom, GFP_USER); + if (!data) + return ERR_PTR(-ENOMEM); +diff --git a/net/caif/chnl_net.c b/net/caif/chnl_net.c +index 910f164dd20cb..4dfac31f9466a 100644 +--- a/net/caif/chnl_net.c ++++ b/net/caif/chnl_net.c +@@ -314,9 +314,6 @@ static int chnl_net_open(struct net_device *dev) + + if (result == 0) { + pr_debug("connect timeout\n"); +- caif_disconnect_client(dev_net(dev), &priv->chnl); +- priv->state = CAIF_DISCONNECTED; +- pr_debug("state disconnected\n"); + result = -ETIMEDOUT; + goto error; + } +diff --git a/net/can/af_can.c b/net/can/af_can.c +index c758a12ffe461..f7dc68cd86e4b 100644 +--- a/net/can/af_can.c ++++ b/net/can/af_can.c +@@ -450,7 +450,7 @@ int can_rx_register(struct net *net, struct net_device *dev, canid_t can_id, + + /* insert new receiver (dev,canid,mask) -> (func,data) */ + +- if (dev && dev->type != ARPHRD_CAN) ++ if (dev && (dev->type != ARPHRD_CAN || !can_get_ml_priv(dev))) + return -ENODEV; + + if (dev && !net_eq(net, dev_net(dev))) +diff --git a/net/can/j1939/main.c b/net/can/j1939/main.c +index ca75d1b8f415c..9da8fbc81c04a 100644 +--- a/net/can/j1939/main.c ++++ b/net/can/j1939/main.c +@@ -332,6 +332,9 @@ int j1939_send_one(struct j1939_priv *priv, struct sk_buff *skb) + /* re-claim the CAN_HDR from the SKB */ + cf = skb_push(skb, J1939_CAN_HDR); + ++ /* initialize header structure */ ++ memset(cf, 0, J1939_CAN_HDR); ++ + /* make it a full can frame again */ + skb_put(skb, J1939_CAN_FTR + (8 - dlc)); + +diff --git a/net/core/skbuff.c b/net/core/skbuff.c +index c9fe2c0b8cae3..e9c796e2944ef 100644 +--- a/net/core/skbuff.c ++++ b/net/core/skbuff.c +@@ -3700,23 +3700,25 @@ struct sk_buff *skb_segment(struct sk_buff *head_skb, + int pos; + int dummy; + +- if (list_skb && !list_skb->head_frag && skb_headlen(list_skb) && +- (skb_shinfo(head_skb)->gso_type & SKB_GSO_DODGY)) { +- /* gso_size is untrusted, and we have a frag_list with a linear +- * non head_frag head. +- * +- * (we assume checking the first list_skb member suffices; +- * i.e if either of the list_skb members have non head_frag +- * head, then the first one has too). +- * +- * If head_skb's headlen does not fit requested gso_size, it +- * means that the frag_list members do NOT terminate on exact +- * gso_size boundaries. Hence we cannot perform skb_frag_t page +- * sharing. Therefore we must fallback to copying the frag_list +- * skbs; we do so by disabling SG. +- */ +- if (mss != GSO_BY_FRAGS && mss != skb_headlen(head_skb)) +- features &= ~NETIF_F_SG; ++ if ((skb_shinfo(head_skb)->gso_type & SKB_GSO_DODGY) && ++ mss != GSO_BY_FRAGS && mss != skb_headlen(head_skb)) { ++ struct sk_buff *check_skb; ++ ++ for (check_skb = list_skb; check_skb; check_skb = check_skb->next) { ++ if (skb_headlen(check_skb) && !check_skb->head_frag) { ++ /* gso_size is untrusted, and we have a frag_list with ++ * a linear non head_frag item. ++ * ++ * If head_skb's headlen does not fit requested gso_size, ++ * it means that the frag_list members do NOT terminate ++ * on exact gso_size boundaries. Hence we cannot perform ++ * skb_frag_t page sharing. Therefore we must fallback to ++ * copying the frag_list skbs; we do so by disabling SG. ++ */ ++ features &= ~NETIF_F_SG; ++ break; ++ } ++ } + } + + __skb_push(head_skb, doffset); +diff --git a/net/ipv4/tcp_bpf.c b/net/ipv4/tcp_bpf.c +index bcc13368c8363..f69dcd3c7797a 100644 +--- a/net/ipv4/tcp_bpf.c ++++ b/net/ipv4/tcp_bpf.c +@@ -311,7 +311,7 @@ static int tcp_bpf_send_verdict(struct sock *sk, struct sk_psock *psock, + { + bool cork = false, enospc = sk_msg_full(msg); + struct sock *sk_redir; +- u32 tosend, delta = 0; ++ u32 tosend, origsize, sent, delta = 0; + u32 eval = __SK_NONE; + int ret; + +@@ -366,10 +366,12 @@ more_data: + cork = true; + psock->cork = NULL; + } +- sk_msg_return(sk, msg, msg->sg.size); ++ sk_msg_return(sk, msg, tosend); + release_sock(sk); + ++ origsize = msg->sg.size; + ret = tcp_bpf_sendmsg_redir(sk_redir, msg, tosend, flags); ++ sent = origsize - msg->sg.size; + + if (eval == __SK_REDIRECT) + sock_put(sk_redir); +@@ -408,7 +410,7 @@ more_data: + msg->sg.data[msg->sg.start].page_link && + msg->sg.data[msg->sg.start].length) { + if (eval == __SK_REDIRECT) +- sk_mem_charge(sk, msg->sg.size); ++ sk_mem_charge(sk, tosend - sent); + goto more_data; + } + } +diff --git a/net/ipv4/tcp_cdg.c b/net/ipv4/tcp_cdg.c +index 709d238018239..56dede4b59d95 100644 +--- a/net/ipv4/tcp_cdg.c ++++ b/net/ipv4/tcp_cdg.c +@@ -375,6 +375,7 @@ static void tcp_cdg_init(struct sock *sk) + struct cdg *ca = inet_csk_ca(sk); + struct tcp_sock *tp = tcp_sk(sk); + ++ ca->gradients = NULL; + /* We silently fall back to window = 1 if allocation fails. */ + if (window > 1) + ca->gradients = kcalloc(window, sizeof(ca->gradients[0]), +@@ -388,6 +389,7 @@ static void tcp_cdg_release(struct sock *sk) + struct cdg *ca = inet_csk_ca(sk); + + kfree(ca->gradients); ++ ca->gradients = NULL; + } + + static struct tcp_congestion_ops tcp_cdg __read_mostly = { +diff --git a/net/ipv6/addrlabel.c b/net/ipv6/addrlabel.c +index 8a22486cf2702..17ac45aa7194c 100644 +--- a/net/ipv6/addrlabel.c ++++ b/net/ipv6/addrlabel.c +@@ -437,6 +437,7 @@ static void ip6addrlbl_putmsg(struct nlmsghdr *nlh, + { + struct ifaddrlblmsg *ifal = nlmsg_data(nlh); + ifal->ifal_family = AF_INET6; ++ ifal->__ifal_reserved = 0; + ifal->ifal_prefixlen = prefixlen; + ifal->ifal_flags = 0; + ifal->ifal_index = ifindex; +diff --git a/net/kcm/kcmsock.c b/net/kcm/kcmsock.c +index d76c98fe9949b..1975403ce8bee 100644 +--- a/net/kcm/kcmsock.c ++++ b/net/kcm/kcmsock.c +@@ -221,7 +221,7 @@ static void requeue_rx_msgs(struct kcm_mux *mux, struct sk_buff_head *head) + struct sk_buff *skb; + struct kcm_sock *kcm; + +- while ((skb = __skb_dequeue(head))) { ++ while ((skb = skb_dequeue(head))) { + /* Reset destructor to avoid calling kcm_rcv_ready */ + skb->destructor = sock_rfree; + skb_orphan(skb); +@@ -1086,53 +1086,18 @@ out_error: + return err; + } + +-static struct sk_buff *kcm_wait_data(struct sock *sk, int flags, +- long timeo, int *err) +-{ +- struct sk_buff *skb; +- +- while (!(skb = skb_peek(&sk->sk_receive_queue))) { +- if (sk->sk_err) { +- *err = sock_error(sk); +- return NULL; +- } +- +- if (sock_flag(sk, SOCK_DONE)) +- return NULL; +- +- if ((flags & MSG_DONTWAIT) || !timeo) { +- *err = -EAGAIN; +- return NULL; +- } +- +- sk_wait_data(sk, &timeo, NULL); +- +- /* Handle signals */ +- if (signal_pending(current)) { +- *err = sock_intr_errno(timeo); +- return NULL; +- } +- } +- +- return skb; +-} +- + static int kcm_recvmsg(struct socket *sock, struct msghdr *msg, + size_t len, int flags) + { ++ int noblock = flags & MSG_DONTWAIT; + struct sock *sk = sock->sk; + struct kcm_sock *kcm = kcm_sk(sk); + int err = 0; +- long timeo; + struct strp_msg *stm; + int copied = 0; + struct sk_buff *skb; + +- timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); +- +- lock_sock(sk); +- +- skb = kcm_wait_data(sk, flags, timeo, &err); ++ skb = skb_recv_datagram(sk, flags, noblock, &err); + if (!skb) + goto out; + +@@ -1163,14 +1128,11 @@ msg_finished: + /* Finished with message */ + msg->msg_flags |= MSG_EOR; + KCM_STATS_INCR(kcm->stats.rx_msgs); +- skb_unlink(skb, &sk->sk_receive_queue); +- kfree_skb(skb); + } + } + + out: +- release_sock(sk); +- ++ skb_free_datagram(sk, skb); + return copied ? : err; + } + +@@ -1178,9 +1140,9 @@ static ssize_t kcm_splice_read(struct socket *sock, loff_t *ppos, + struct pipe_inode_info *pipe, size_t len, + unsigned int flags) + { ++ int noblock = flags & MSG_DONTWAIT; + struct sock *sk = sock->sk; + struct kcm_sock *kcm = kcm_sk(sk); +- long timeo; + struct strp_msg *stm; + int err = 0; + ssize_t copied; +@@ -1188,11 +1150,7 @@ static ssize_t kcm_splice_read(struct socket *sock, loff_t *ppos, + + /* Only support splice for SOCKSEQPACKET */ + +- timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); +- +- lock_sock(sk); +- +- skb = kcm_wait_data(sk, flags, timeo, &err); ++ skb = skb_recv_datagram(sk, flags, noblock, &err); + if (!skb) + goto err_out; + +@@ -1220,13 +1178,11 @@ static ssize_t kcm_splice_read(struct socket *sock, loff_t *ppos, + * finish reading the message. + */ + +- release_sock(sk); +- ++ skb_free_datagram(sk, skb); + return copied; + + err_out: +- release_sock(sk); +- ++ skb_free_datagram(sk, skb); + return err; + } + +@@ -1846,10 +1802,10 @@ static int kcm_release(struct socket *sock) + kcm = kcm_sk(sk); + mux = kcm->mux; + ++ lock_sock(sk); + sock_orphan(sk); + kfree_skb(kcm->seq_skb); + +- lock_sock(sk); + /* Purge queue under lock to avoid race condition with tx_work trying + * to act when queue is nonempty. If tx_work runs after this point + * it will just return. +diff --git a/net/tipc/netlink_compat.c b/net/tipc/netlink_compat.c +index 561ea834f7327..bef28e900b3ed 100644 +--- a/net/tipc/netlink_compat.c ++++ b/net/tipc/netlink_compat.c +@@ -857,7 +857,7 @@ static int tipc_nl_compat_name_table_dump_header(struct tipc_nl_compat_msg *msg) + }; + + ntq = (struct tipc_name_table_query *)TLV_DATA(msg->req); +- if (TLV_GET_DATA_LEN(msg->req) < sizeof(struct tipc_name_table_query)) ++ if (TLV_GET_DATA_LEN(msg->req) < (int)sizeof(struct tipc_name_table_query)) + return -EINVAL; + + depth = ntohl(ntq->depth); +diff --git a/net/wireless/reg.c b/net/wireless/reg.c +index 74caece779633..4db397db2fb45 100644 +--- a/net/wireless/reg.c ++++ b/net/wireless/reg.c +@@ -1060,6 +1060,8 @@ static void regdb_fw_cb(const struct firmware *fw, void *context) + + static int query_regdb_file(const char *alpha2) + { ++ int err; ++ + ASSERT_RTNL(); + + if (regdb) +@@ -1069,9 +1071,13 @@ static int query_regdb_file(const char *alpha2) + if (!alpha2) + return -ENOMEM; + +- return request_firmware_nowait(THIS_MODULE, true, "regulatory.db", +- ®_pdev->dev, GFP_KERNEL, +- (void *)alpha2, regdb_fw_cb); ++ err = request_firmware_nowait(THIS_MODULE, true, "regulatory.db", ++ ®_pdev->dev, GFP_KERNEL, ++ (void *)alpha2, regdb_fw_cb); ++ if (err) ++ kfree(alpha2); ++ ++ return err; + } + + int reg_reload_regdb(void) +diff --git a/net/wireless/scan.c b/net/wireless/scan.c +index c433235e6390a..630c64520516a 100644 +--- a/net/wireless/scan.c ++++ b/net/wireless/scan.c +@@ -1166,7 +1166,9 @@ cfg80211_update_known_bss(struct cfg80211_registered_device *rdev, + if (old == rcu_access_pointer(known->pub.ies)) + rcu_assign_pointer(known->pub.ies, new->pub.beacon_ies); + +- cfg80211_update_hidden_bsses(known, new->pub.beacon_ies, old); ++ cfg80211_update_hidden_bsses(known, ++ rcu_access_pointer(new->pub.beacon_ies), ++ old); + + if (old) + kfree_rcu((struct cfg80211_bss_ies *)old, rcu_head); +diff --git a/net/x25/x25_dev.c b/net/x25/x25_dev.c +index 25bf72ee6cad0..226397add422a 100644 +--- a/net/x25/x25_dev.c ++++ b/net/x25/x25_dev.c +@@ -117,7 +117,7 @@ int x25_lapb_receive_frame(struct sk_buff *skb, struct net_device *dev, + + if (!pskb_may_pull(skb, 1)) { + x25_neigh_put(nb); +- return 0; ++ goto drop; + } + + switch (skb->data[0]) { +diff --git a/scripts/extract-cert.c b/scripts/extract-cert.c +index b071bf476fea7..dd1a4bd706a2e 100644 +--- a/scripts/extract-cert.c ++++ b/scripts/extract-cert.c +@@ -23,6 +23,13 @@ + #include <openssl/err.h> + #include <openssl/engine.h> + ++/* ++ * OpenSSL 3.0 deprecates the OpenSSL's ENGINE API. ++ * ++ * Remove this if/when that API is no longer used ++ */ ++#pragma GCC diagnostic ignored "-Wdeprecated-declarations" ++ + #define PKEY_ID_PKCS7 2 + + static __attribute__((noreturn)) +diff --git a/scripts/sign-file.c b/scripts/sign-file.c +index fbd34b8e8f578..7434e9ea926e2 100644 +--- a/scripts/sign-file.c ++++ b/scripts/sign-file.c +@@ -29,6 +29,13 @@ + #include <openssl/err.h> + #include <openssl/engine.h> + ++/* ++ * OpenSSL 3.0 deprecates the OpenSSL's ENGINE API. ++ * ++ * Remove this if/when that API is no longer used ++ */ ++#pragma GCC diagnostic ignored "-Wdeprecated-declarations" ++ + /* + * Use CMS if we have openssl-1.0.0 or newer available - otherwise we have to + * assume that it's not available and its header file is missing and that we +diff --git a/sound/hda/hdac_sysfs.c b/sound/hda/hdac_sysfs.c +index e56e833259031..bcf302f5115ac 100644 +--- a/sound/hda/hdac_sysfs.c ++++ b/sound/hda/hdac_sysfs.c +@@ -346,8 +346,10 @@ static int add_widget_node(struct kobject *parent, hda_nid_t nid, + return -ENOMEM; + kobject_init(kobj, &widget_ktype); + err = kobject_add(kobj, parent, "%02x", nid); +- if (err < 0) ++ if (err < 0) { ++ kobject_put(kobj); + return err; ++ } + err = sysfs_create_group(kobj, group); + if (err < 0) { + kobject_put(kobj); +diff --git a/sound/pci/hda/patch_ca0132.c b/sound/pci/hda/patch_ca0132.c +index 9412bdda85c82..3ef1084b66884 100644 +--- a/sound/pci/hda/patch_ca0132.c ++++ b/sound/pci/hda/patch_ca0132.c +@@ -1182,6 +1182,7 @@ static const struct snd_pci_quirk ca0132_quirks[] = { + SND_PCI_QUIRK(0x1458, 0xA026, "Gigabyte G1.Sniper Z97", QUIRK_R3DI), + SND_PCI_QUIRK(0x1458, 0xA036, "Gigabyte GA-Z170X-Gaming 7", QUIRK_R3DI), + SND_PCI_QUIRK(0x3842, 0x1038, "EVGA X99 Classified", QUIRK_R3DI), ++ SND_PCI_QUIRK(0x3842, 0x1055, "EVGA Z390 DARK", QUIRK_R3DI), + SND_PCI_QUIRK(0x1102, 0x0013, "Recon3D", QUIRK_R3D), + SND_PCI_QUIRK(0x1102, 0x0018, "Recon3D", QUIRK_R3D), + SND_PCI_QUIRK(0x1102, 0x0051, "Sound Blaster AE-5", QUIRK_AE5), +diff --git a/sound/soc/codecs/jz4725b.c b/sound/soc/codecs/jz4725b.c +index 2567a5d15b554..48c40a44b7632 100644 +--- a/sound/soc/codecs/jz4725b.c ++++ b/sound/soc/codecs/jz4725b.c +@@ -136,14 +136,17 @@ enum { + #define REG_CGR3_GO1L_OFFSET 0 + #define REG_CGR3_GO1L_MASK (0x1f << REG_CGR3_GO1L_OFFSET) + ++#define REG_CGR10_GIL_OFFSET 0 ++#define REG_CGR10_GIR_OFFSET 4 ++ + struct jz_icdc { + struct regmap *regmap; + void __iomem *base; + struct clk *clk; + }; + +-static const SNDRV_CTL_TLVD_DECLARE_DB_LINEAR(jz4725b_dac_tlv, -2250, 0); +-static const SNDRV_CTL_TLVD_DECLARE_DB_LINEAR(jz4725b_line_tlv, -1500, 600); ++static const SNDRV_CTL_TLVD_DECLARE_DB_SCALE(jz4725b_adc_tlv, 0, 150, 0); ++static const SNDRV_CTL_TLVD_DECLARE_DB_SCALE(jz4725b_dac_tlv, -2250, 150, 0); + + static const struct snd_kcontrol_new jz4725b_codec_controls[] = { + SOC_DOUBLE_TLV("Master Playback Volume", +@@ -151,11 +154,11 @@ static const struct snd_kcontrol_new jz4725b_codec_controls[] = { + REG_CGR1_GODL_OFFSET, + REG_CGR1_GODR_OFFSET, + 0xf, 1, jz4725b_dac_tlv), +- SOC_DOUBLE_R_TLV("Master Capture Volume", +- JZ4725B_CODEC_REG_CGR3, +- JZ4725B_CODEC_REG_CGR2, +- REG_CGR2_GO1R_OFFSET, +- 0x1f, 1, jz4725b_line_tlv), ++ SOC_DOUBLE_TLV("Master Capture Volume", ++ JZ4725B_CODEC_REG_CGR10, ++ REG_CGR10_GIL_OFFSET, ++ REG_CGR10_GIR_OFFSET, ++ 0xf, 0, jz4725b_adc_tlv), + + SOC_SINGLE("Master Playback Switch", JZ4725B_CODEC_REG_CR1, + REG_CR1_DAC_MUTE_OFFSET, 1, 1), +@@ -180,7 +183,7 @@ static SOC_VALUE_ENUM_SINGLE_DECL(jz4725b_codec_adc_src_enum, + jz4725b_codec_adc_src_texts, + jz4725b_codec_adc_src_values); + static const struct snd_kcontrol_new jz4725b_codec_adc_src_ctrl = +- SOC_DAPM_ENUM("Route", jz4725b_codec_adc_src_enum); ++ SOC_DAPM_ENUM("ADC Source Capture Route", jz4725b_codec_adc_src_enum); + + static const struct snd_kcontrol_new jz4725b_codec_mixer_controls[] = { + SOC_DAPM_SINGLE("Line In Bypass", JZ4725B_CODEC_REG_CR1, +@@ -225,7 +228,7 @@ static const struct snd_soc_dapm_widget jz4725b_codec_dapm_widgets[] = { + SND_SOC_DAPM_ADC("ADC", "Capture", + JZ4725B_CODEC_REG_PMR1, REG_PMR1_SB_ADC_OFFSET, 1), + +- SND_SOC_DAPM_MUX("ADC Source", SND_SOC_NOPM, 0, 0, ++ SND_SOC_DAPM_MUX("ADC Source Capture Route", SND_SOC_NOPM, 0, 0, + &jz4725b_codec_adc_src_ctrl), + + /* Mixer */ +@@ -236,7 +239,8 @@ static const struct snd_soc_dapm_widget jz4725b_codec_dapm_widgets[] = { + SND_SOC_DAPM_MIXER("DAC to Mixer", JZ4725B_CODEC_REG_CR1, + REG_CR1_DACSEL_OFFSET, 0, NULL, 0), + +- SND_SOC_DAPM_MIXER("Line In", SND_SOC_NOPM, 0, 0, NULL, 0), ++ SND_SOC_DAPM_MIXER("Line In", JZ4725B_CODEC_REG_PMR1, ++ REG_PMR1_SB_LIN_OFFSET, 1, NULL, 0), + SND_SOC_DAPM_MIXER("HP Out", JZ4725B_CODEC_REG_CR1, + REG_CR1_HP_DIS_OFFSET, 1, NULL, 0), + +@@ -283,11 +287,11 @@ static const struct snd_soc_dapm_route jz4725b_codec_dapm_routes[] = { + {"Mixer", NULL, "DAC to Mixer"}, + + {"Mixer to ADC", NULL, "Mixer"}, +- {"ADC Source", "Mixer", "Mixer to ADC"}, +- {"ADC Source", "Line In", "Line In"}, +- {"ADC Source", "Mic 1", "Mic 1"}, +- {"ADC Source", "Mic 2", "Mic 2"}, +- {"ADC", NULL, "ADC Source"}, ++ {"ADC Source Capture Route", "Mixer", "Mixer to ADC"}, ++ {"ADC Source Capture Route", "Line In", "Line In"}, ++ {"ADC Source Capture Route", "Mic 1", "Mic 1"}, ++ {"ADC Source Capture Route", "Mic 2", "Mic 2"}, ++ {"ADC", NULL, "ADC Source Capture Route"}, + + {"Out Stage", NULL, "Mixer"}, + {"HP Out", NULL, "Out Stage"}, +diff --git a/sound/soc/codecs/wm5102.c b/sound/soc/codecs/wm5102.c +index c5667b149c707..d6d4b4121369f 100644 +--- a/sound/soc/codecs/wm5102.c ++++ b/sound/soc/codecs/wm5102.c +@@ -2084,6 +2084,9 @@ static int wm5102_probe(struct platform_device *pdev) + regmap_update_bits(arizona->regmap, wm5102_digital_vu[i], + WM5102_DIG_VU, WM5102_DIG_VU); + ++ pm_runtime_enable(&pdev->dev); ++ pm_runtime_idle(&pdev->dev); ++ + ret = arizona_request_irq(arizona, ARIZONA_IRQ_DSP_IRQ1, + "ADSP2 Compressed IRQ", wm5102_adsp2_irq, + wm5102); +@@ -2116,9 +2119,6 @@ static int wm5102_probe(struct platform_device *pdev) + goto err_spk_irqs; + } + +- pm_runtime_enable(&pdev->dev); +- pm_runtime_idle(&pdev->dev); +- + return ret; + + err_spk_irqs: +diff --git a/sound/soc/codecs/wm5110.c b/sound/soc/codecs/wm5110.c +index bbe9fdfb423cc..06ec3f48c808a 100644 +--- a/sound/soc/codecs/wm5110.c ++++ b/sound/soc/codecs/wm5110.c +@@ -2452,6 +2452,9 @@ static int wm5110_probe(struct platform_device *pdev) + regmap_update_bits(arizona->regmap, wm5110_digital_vu[i], + WM5110_DIG_VU, WM5110_DIG_VU); + ++ pm_runtime_enable(&pdev->dev); ++ pm_runtime_idle(&pdev->dev); ++ + ret = arizona_request_irq(arizona, ARIZONA_IRQ_DSP_IRQ1, + "ADSP2 Compressed IRQ", wm5110_adsp2_irq, + wm5110); +@@ -2484,9 +2487,6 @@ static int wm5110_probe(struct platform_device *pdev) + goto err_spk_irqs; + } + +- pm_runtime_enable(&pdev->dev); +- pm_runtime_idle(&pdev->dev); +- + return ret; + + err_spk_irqs: +diff --git a/sound/soc/codecs/wm8962.c b/sound/soc/codecs/wm8962.c +index ebaee468057b8..c384ca3681e9b 100644 +--- a/sound/soc/codecs/wm8962.c ++++ b/sound/soc/codecs/wm8962.c +@@ -1840,6 +1840,49 @@ SOC_SINGLE_TLV("SPKOUTR Mixer DACR Volume", WM8962_SPEAKER_MIXER_5, + 4, 1, 0, inmix_tlv), + }; + ++static int tp_event(struct snd_soc_dapm_widget *w, ++ struct snd_kcontrol *kcontrol, int event) ++{ ++ int ret, reg, val, mask; ++ struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); ++ ++ ret = pm_runtime_resume_and_get(component->dev); ++ if (ret < 0) { ++ dev_err(component->dev, "Failed to resume device: %d\n", ret); ++ return ret; ++ } ++ ++ reg = WM8962_ADDITIONAL_CONTROL_4; ++ ++ if (!strcmp(w->name, "TEMP_HP")) { ++ mask = WM8962_TEMP_ENA_HP_MASK; ++ val = WM8962_TEMP_ENA_HP; ++ } else if (!strcmp(w->name, "TEMP_SPK")) { ++ mask = WM8962_TEMP_ENA_SPK_MASK; ++ val = WM8962_TEMP_ENA_SPK; ++ } else { ++ pm_runtime_put(component->dev); ++ return -EINVAL; ++ } ++ ++ switch (event) { ++ case SND_SOC_DAPM_POST_PMD: ++ val = 0; ++ fallthrough; ++ case SND_SOC_DAPM_POST_PMU: ++ ret = snd_soc_component_update_bits(component, reg, mask, val); ++ break; ++ default: ++ WARN(1, "Invalid event %d\n", event); ++ pm_runtime_put(component->dev); ++ return -EINVAL; ++ } ++ ++ pm_runtime_put(component->dev); ++ ++ return 0; ++} ++ + static int cp_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *kcontrol, int event) + { +@@ -2132,8 +2175,10 @@ SND_SOC_DAPM_SUPPLY("TOCLK", WM8962_ADDITIONAL_CONTROL_1, 0, 0, NULL, 0), + SND_SOC_DAPM_SUPPLY_S("DSP2", 1, WM8962_DSP2_POWER_MANAGEMENT, + WM8962_DSP2_ENA_SHIFT, 0, dsp2_event, + SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), +-SND_SOC_DAPM_SUPPLY("TEMP_HP", WM8962_ADDITIONAL_CONTROL_4, 2, 0, NULL, 0), +-SND_SOC_DAPM_SUPPLY("TEMP_SPK", WM8962_ADDITIONAL_CONTROL_4, 1, 0, NULL, 0), ++SND_SOC_DAPM_SUPPLY("TEMP_HP", SND_SOC_NOPM, 0, 0, tp_event, ++ SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD), ++SND_SOC_DAPM_SUPPLY("TEMP_SPK", SND_SOC_NOPM, 0, 0, tp_event, ++ SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD), + + SND_SOC_DAPM_MIXER("INPGAL", WM8962_LEFT_INPUT_PGA_CONTROL, 4, 0, + inpgal, ARRAY_SIZE(inpgal)), +@@ -3750,6 +3795,11 @@ static int wm8962_i2c_probe(struct i2c_client *i2c, + if (ret < 0) + goto err_pm_runtime; + ++ regmap_update_bits(wm8962->regmap, WM8962_ADDITIONAL_CONTROL_4, ++ WM8962_TEMP_ENA_HP_MASK, 0); ++ regmap_update_bits(wm8962->regmap, WM8962_ADDITIONAL_CONTROL_4, ++ WM8962_TEMP_ENA_SPK_MASK, 0); ++ + regcache_cache_only(wm8962->regmap, true); + + /* The drivers should power up as needed */ +diff --git a/sound/soc/codecs/wm8997.c b/sound/soc/codecs/wm8997.c +index 07378714b013a..229f2986cd96b 100644 +--- a/sound/soc/codecs/wm8997.c ++++ b/sound/soc/codecs/wm8997.c +@@ -1156,6 +1156,9 @@ static int wm8997_probe(struct platform_device *pdev) + regmap_update_bits(arizona->regmap, wm8997_digital_vu[i], + WM8997_DIG_VU, WM8997_DIG_VU); + ++ pm_runtime_enable(&pdev->dev); ++ pm_runtime_idle(&pdev->dev); ++ + arizona_init_common(arizona); + + ret = arizona_init_vol_limit(arizona); +@@ -1174,9 +1177,6 @@ static int wm8997_probe(struct platform_device *pdev) + goto err_spk_irqs; + } + +- pm_runtime_enable(&pdev->dev); +- pm_runtime_idle(&pdev->dev); +- + return ret; + + err_spk_irqs: +diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c +index 093ab32ea2c3a..2115fd412c78c 100644 +--- a/sound/soc/soc-core.c ++++ b/sound/soc/soc-core.c +@@ -3512,10 +3512,23 @@ EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_codecs); + + static int __init snd_soc_init(void) + { ++ int ret; ++ + snd_soc_debugfs_init(); +- snd_soc_util_init(); ++ ret = snd_soc_util_init(); ++ if (ret) ++ goto err_util_init; + +- return platform_driver_register(&soc_driver); ++ ret = platform_driver_register(&soc_driver); ++ if (ret) ++ goto err_register; ++ return 0; ++ ++err_register: ++ snd_soc_util_exit(); ++err_util_init: ++ snd_soc_debugfs_exit(); ++ return ret; + } + module_init(snd_soc_init); + +diff --git a/sound/soc/soc-utils.c b/sound/soc/soc-utils.c +index 54dcece52b0ce..abcc5d97b134e 100644 +--- a/sound/soc/soc-utils.c ++++ b/sound/soc/soc-utils.c +@@ -174,7 +174,7 @@ int __init snd_soc_util_init(void) + return ret; + } + +-void __exit snd_soc_util_exit(void) ++void snd_soc_util_exit(void) + { + platform_driver_unregister(&soc_dummy_driver); + platform_device_unregister(soc_dummy_dev); +diff --git a/sound/usb/midi.c b/sound/usb/midi.c +index ce501200e592f..f175c537353a0 100644 +--- a/sound/usb/midi.c ++++ b/sound/usb/midi.c +@@ -1149,10 +1149,8 @@ static int snd_usbmidi_output_open(struct snd_rawmidi_substream *substream) + port = &umidi->endpoints[i].out->ports[j]; + break; + } +- if (!port) { +- snd_BUG(); ++ if (!port) + return -ENXIO; +- } + + substream->runtime->private_data = port; + port->state = STATE_UNKNOWN; +diff --git a/sound/usb/quirks-table.h b/sound/usb/quirks-table.h +index 5f44b142a8b0b..06657412c6d8e 100644 +--- a/sound/usb/quirks-table.h ++++ b/sound/usb/quirks-table.h +@@ -2147,6 +2147,10 @@ YAMAHA_DEVICE(0x7010, "UB99"), + } + } + }, ++{ ++ /* M-Audio Micro */ ++ USB_DEVICE_VENDOR_SPEC(0x0763, 0x201a), ++}, + { + USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030), + .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { +diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c +index d61f95dc1abf7..28489aab6821f 100644 +--- a/sound/usb/quirks.c ++++ b/sound/usb/quirks.c +@@ -1676,6 +1676,7 @@ u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip, + /* XMOS based USB DACs */ + switch (chip->usb_id) { + case USB_ID(0x1511, 0x0037): /* AURALiC VEGA */ ++ case USB_ID(0x21ed, 0xd75a): /* Accuphase DAC-60 option card */ + case USB_ID(0x2522, 0x0012): /* LH Labs VI DAC Infinity */ + case USB_ID(0x2772, 0x0230): /* Pro-Ject Pre Box S2 Digital */ + if (fp->altsetting == 2) +diff --git a/tools/perf/util/stat-display.c b/tools/perf/util/stat-display.c +index 93147cc40162f..e18c26501a7fe 100644 +--- a/tools/perf/util/stat-display.c ++++ b/tools/perf/util/stat-display.c +@@ -193,7 +193,7 @@ static void new_line_csv(struct perf_stat_config *config, void *ctx) + + fputc('\n', os->fh); + if (os->prefix) +- fprintf(os->fh, "%s%s", os->prefix, config->csv_sep); ++ fprintf(os->fh, "%s", os->prefix); + aggr_printout(config, os->evsel, os->id, os->nr); + for (i = 0; i < os->nfields; i++) + fputs(config->csv_sep, os->fh); +diff --git a/tools/testing/selftests/futex/functional/Makefile b/tools/testing/selftests/futex/functional/Makefile +index 30996306cabcf..479531f5865d2 100644 +--- a/tools/testing/selftests/futex/functional/Makefile ++++ b/tools/testing/selftests/futex/functional/Makefile +@@ -3,11 +3,11 @@ INCLUDES := -I../include -I../../ + CFLAGS := $(CFLAGS) -g -O2 -Wall -D_GNU_SOURCE -pthread $(INCLUDES) + LDFLAGS := $(LDFLAGS) -pthread -lrt + +-HEADERS := \ ++LOCAL_HDRS := \ + ../include/futextest.h \ + ../include/atomic.h \ + ../include/logging.h +-TEST_GEN_FILES := \ ++TEST_GEN_PROGS := \ + futex_wait_timeout \ + futex_wait_wouldblock \ + futex_requeue_pi \ +@@ -21,5 +21,3 @@ TEST_PROGS := run.sh + top_srcdir = ../../../../.. + KSFT_KHDR_INSTALL := 1 + include ../../lib.mk +- +-$(TEST_GEN_FILES): $(HEADERS) +diff --git a/tools/testing/selftests/intel_pstate/Makefile b/tools/testing/selftests/intel_pstate/Makefile +index 7340fd6a9a9f2..9fc1a40b01276 100644 +--- a/tools/testing/selftests/intel_pstate/Makefile ++++ b/tools/testing/selftests/intel_pstate/Makefile +@@ -2,10 +2,10 @@ + CFLAGS := $(CFLAGS) -Wall -D_GNU_SOURCE + LDLIBS := $(LDLIBS) -lm + +-uname_M := $(shell uname -m 2>/dev/null || echo not) +-ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/x86/ -e s/x86_64/x86/) ++ARCH ?= $(shell uname -m 2>/dev/null || echo not) ++ARCH_PROCESSED := $(shell echo $(ARCH) | sed -e s/i.86/x86/ -e s/x86_64/x86/) + +-ifeq (x86,$(ARCH)) ++ifeq (x86,$(ARCH_PROCESSED)) + TEST_GEN_FILES := msr aperf + endif + +diff --git a/tools/testing/selftests/kvm/include/x86_64/processor.h b/tools/testing/selftests/kvm/include/x86_64/processor.h +index aead07c24afcf..d60f584e8d0f1 100644 +--- a/tools/testing/selftests/kvm/include/x86_64/processor.h ++++ b/tools/testing/selftests/kvm/include/x86_64/processor.h +@@ -635,6 +635,11 @@ void kvm_get_cpu_address_width(unsigned int *pa_bits, unsigned int *va_bits); + #define MSR_AMD64_OSVW_STATUS 0xc0010141 + #define MSR_AMD64_LS_CFG 0xc0011020 + #define MSR_AMD64_DC_CFG 0xc0011022 ++ ++#define MSR_AMD64_DE_CFG 0xc0011029 ++#define MSR_AMD64_DE_CFG_LFENCE_SERIALIZE_BIT 1 ++#define MSR_AMD64_DE_CFG_LFENCE_SERIALIZE BIT_ULL(MSR_AMD64_DE_CFG_LFENCE_SERIALIZE_BIT) ++ + #define MSR_AMD64_BU_CFG2 0xc001102a + #define MSR_AMD64_IBSFETCHCTL 0xc0011030 + #define MSR_AMD64_IBSFETCHLINAD 0xc0011031 +@@ -685,9 +690,6 @@ void kvm_get_cpu_address_width(unsigned int *pa_bits, unsigned int *va_bits); + #define FAM10H_MMIO_CONF_BASE_MASK 0xfffffffULL + #define FAM10H_MMIO_CONF_BASE_SHIFT 20 + #define MSR_FAM10H_NODE_ID 0xc001100c +-#define MSR_F10H_DECFG 0xc0011029 +-#define MSR_F10H_DECFG_LFENCE_SERIALIZE_BIT 1 +-#define MSR_F10H_DECFG_LFENCE_SERIALIZE BIT_ULL(MSR_F10H_DECFG_LFENCE_SERIALIZE_BIT) + + /* K8 MSRs */ + #define MSR_K8_TOP_MEM1 0xc001001a
