From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from lists.gentoo.org (pigeon.gentoo.org [208.92.234.80]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id E34B2138350 for ; Sun, 12 Jan 2020 15:01:22 +0000 (UTC) Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id 24AE7E0D10; Sun, 12 Jan 2020 15:01:22 +0000 (UTC) Received: from smtp.gentoo.org (smtp.gentoo.org [140.211.166.183]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by pigeon.gentoo.org (Postfix) with ESMTPS id C50AFE0D10 for ; Sun, 12 Jan 2020 15:01:21 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id 5D4A634DFB8 for ; Sun, 12 Jan 2020 15:01:20 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id C158E36 for ; Sun, 12 Jan 2020 15:01:18 +0000 (UTC) From: "Mike Pagano" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Mike Pagano" Message-ID: <1578841262.e611a1958ebdf6e895280efce1cfa08b17c5b4d9.mpagano@gentoo> Subject: [gentoo-commits] proj/linux-patches:5.4 commit in: / X-VCS-Repository: proj/linux-patches X-VCS-Files: 0000_README 1010_linux-5.4.11.patch X-VCS-Directories: / X-VCS-Committer: mpagano X-VCS-Committer-Name: Mike Pagano X-VCS-Revision: e611a1958ebdf6e895280efce1cfa08b17c5b4d9 X-VCS-Branch: 5.4 Date: Sun, 12 Jan 2020 15:01:18 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: 58fa4450-6c65-445c-b10c-629849a38c18 X-Archives-Hash: c6c65e3a648fe5f50e4ec1231a2cc812 commit: e611a1958ebdf6e895280efce1cfa08b17c5b4d9 Author: Mike Pagano gentoo org> AuthorDate: Sun Jan 12 15:01:02 2020 +0000 Commit: Mike Pagano gentoo org> CommitDate: Sun Jan 12 15:01:02 2020 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=e611a195 Linux patch 5.4.11 Signed-off-by: Mike Pagano gentoo.org> 0000_README | 4 + 1010_linux-5.4.11.patch | 5959 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 5963 insertions(+) diff --git a/0000_README b/0000_README index f39e13c..940c66a 100644 --- a/0000_README +++ b/0000_README @@ -83,6 +83,10 @@ Patch: 1009_linux-5.4.10.patch From: http://www.kernel.org Desc: Linux 5.4.10 +Patch: 1010_linux-5.4.11.patch +From: http://www.kernel.org +Desc: Linux 5.4.11 + 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/1010_linux-5.4.11.patch b/1010_linux-5.4.11.patch new file mode 100644 index 0000000..28d7a5b --- /dev/null +++ b/1010_linux-5.4.11.patch @@ -0,0 +1,5959 @@ +diff --git a/Makefile b/Makefile +index 726bb3dacd5b..e8963f623568 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 4 +-SUBLEVEL = 10 ++SUBLEVEL = 11 + EXTRAVERSION = + NAME = Kleptomaniac Octopus + +diff --git a/arch/arm/boot/dts/am335x-sancloud-bbe.dts b/arch/arm/boot/dts/am335x-sancloud-bbe.dts +index 8678e6e35493..e5fdb7abb0d5 100644 +--- a/arch/arm/boot/dts/am335x-sancloud-bbe.dts ++++ b/arch/arm/boot/dts/am335x-sancloud-bbe.dts +@@ -108,7 +108,7 @@ + + &cpsw_emac0 { + phy-handle = <ðphy0>; +- phy-mode = "rgmii-txid"; ++ phy-mode = "rgmii-id"; + }; + + &i2c0 { +diff --git a/arch/arm/boot/dts/am437x-gp-evm.dts b/arch/arm/boot/dts/am437x-gp-evm.dts +index cae4500194fe..811c8cae315b 100644 +--- a/arch/arm/boot/dts/am437x-gp-evm.dts ++++ b/arch/arm/boot/dts/am437x-gp-evm.dts +@@ -86,7 +86,7 @@ + }; + + lcd0: display { +- compatible = "osddisplays,osd057T0559-34ts", "panel-dpi"; ++ compatible = "osddisplays,osd070t1718-19ts", "panel-dpi"; + label = "lcd"; + + backlight = <&lcd_bl>; +diff --git a/arch/arm/boot/dts/am43x-epos-evm.dts b/arch/arm/boot/dts/am43x-epos-evm.dts +index 95314121d111..078cb473fa7d 100644 +--- a/arch/arm/boot/dts/am43x-epos-evm.dts ++++ b/arch/arm/boot/dts/am43x-epos-evm.dts +@@ -42,7 +42,7 @@ + }; + + lcd0: display { +- compatible = "osddisplays,osd057T0559-34ts", "panel-dpi"; ++ compatible = "osddisplays,osd070t1718-19ts", "panel-dpi"; + label = "lcd"; + + backlight = <&lcd_bl>; +diff --git a/arch/arm/boot/dts/bcm-cygnus.dtsi b/arch/arm/boot/dts/bcm-cygnus.dtsi +index 2dac3efc7640..1bc45cfd5453 100644 +--- a/arch/arm/boot/dts/bcm-cygnus.dtsi ++++ b/arch/arm/boot/dts/bcm-cygnus.dtsi +@@ -174,8 +174,8 @@ + mdio: mdio@18002000 { + compatible = "brcm,iproc-mdio"; + reg = <0x18002000 0x8>; +- #size-cells = <1>; +- #address-cells = <0>; ++ #size-cells = <0>; ++ #address-cells = <1>; + status = "disabled"; + + gphy0: ethernet-phy@0 { +diff --git a/arch/arm/boot/dts/bcm283x.dtsi b/arch/arm/boot/dts/bcm283x.dtsi +index 2d191fcbc2cc..90125ce19a1b 100644 +--- a/arch/arm/boot/dts/bcm283x.dtsi ++++ b/arch/arm/boot/dts/bcm283x.dtsi +@@ -40,7 +40,7 @@ + + trips { + cpu-crit { +- temperature = <80000>; ++ temperature = <90000>; + hysteresis = <0>; + type = "critical"; + }; +diff --git a/arch/arm/boot/dts/bcm5301x.dtsi b/arch/arm/boot/dts/bcm5301x.dtsi +index 372dc1eb88a0..2d9b4dd05830 100644 +--- a/arch/arm/boot/dts/bcm5301x.dtsi ++++ b/arch/arm/boot/dts/bcm5301x.dtsi +@@ -353,8 +353,8 @@ + mdio: mdio@18003000 { + compatible = "brcm,iproc-mdio"; + reg = <0x18003000 0x8>; +- #size-cells = <1>; +- #address-cells = <0>; ++ #size-cells = <0>; ++ #address-cells = <1>; + }; + + mdio-bus-mux@18003000 { +diff --git a/arch/arm/boot/dts/imx6ul-14x14-evk.dtsi b/arch/arm/boot/dts/imx6ul-14x14-evk.dtsi +index c2a9dd57e56a..aa86341adaaa 100644 +--- a/arch/arm/boot/dts/imx6ul-14x14-evk.dtsi ++++ b/arch/arm/boot/dts/imx6ul-14x14-evk.dtsi +@@ -215,7 +215,7 @@ + flash0: n25q256a@0 { + #address-cells = <1>; + #size-cells = <1>; +- compatible = "micron,n25q256a"; ++ compatible = "micron,n25q256a", "jedec,spi-nor"; + spi-max-frequency = <29000000>; + spi-rx-bus-width = <4>; + spi-tx-bus-width = <4>; +diff --git a/arch/arm/configs/exynos_defconfig b/arch/arm/configs/exynos_defconfig +index 08db1c83eb2d..736ed7a7bcf8 100644 +--- a/arch/arm/configs/exynos_defconfig ++++ b/arch/arm/configs/exynos_defconfig +@@ -348,6 +348,7 @@ CONFIG_PRINTK_TIME=y + CONFIG_DYNAMIC_DEBUG=y + CONFIG_DEBUG_INFO=y + CONFIG_MAGIC_SYSRQ=y ++CONFIG_DEBUG_FS=y + CONFIG_DEBUG_KERNEL=y + CONFIG_SOFTLOCKUP_DETECTOR=y + # CONFIG_DETECT_HUNG_TASK is not set +diff --git a/arch/arm/configs/imx_v6_v7_defconfig b/arch/arm/configs/imx_v6_v7_defconfig +index 0f7381ee0c37..dabb80453249 100644 +--- a/arch/arm/configs/imx_v6_v7_defconfig ++++ b/arch/arm/configs/imx_v6_v7_defconfig +@@ -460,6 +460,7 @@ CONFIG_FONT_8x8=y + CONFIG_FONT_8x16=y + CONFIG_PRINTK_TIME=y + CONFIG_MAGIC_SYSRQ=y ++CONFIG_DEBUG_FS=y + # CONFIG_SCHED_DEBUG is not set + CONFIG_PROVE_LOCKING=y + # CONFIG_DEBUG_BUGVERBOSE is not set +diff --git a/arch/arm/configs/omap2plus_defconfig b/arch/arm/configs/omap2plus_defconfig +index 40d7f1a4fc45..4ec69fb8a698 100644 +--- a/arch/arm/configs/omap2plus_defconfig ++++ b/arch/arm/configs/omap2plus_defconfig +@@ -552,5 +552,6 @@ CONFIG_DEBUG_INFO=y + CONFIG_DEBUG_INFO_SPLIT=y + CONFIG_DEBUG_INFO_DWARF4=y + CONFIG_MAGIC_SYSRQ=y ++CONFIG_DEBUG_FS=y + CONFIG_SCHEDSTATS=y + # CONFIG_DEBUG_BUGVERBOSE is not set +diff --git a/arch/arm/mach-vexpress/spc.c b/arch/arm/mach-vexpress/spc.c +index 354e0e7025ae..1da11bdb1dfb 100644 +--- a/arch/arm/mach-vexpress/spc.c ++++ b/arch/arm/mach-vexpress/spc.c +@@ -551,8 +551,9 @@ static struct clk *ve_spc_clk_register(struct device *cpu_dev) + + static int __init ve_spc_clk_init(void) + { +- int cpu; ++ int cpu, cluster; + struct clk *clk; ++ bool init_opp_table[MAX_CLUSTERS] = { false }; + + if (!info) + return 0; /* Continue only if SPC is initialised */ +@@ -578,8 +579,17 @@ static int __init ve_spc_clk_init(void) + continue; + } + ++ cluster = topology_physical_package_id(cpu_dev->id); ++ if (init_opp_table[cluster]) ++ continue; ++ + if (ve_init_opp_table(cpu_dev)) + pr_warn("failed to initialise cpu%d opp table\n", cpu); ++ else if (dev_pm_opp_set_sharing_cpus(cpu_dev, ++ topology_core_cpumask(cpu_dev->id))) ++ pr_warn("failed to mark OPPs shared for cpu%d\n", cpu); ++ else ++ init_opp_table[cluster] = true; + } + + platform_device_register_simple("vexpress-spc-cpufreq", -1, NULL, 0); +diff --git a/arch/arm64/boot/dts/freescale/fsl-ls1028a.dtsi b/arch/arm64/boot/dts/freescale/fsl-ls1028a.dtsi +index 72b9a75976a1..bb960fe2bb64 100644 +--- a/arch/arm64/boot/dts/freescale/fsl-ls1028a.dtsi ++++ b/arch/arm64/boot/dts/freescale/fsl-ls1028a.dtsi +@@ -102,7 +102,7 @@ + + reboot { + compatible ="syscon-reboot"; +- regmap = <&dcfg>; ++ regmap = <&rst>; + offset = <0xb0>; + mask = <0x02>; + }; +@@ -161,6 +161,12 @@ + big-endian; + }; + ++ rst: syscon@1e60000 { ++ compatible = "syscon"; ++ reg = <0x0 0x1e60000 0x0 0x10000>; ++ little-endian; ++ }; ++ + scfg: syscon@1fc0000 { + compatible = "fsl,ls1028a-scfg", "syscon"; + reg = <0x0 0x1fc0000 0x0 0x10000>; +@@ -567,7 +573,7 @@ + 0x00010004 0x0000003d + 0x00010005 0x00000045 + 0x00010006 0x0000004d +- 0x00010007 0x00000045 ++ 0x00010007 0x00000055 + 0x00010008 0x0000005e + 0x00010009 0x00000066 + 0x0001000a 0x0000006e +diff --git a/arch/arm64/kernel/cpu_errata.c b/arch/arm64/kernel/cpu_errata.c +index 93f34b4eca25..96f576e9ea46 100644 +--- a/arch/arm64/kernel/cpu_errata.c ++++ b/arch/arm64/kernel/cpu_errata.c +@@ -575,6 +575,7 @@ static const struct midr_range spectre_v2_safe_list[] = { + MIDR_ALL_VERSIONS(MIDR_CORTEX_A53), + MIDR_ALL_VERSIONS(MIDR_CORTEX_A55), + MIDR_ALL_VERSIONS(MIDR_BRAHMA_B53), ++ MIDR_ALL_VERSIONS(MIDR_HISI_TSV110), + { /* sentinel */ } + }; + +diff --git a/arch/mips/net/ebpf_jit.c b/arch/mips/net/ebpf_jit.c +index a2405d5f7d1e..561154cbcc40 100644 +--- a/arch/mips/net/ebpf_jit.c ++++ b/arch/mips/net/ebpf_jit.c +@@ -604,6 +604,7 @@ static void emit_const_to_reg(struct jit_ctx *ctx, int dst, u64 value) + static int emit_bpf_tail_call(struct jit_ctx *ctx, int this_idx) + { + int off, b_off; ++ int tcc_reg; + + ctx->flags |= EBPF_SEEN_TC; + /* +@@ -616,14 +617,14 @@ static int emit_bpf_tail_call(struct jit_ctx *ctx, int this_idx) + b_off = b_imm(this_idx + 1, ctx); + emit_instr(ctx, bne, MIPS_R_AT, MIPS_R_ZERO, b_off); + /* +- * if (--TCC < 0) ++ * if (TCC-- < 0) + * goto out; + */ + /* Delay slot */ +- emit_instr(ctx, daddiu, MIPS_R_T5, +- (ctx->flags & EBPF_TCC_IN_V1) ? MIPS_R_V1 : MIPS_R_S4, -1); ++ tcc_reg = (ctx->flags & EBPF_TCC_IN_V1) ? MIPS_R_V1 : MIPS_R_S4; ++ emit_instr(ctx, daddiu, MIPS_R_T5, tcc_reg, -1); + b_off = b_imm(this_idx + 1, ctx); +- emit_instr(ctx, bltz, MIPS_R_T5, b_off); ++ emit_instr(ctx, bltz, tcc_reg, b_off); + /* + * prog = array->ptrs[index]; + * if (prog == NULL) +diff --git a/arch/parisc/include/asm/cmpxchg.h b/arch/parisc/include/asm/cmpxchg.h +index f627c37dad9c..ab5c215cf46c 100644 +--- a/arch/parisc/include/asm/cmpxchg.h ++++ b/arch/parisc/include/asm/cmpxchg.h +@@ -44,8 +44,14 @@ __xchg(unsigned long x, __volatile__ void *ptr, int size) + ** if (((unsigned long)p & 0xf) == 0) + ** return __ldcw(p); + */ +-#define xchg(ptr, x) \ +- ((__typeof__(*(ptr)))__xchg((unsigned long)(x), (ptr), sizeof(*(ptr)))) ++#define xchg(ptr, x) \ ++({ \ ++ __typeof__(*(ptr)) __ret; \ ++ __typeof__(*(ptr)) _x_ = (x); \ ++ __ret = (__typeof__(*(ptr))) \ ++ __xchg((unsigned long)_x_, (ptr), sizeof(*(ptr))); \ ++ __ret; \ ++}) + + /* bug catcher for when unsupported size is used - won't link */ + extern void __cmpxchg_called_with_bad_pointer(void); +diff --git a/arch/parisc/include/asm/kexec.h b/arch/parisc/include/asm/kexec.h +index a99ea747d7ed..87e174006995 100644 +--- a/arch/parisc/include/asm/kexec.h ++++ b/arch/parisc/include/asm/kexec.h +@@ -2,8 +2,6 @@ + #ifndef _ASM_PARISC_KEXEC_H + #define _ASM_PARISC_KEXEC_H + +-#ifdef CONFIG_KEXEC +- + /* Maximum physical address we can use pages from */ + #define KEXEC_SOURCE_MEMORY_LIMIT (-1UL) + /* Maximum address we can reach in physical address mode */ +@@ -32,6 +30,4 @@ static inline void crash_setup_regs(struct pt_regs *newregs, + + #endif /* __ASSEMBLY__ */ + +-#endif /* CONFIG_KEXEC */ +- + #endif /* _ASM_PARISC_KEXEC_H */ +diff --git a/arch/parisc/kernel/Makefile b/arch/parisc/kernel/Makefile +index 2663c8f8be11..068d90950d93 100644 +--- a/arch/parisc/kernel/Makefile ++++ b/arch/parisc/kernel/Makefile +@@ -37,5 +37,5 @@ obj-$(CONFIG_FUNCTION_GRAPH_TRACER) += ftrace.o + obj-$(CONFIG_JUMP_LABEL) += jump_label.o + obj-$(CONFIG_KGDB) += kgdb.o + obj-$(CONFIG_KPROBES) += kprobes.o +-obj-$(CONFIG_KEXEC) += kexec.o relocate_kernel.o ++obj-$(CONFIG_KEXEC_CORE) += kexec.o relocate_kernel.o + obj-$(CONFIG_KEXEC_FILE) += kexec_file.o +diff --git a/arch/parisc/kernel/drivers.c b/arch/parisc/kernel/drivers.c +index 3b330e58a4f0..a6c9f49c6612 100644 +--- a/arch/parisc/kernel/drivers.c ++++ b/arch/parisc/kernel/drivers.c +@@ -810,7 +810,7 @@ EXPORT_SYMBOL(device_to_hwpath); + static void walk_native_bus(unsigned long io_io_low, unsigned long io_io_high, + struct device *parent); + +-static void walk_lower_bus(struct parisc_device *dev) ++static void __init walk_lower_bus(struct parisc_device *dev) + { + unsigned long io_io_low, io_io_high; + +diff --git a/arch/powerpc/include/asm/spinlock.h b/arch/powerpc/include/asm/spinlock.h +index e9a960e28f3c..d6102e34eb21 100644 +--- a/arch/powerpc/include/asm/spinlock.h ++++ b/arch/powerpc/include/asm/spinlock.h +@@ -15,6 +15,7 @@ + * + * (the type definitions are in asm/spinlock_types.h) + */ ++#include + #include + #ifdef CONFIG_PPC64 + #include +@@ -36,10 +37,12 @@ + #endif + + #ifdef CONFIG_PPC_PSERIES ++DECLARE_STATIC_KEY_FALSE(shared_processor); ++ + #define vcpu_is_preempted vcpu_is_preempted + static inline bool vcpu_is_preempted(int cpu) + { +- if (!firmware_has_feature(FW_FEATURE_SPLPAR)) ++ if (!static_branch_unlikely(&shared_processor)) + return false; + return !!(be32_to_cpu(lppaca_of(cpu).yield_count) & 1); + } +diff --git a/arch/powerpc/mm/mem.c b/arch/powerpc/mm/mem.c +index d30a2e6e68b4..9f5b32163bda 100644 +--- a/arch/powerpc/mm/mem.c ++++ b/arch/powerpc/mm/mem.c +@@ -282,6 +282,14 @@ void __init mem_init(void) + BUILD_BUG_ON(MMU_PAGE_COUNT > 16); + + #ifdef CONFIG_SWIOTLB ++ /* ++ * Some platforms (e.g. 85xx) limit DMA-able memory way below ++ * 4G. We force memblock to bottom-up mode to ensure that the ++ * memory allocated in swiotlb_init() is DMA-able. ++ * As it's the last memblock allocation, no need to reset it ++ * back to to-down. ++ */ ++ memblock_set_bottom_up(true); + swiotlb_init(0); + #endif + +diff --git a/arch/powerpc/platforms/pseries/setup.c b/arch/powerpc/platforms/pseries/setup.c +index 0a40201f315f..0c8421dd01ab 100644 +--- a/arch/powerpc/platforms/pseries/setup.c ++++ b/arch/powerpc/platforms/pseries/setup.c +@@ -74,6 +74,9 @@ + #include "pseries.h" + #include "../../../../drivers/pci/pci.h" + ++DEFINE_STATIC_KEY_FALSE(shared_processor); ++EXPORT_SYMBOL_GPL(shared_processor); ++ + int CMO_PrPSP = -1; + int CMO_SecPSP = -1; + unsigned long CMO_PageSize = (ASM_CONST(1) << IOMMU_PAGE_SHIFT_4K); +@@ -758,6 +761,10 @@ static void __init pSeries_setup_arch(void) + + if (firmware_has_feature(FW_FEATURE_LPAR)) { + vpa_init(boot_cpuid); ++ ++ if (lppaca_shared_proc(get_lppaca())) ++ static_branch_enable(&shared_processor); ++ + ppc_md.power_save = pseries_lpar_idle; + ppc_md.enable_pmcs = pseries_lpar_enable_pmcs; + #ifdef CONFIG_PCI_IOV +diff --git a/arch/riscv/net/bpf_jit_comp.c b/arch/riscv/net/bpf_jit_comp.c +index 5451ef3845f2..7fbf56aab661 100644 +--- a/arch/riscv/net/bpf_jit_comp.c ++++ b/arch/riscv/net/bpf_jit_comp.c +@@ -631,14 +631,14 @@ static int emit_bpf_tail_call(int insn, struct rv_jit_context *ctx) + return -1; + emit(rv_bgeu(RV_REG_A2, RV_REG_T1, off >> 1), ctx); + +- /* if (--TCC < 0) ++ /* if (TCC-- < 0) + * goto out; + */ + emit(rv_addi(RV_REG_T1, tcc, -1), ctx); + off = (tc_ninsn - (ctx->ninsns - start_insn)) << 2; + if (is_13b_check(off, insn)) + return -1; +- emit(rv_blt(RV_REG_T1, RV_REG_ZERO, off >> 1), ctx); ++ emit(rv_blt(tcc, RV_REG_ZERO, off >> 1), ctx); + + /* prog = array->ptrs[index]; + * if (!prog) +diff --git a/arch/s390/purgatory/Makefile b/arch/s390/purgatory/Makefile +index bc0d7a0d0394..9de56065f28c 100644 +--- a/arch/s390/purgatory/Makefile ++++ b/arch/s390/purgatory/Makefile +@@ -15,8 +15,10 @@ CFLAGS_sha256.o := -D__DISABLE_EXPORTS + $(obj)/mem.o: $(srctree)/arch/s390/lib/mem.S FORCE + $(call if_changed_rule,as_o_S) + +-$(obj)/string.o: $(srctree)/arch/s390/lib/string.c FORCE +- $(call if_changed_rule,cc_o_c) ++KCOV_INSTRUMENT := n ++GCOV_PROFILE := n ++UBSAN_SANITIZE := n ++KASAN_SANITIZE := n + + KBUILD_CFLAGS := -fno-strict-aliasing -Wall -Wstrict-prototypes + KBUILD_CFLAGS += -Wno-pointer-sign -Wno-sign-compare +diff --git a/arch/s390/purgatory/string.c b/arch/s390/purgatory/string.c +new file mode 100644 +index 000000000000..c98c22a72db7 +--- /dev/null ++++ b/arch/s390/purgatory/string.c +@@ -0,0 +1,3 @@ ++// SPDX-License-Identifier: GPL-2.0 ++#define __HAVE_ARCH_MEMCMP /* arch function */ ++#include "../lib/string.c" +diff --git a/arch/x86/events/core.c b/arch/x86/events/core.c +index 7b21455d7504..e622158f5659 100644 +--- a/arch/x86/events/core.c ++++ b/arch/x86/events/core.c +@@ -375,7 +375,7 @@ int x86_add_exclusive(unsigned int what) + * LBR and BTS are still mutually exclusive. + */ + if (x86_pmu.lbr_pt_coexist && what == x86_lbr_exclusive_pt) +- return 0; ++ goto out; + + if (!atomic_inc_not_zero(&x86_pmu.lbr_exclusive[what])) { + mutex_lock(&pmc_reserve_mutex); +@@ -387,6 +387,7 @@ int x86_add_exclusive(unsigned int what) + mutex_unlock(&pmc_reserve_mutex); + } + ++out: + atomic_inc(&active_events); + return 0; + +@@ -397,11 +398,15 @@ fail_unlock: + + void x86_del_exclusive(unsigned int what) + { ++ atomic_dec(&active_events); ++ ++ /* ++ * See the comment in x86_add_exclusive(). ++ */ + if (x86_pmu.lbr_pt_coexist && what == x86_lbr_exclusive_pt) + return; + + atomic_dec(&x86_pmu.lbr_exclusive[what]); +- atomic_dec(&active_events); + } + + int x86_setup_perfctr(struct perf_event *event) +@@ -1641,9 +1646,12 @@ static struct attribute_group x86_pmu_format_group __ro_after_init = { + + ssize_t events_sysfs_show(struct device *dev, struct device_attribute *attr, char *page) + { +- struct perf_pmu_events_attr *pmu_attr = \ ++ struct perf_pmu_events_attr *pmu_attr = + container_of(attr, struct perf_pmu_events_attr, attr); +- u64 config = x86_pmu.event_map(pmu_attr->id); ++ u64 config = 0; ++ ++ if (pmu_attr->id < x86_pmu.max_events) ++ config = x86_pmu.event_map(pmu_attr->id); + + /* string trumps id */ + if (pmu_attr->event_str) +@@ -1712,6 +1720,9 @@ is_visible(struct kobject *kobj, struct attribute *attr, int idx) + { + struct perf_pmu_events_attr *pmu_attr; + ++ if (idx >= x86_pmu.max_events) ++ return 0; ++ + pmu_attr = container_of(attr, struct perf_pmu_events_attr, attr.attr); + /* str trumps id */ + return pmu_attr->event_str || x86_pmu.event_map(idx) ? attr->mode : 0; +diff --git a/arch/x86/kernel/early-quirks.c b/arch/x86/kernel/early-quirks.c +index 606711f5ebf8..2f9ec14be3b1 100644 +--- a/arch/x86/kernel/early-quirks.c ++++ b/arch/x86/kernel/early-quirks.c +@@ -714,6 +714,8 @@ static struct chipset early_qrk[] __initdata = { + PCI_CLASS_BRIDGE_HOST, PCI_ANY_ID, 0, force_disable_hpet}, + { PCI_VENDOR_ID_INTEL, 0x3ec4, + PCI_CLASS_BRIDGE_HOST, PCI_ANY_ID, 0, force_disable_hpet}, ++ { PCI_VENDOR_ID_INTEL, 0x8a12, ++ PCI_CLASS_BRIDGE_HOST, PCI_ANY_ID, 0, force_disable_hpet}, + { PCI_VENDOR_ID_BROADCOM, 0x4331, + PCI_CLASS_NETWORK_OTHER, PCI_ANY_ID, 0, apple_airport_reset}, + {} +diff --git a/arch/x86/platform/efi/quirks.c b/arch/x86/platform/efi/quirks.c +index 3b9fd679cea9..aefe845dff59 100644 +--- a/arch/x86/platform/efi/quirks.c ++++ b/arch/x86/platform/efi/quirks.c +@@ -260,10 +260,6 @@ void __init efi_arch_mem_reserve(phys_addr_t addr, u64 size) + return; + } + +- /* No need to reserve regions that will never be freed. */ +- if (md.attribute & EFI_MEMORY_RUNTIME) +- return; +- + size += addr % EFI_PAGE_SIZE; + size = round_up(size, EFI_PAGE_SIZE); + addr = round_down(addr, EFI_PAGE_SIZE); +@@ -293,6 +289,8 @@ void __init efi_arch_mem_reserve(phys_addr_t addr, u64 size) + early_memunmap(new, new_size); + + efi_memmap_install(new_phys, num_entries); ++ e820__range_update(addr, size, E820_TYPE_RAM, E820_TYPE_RESERVED); ++ e820__update_table(e820_table); + } + + /* +diff --git a/block/blk-core.c b/block/blk-core.c +index d5e668ec751b..1075aaff606d 100644 +--- a/block/blk-core.c ++++ b/block/blk-core.c +@@ -886,11 +886,14 @@ generic_make_request_checks(struct bio *bio) + } + + /* +- * For a REQ_NOWAIT based request, return -EOPNOTSUPP +- * if queue is not a request based queue. ++ * Non-mq queues do not honor REQ_NOWAIT, so complete a bio ++ * with BLK_STS_AGAIN status in order to catch -EAGAIN and ++ * to give a chance to the caller to repeat request gracefully. + */ +- if ((bio->bi_opf & REQ_NOWAIT) && !queue_is_mq(q)) +- goto not_supported; ++ if ((bio->bi_opf & REQ_NOWAIT) && !queue_is_mq(q)) { ++ status = BLK_STS_AGAIN; ++ goto end_io; ++ } + + if (should_fail_bio(bio)) + goto end_io; +diff --git a/block/blk-flush.c b/block/blk-flush.c +index 1eec9cbe5a0a..b1f0a1ac505c 100644 +--- a/block/blk-flush.c ++++ b/block/blk-flush.c +@@ -69,6 +69,7 @@ + #include + #include + #include ++#include + + #include "blk.h" + #include "blk-mq.h" +@@ -492,6 +493,9 @@ struct blk_flush_queue *blk_alloc_flush_queue(struct request_queue *q, + INIT_LIST_HEAD(&fq->flush_queue[1]); + INIT_LIST_HEAD(&fq->flush_data_in_flight); + ++ lockdep_register_key(&fq->key); ++ lockdep_set_class(&fq->mq_flush_lock, &fq->key); ++ + return fq; + + fail_rq: +@@ -506,6 +510,7 @@ void blk_free_flush_queue(struct blk_flush_queue *fq) + if (!fq) + return; + ++ lockdep_unregister_key(&fq->key); + kfree(fq->flush_rq); + kfree(fq); + } +diff --git a/block/blk-map.c b/block/blk-map.c +index 3a62e471d81b..b0790268ed9d 100644 +--- a/block/blk-map.c ++++ b/block/blk-map.c +@@ -151,7 +151,7 @@ int blk_rq_map_user_iov(struct request_queue *q, struct request *rq, + return 0; + + unmap_rq: +- __blk_rq_unmap_user(bio); ++ blk_rq_unmap_user(bio); + fail: + rq->bio = NULL; + return ret; +diff --git a/block/blk.h b/block/blk.h +index 47fba9362e60..ffea1691470e 100644 +--- a/block/blk.h ++++ b/block/blk.h +@@ -30,6 +30,7 @@ struct blk_flush_queue { + * at the same time + */ + struct request *orig_rq; ++ struct lock_class_key key; + spinlock_t mq_flush_lock; + }; + +diff --git a/drivers/bus/ti-sysc.c b/drivers/bus/ti-sysc.c +index 2b6670daf7fc..34bd9bf4e68a 100644 +--- a/drivers/bus/ti-sysc.c ++++ b/drivers/bus/ti-sysc.c +@@ -1594,6 +1594,10 @@ static int sysc_reset(struct sysc *ddata) + sysc_val |= sysc_mask; + sysc_write(ddata, sysc_offset, sysc_val); + ++ if (ddata->cfg.srst_udelay) ++ usleep_range(ddata->cfg.srst_udelay, ++ ddata->cfg.srst_udelay * 2); ++ + if (ddata->clk_enable_quirk) + ddata->clk_enable_quirk(ddata); + +diff --git a/drivers/char/tpm/tpm_ftpm_tee.c b/drivers/char/tpm/tpm_ftpm_tee.c +index 6640a14dbe48..22bf553ccf9d 100644 +--- a/drivers/char/tpm/tpm_ftpm_tee.c ++++ b/drivers/char/tpm/tpm_ftpm_tee.c +@@ -32,7 +32,7 @@ static const uuid_t ftpm_ta_uuid = + 0x82, 0xCB, 0x34, 0x3F, 0xB7, 0xF3, 0x78, 0x96); + + /** +- * ftpm_tee_tpm_op_recv - retrieve fTPM response. ++ * ftpm_tee_tpm_op_recv() - retrieve fTPM response. + * @chip: the tpm_chip description as specified in driver/char/tpm/tpm.h. + * @buf: the buffer to store data. + * @count: the number of bytes to read. +@@ -61,7 +61,7 @@ static int ftpm_tee_tpm_op_recv(struct tpm_chip *chip, u8 *buf, size_t count) + } + + /** +- * ftpm_tee_tpm_op_send - send TPM commands through the TEE shared memory. ++ * ftpm_tee_tpm_op_send() - send TPM commands through the TEE shared memory. + * @chip: the tpm_chip description as specified in driver/char/tpm/tpm.h + * @buf: the buffer to send. + * @len: the number of bytes to send. +@@ -208,7 +208,7 @@ static int ftpm_tee_match(struct tee_ioctl_version_data *ver, const void *data) + } + + /** +- * ftpm_tee_probe - initialize the fTPM ++ * ftpm_tee_probe() - initialize the fTPM + * @pdev: the platform_device description. + * + * Return: +@@ -298,7 +298,7 @@ out_tee_session: + } + + /** +- * ftpm_tee_remove - remove the TPM device ++ * ftpm_tee_remove() - remove the TPM device + * @pdev: the platform_device description. + * + * Return: +@@ -328,6 +328,19 @@ static int ftpm_tee_remove(struct platform_device *pdev) + return 0; + } + ++/** ++ * ftpm_tee_shutdown() - shutdown the TPM device ++ * @pdev: the platform_device description. ++ */ ++static void ftpm_tee_shutdown(struct platform_device *pdev) ++{ ++ struct ftpm_tee_private *pvt_data = dev_get_drvdata(&pdev->dev); ++ ++ tee_shm_free(pvt_data->shm); ++ tee_client_close_session(pvt_data->ctx, pvt_data->session); ++ tee_client_close_context(pvt_data->ctx); ++} ++ + static const struct of_device_id of_ftpm_tee_ids[] = { + { .compatible = "microsoft,ftpm" }, + { } +@@ -341,6 +354,7 @@ static struct platform_driver ftpm_tee_driver = { + }, + .probe = ftpm_tee_probe, + .remove = ftpm_tee_remove, ++ .shutdown = ftpm_tee_shutdown, + }; + + module_platform_driver(ftpm_tee_driver); +diff --git a/drivers/clk/at91/at91sam9260.c b/drivers/clk/at91/at91sam9260.c +index 0aabe49aed09..a9d4234758d7 100644 +--- a/drivers/clk/at91/at91sam9260.c ++++ b/drivers/clk/at91/at91sam9260.c +@@ -348,7 +348,7 @@ static void __init at91sam926x_pmc_setup(struct device_node *np, + return; + mainxtal_name = of_clk_get_parent_name(np, i); + +- regmap = syscon_node_to_regmap(np); ++ regmap = device_node_to_regmap(np); + if (IS_ERR(regmap)) + return; + +diff --git a/drivers/clk/at91/at91sam9rl.c b/drivers/clk/at91/at91sam9rl.c +index 0ac34cdaa106..77fe83a73bf4 100644 +--- a/drivers/clk/at91/at91sam9rl.c ++++ b/drivers/clk/at91/at91sam9rl.c +@@ -83,7 +83,7 @@ static void __init at91sam9rl_pmc_setup(struct device_node *np) + return; + mainxtal_name = of_clk_get_parent_name(np, i); + +- regmap = syscon_node_to_regmap(np); ++ regmap = device_node_to_regmap(np); + if (IS_ERR(regmap)) + return; + +diff --git a/drivers/clk/at91/at91sam9x5.c b/drivers/clk/at91/at91sam9x5.c +index 0855f3a80cc7..086cf0b4955c 100644 +--- a/drivers/clk/at91/at91sam9x5.c ++++ b/drivers/clk/at91/at91sam9x5.c +@@ -146,7 +146,7 @@ static void __init at91sam9x5_pmc_setup(struct device_node *np, + return; + mainxtal_name = of_clk_get_parent_name(np, i); + +- regmap = syscon_node_to_regmap(np); ++ regmap = device_node_to_regmap(np); + if (IS_ERR(regmap)) + return; + +diff --git a/drivers/clk/at91/pmc.c b/drivers/clk/at91/pmc.c +index 0b03cfae3a9d..b71515acdec1 100644 +--- a/drivers/clk/at91/pmc.c ++++ b/drivers/clk/at91/pmc.c +@@ -275,7 +275,7 @@ static int __init pmc_register_ops(void) + + np = of_find_matching_node(NULL, sama5d2_pmc_dt_ids); + +- pmcreg = syscon_node_to_regmap(np); ++ pmcreg = device_node_to_regmap(np); + if (IS_ERR(pmcreg)) + return PTR_ERR(pmcreg); + +diff --git a/drivers/clk/at91/sama5d2.c b/drivers/clk/at91/sama5d2.c +index 0de1108737db..ff7e3f727082 100644 +--- a/drivers/clk/at91/sama5d2.c ++++ b/drivers/clk/at91/sama5d2.c +@@ -162,7 +162,7 @@ static void __init sama5d2_pmc_setup(struct device_node *np) + return; + mainxtal_name = of_clk_get_parent_name(np, i); + +- regmap = syscon_node_to_regmap(np); ++ regmap = device_node_to_regmap(np); + if (IS_ERR(regmap)) + return; + +diff --git a/drivers/clk/at91/sama5d4.c b/drivers/clk/at91/sama5d4.c +index 25b156d4e645..a6dee4a3b6e4 100644 +--- a/drivers/clk/at91/sama5d4.c ++++ b/drivers/clk/at91/sama5d4.c +@@ -136,7 +136,7 @@ static void __init sama5d4_pmc_setup(struct device_node *np) + return; + mainxtal_name = of_clk_get_parent_name(np, i); + +- regmap = syscon_node_to_regmap(np); ++ regmap = device_node_to_regmap(np); + if (IS_ERR(regmap)) + return; + +diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c +index 1c677d7f7f53..27a95c86a80b 100644 +--- a/drivers/clk/clk.c ++++ b/drivers/clk/clk.c +@@ -3231,6 +3231,34 @@ static inline void clk_debug_unregister(struct clk_core *core) + } + #endif + ++static void clk_core_reparent_orphans_nolock(void) ++{ ++ struct clk_core *orphan; ++ struct hlist_node *tmp2; ++ ++ /* ++ * walk the list of orphan clocks and reparent any that newly finds a ++ * parent. ++ */ ++ hlist_for_each_entry_safe(orphan, tmp2, &clk_orphan_list, child_node) { ++ struct clk_core *parent = __clk_init_parent(orphan); ++ ++ /* ++ * We need to use __clk_set_parent_before() and _after() to ++ * to properly migrate any prepare/enable count of the orphan ++ * clock. This is important for CLK_IS_CRITICAL clocks, which ++ * are enabled during init but might not have a parent yet. ++ */ ++ if (parent) { ++ /* update the clk tree topology */ ++ __clk_set_parent_before(orphan, parent); ++ __clk_set_parent_after(orphan, parent, NULL); ++ __clk_recalc_accuracies(orphan); ++ __clk_recalc_rates(orphan, 0); ++ } ++ } ++} ++ + /** + * __clk_core_init - initialize the data structures in a struct clk_core + * @core: clk_core being initialized +@@ -3241,8 +3269,6 @@ static inline void clk_debug_unregister(struct clk_core *core) + static int __clk_core_init(struct clk_core *core) + { + int ret; +- struct clk_core *orphan; +- struct hlist_node *tmp2; + unsigned long rate; + + if (!core) +@@ -3389,27 +3415,8 @@ static int __clk_core_init(struct clk_core *core) + clk_enable_unlock(flags); + } + +- /* +- * walk the list of orphan clocks and reparent any that newly finds a +- * parent. +- */ +- hlist_for_each_entry_safe(orphan, tmp2, &clk_orphan_list, child_node) { +- struct clk_core *parent = __clk_init_parent(orphan); ++ clk_core_reparent_orphans_nolock(); + +- /* +- * We need to use __clk_set_parent_before() and _after() to +- * to properly migrate any prepare/enable count of the orphan +- * clock. This is important for CLK_IS_CRITICAL clocks, which +- * are enabled during init but might not have a parent yet. +- */ +- if (parent) { +- /* update the clk tree topology */ +- __clk_set_parent_before(orphan, parent); +- __clk_set_parent_after(orphan, parent, NULL); +- __clk_recalc_accuracies(orphan); +- __clk_recalc_rates(orphan, 0); +- } +- } + + kref_init(&core->ref); + out: +@@ -4160,6 +4167,13 @@ int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb) + EXPORT_SYMBOL_GPL(clk_notifier_unregister); + + #ifdef CONFIG_OF ++static void clk_core_reparent_orphans(void) ++{ ++ clk_prepare_lock(); ++ clk_core_reparent_orphans_nolock(); ++ clk_prepare_unlock(); ++} ++ + /** + * struct of_clk_provider - Clock provider registration structure + * @link: Entry in global list of clock providers +@@ -4255,6 +4269,8 @@ int of_clk_add_provider(struct device_node *np, + mutex_unlock(&of_clk_mutex); + pr_debug("Added clock from %pOF\n", np); + ++ clk_core_reparent_orphans(); ++ + ret = of_clk_set_defaults(np, true); + if (ret < 0) + of_clk_del_provider(np); +@@ -4290,6 +4306,8 @@ int of_clk_add_hw_provider(struct device_node *np, + mutex_unlock(&of_clk_mutex); + pr_debug("Added clk_hw provider from %pOF\n", np); + ++ clk_core_reparent_orphans(); ++ + ret = of_clk_set_defaults(np, true); + if (ret < 0) + of_clk_del_provider(np); +diff --git a/drivers/firmware/efi/earlycon.c b/drivers/firmware/efi/earlycon.c +index c9a0efca17b0..d4077db6dc97 100644 +--- a/drivers/firmware/efi/earlycon.c ++++ b/drivers/firmware/efi/earlycon.c +@@ -13,18 +13,57 @@ + + #include + ++static const struct console *earlycon_console __initdata; + static const struct font_desc *font; + static u32 efi_x, efi_y; + static u64 fb_base; + static pgprot_t fb_prot; ++static void *efi_fb; ++ ++/* ++ * EFI earlycon needs to use early_memremap() to map the framebuffer. ++ * But early_memremap() is not usable for 'earlycon=efifb keep_bootcon', ++ * memremap() should be used instead. memremap() will be available after ++ * paging_init() which is earlier than initcall callbacks. Thus adding this ++ * early initcall function early_efi_map_fb() to map the whole EFI framebuffer. ++ */ ++static int __init efi_earlycon_remap_fb(void) ++{ ++ /* bail if there is no bootconsole or it has been disabled already */ ++ if (!earlycon_console || !(earlycon_console->flags & CON_ENABLED)) ++ return 0; ++ ++ if (pgprot_val(fb_prot) == pgprot_val(PAGE_KERNEL)) ++ efi_fb = memremap(fb_base, screen_info.lfb_size, MEMREMAP_WB); ++ else ++ efi_fb = memremap(fb_base, screen_info.lfb_size, MEMREMAP_WC); ++ ++ return efi_fb ? 0 : -ENOMEM; ++} ++early_initcall(efi_earlycon_remap_fb); ++ ++static int __init efi_earlycon_unmap_fb(void) ++{ ++ /* unmap the bootconsole fb unless keep_bootcon has left it enabled */ ++ if (efi_fb && !(earlycon_console->flags & CON_ENABLED)) ++ memunmap(efi_fb); ++ return 0; ++} ++late_initcall(efi_earlycon_unmap_fb); + + static __ref void *efi_earlycon_map(unsigned long start, unsigned long len) + { ++ if (efi_fb) ++ return efi_fb + start; ++ + return early_memremap_prot(fb_base + start, len, pgprot_val(fb_prot)); + } + + static __ref void efi_earlycon_unmap(void *addr, unsigned long len) + { ++ if (efi_fb) ++ return; ++ + early_memunmap(addr, len); + } + +@@ -201,6 +240,7 @@ static int __init efi_earlycon_setup(struct earlycon_device *device, + efi_earlycon_scroll_up(); + + device->con->write = efi_earlycon_write; ++ earlycon_console = device->con; + return 0; + } + EARLYCON_DECLARE(efifb, efi_earlycon_setup); +diff --git a/drivers/firmware/efi/libstub/gop.c b/drivers/firmware/efi/libstub/gop.c +index 0101ca4c13b1..b7bf1e993b8b 100644 +--- a/drivers/firmware/efi/libstub/gop.c ++++ b/drivers/firmware/efi/libstub/gop.c +@@ -83,30 +83,6 @@ setup_pixel_info(struct screen_info *si, u32 pixels_per_scan_line, + } + } + +-static efi_status_t +-__gop_query32(efi_system_table_t *sys_table_arg, +- struct efi_graphics_output_protocol_32 *gop32, +- struct efi_graphics_output_mode_info **info, +- unsigned long *size, u64 *fb_base) +-{ +- struct efi_graphics_output_protocol_mode_32 *mode; +- efi_graphics_output_protocol_query_mode query_mode; +- efi_status_t status; +- unsigned long m; +- +- m = gop32->mode; +- mode = (struct efi_graphics_output_protocol_mode_32 *)m; +- query_mode = (void *)(unsigned long)gop32->query_mode; +- +- status = __efi_call_early(query_mode, (void *)gop32, mode->mode, size, +- info); +- if (status != EFI_SUCCESS) +- return status; +- +- *fb_base = mode->frame_buffer_base; +- return status; +-} +- + static efi_status_t + setup_gop32(efi_system_table_t *sys_table_arg, struct screen_info *si, + efi_guid_t *proto, unsigned long size, void **gop_handle) +@@ -119,7 +95,7 @@ setup_gop32(efi_system_table_t *sys_table_arg, struct screen_info *si, + u64 fb_base; + struct efi_pixel_bitmask pixel_info; + int pixel_format; +- efi_status_t status = EFI_NOT_FOUND; ++ efi_status_t status; + u32 *handles = (u32 *)(unsigned long)gop_handle; + int i; + +@@ -128,6 +104,7 @@ setup_gop32(efi_system_table_t *sys_table_arg, struct screen_info *si, + + nr_gops = size / sizeof(u32); + for (i = 0; i < nr_gops; i++) { ++ struct efi_graphics_output_protocol_mode_32 *mode; + struct efi_graphics_output_mode_info *info = NULL; + efi_guid_t conout_proto = EFI_CONSOLE_OUT_DEVICE_GUID; + bool conout_found = false; +@@ -145,9 +122,11 @@ setup_gop32(efi_system_table_t *sys_table_arg, struct screen_info *si, + if (status == EFI_SUCCESS) + conout_found = true; + +- status = __gop_query32(sys_table_arg, gop32, &info, &size, +- ¤t_fb_base); +- if (status == EFI_SUCCESS && (!first_gop || conout_found) && ++ mode = (void *)(unsigned long)gop32->mode; ++ info = (void *)(unsigned long)mode->info; ++ current_fb_base = mode->frame_buffer_base; ++ ++ if ((!first_gop || conout_found) && + info->pixel_format != PIXEL_BLT_ONLY) { + /* + * Systems that use the UEFI Console Splitter may +@@ -175,7 +154,7 @@ setup_gop32(efi_system_table_t *sys_table_arg, struct screen_info *si, + + /* Did we find any GOPs? */ + if (!first_gop) +- goto out; ++ return EFI_NOT_FOUND; + + /* EFI framebuffer */ + si->orig_video_isVGA = VIDEO_TYPE_EFI; +@@ -197,32 +176,8 @@ setup_gop32(efi_system_table_t *sys_table_arg, struct screen_info *si, + si->lfb_size = si->lfb_linelength * si->lfb_height; + + si->capabilities |= VIDEO_CAPABILITY_SKIP_QUIRKS; +-out: +- return status; +-} +- +-static efi_status_t +-__gop_query64(efi_system_table_t *sys_table_arg, +- struct efi_graphics_output_protocol_64 *gop64, +- struct efi_graphics_output_mode_info **info, +- unsigned long *size, u64 *fb_base) +-{ +- struct efi_graphics_output_protocol_mode_64 *mode; +- efi_graphics_output_protocol_query_mode query_mode; +- efi_status_t status; +- unsigned long m; +- +- m = gop64->mode; +- mode = (struct efi_graphics_output_protocol_mode_64 *)m; +- query_mode = (void *)(unsigned long)gop64->query_mode; +- +- status = __efi_call_early(query_mode, (void *)gop64, mode->mode, size, +- info); +- if (status != EFI_SUCCESS) +- return status; + +- *fb_base = mode->frame_buffer_base; +- return status; ++ return EFI_SUCCESS; + } + + static efi_status_t +@@ -237,7 +192,7 @@ setup_gop64(efi_system_table_t *sys_table_arg, struct screen_info *si, + u64 fb_base; + struct efi_pixel_bitmask pixel_info; + int pixel_format; +- efi_status_t status = EFI_NOT_FOUND; ++ efi_status_t status; + u64 *handles = (u64 *)(unsigned long)gop_handle; + int i; + +@@ -246,6 +201,7 @@ setup_gop64(efi_system_table_t *sys_table_arg, struct screen_info *si, + + nr_gops = size / sizeof(u64); + for (i = 0; i < nr_gops; i++) { ++ struct efi_graphics_output_protocol_mode_64 *mode; + struct efi_graphics_output_mode_info *info = NULL; + efi_guid_t conout_proto = EFI_CONSOLE_OUT_DEVICE_GUID; + bool conout_found = false; +@@ -263,9 +219,11 @@ setup_gop64(efi_system_table_t *sys_table_arg, struct screen_info *si, + if (status == EFI_SUCCESS) + conout_found = true; + +- status = __gop_query64(sys_table_arg, gop64, &info, &size, +- ¤t_fb_base); +- if (status == EFI_SUCCESS && (!first_gop || conout_found) && ++ mode = (void *)(unsigned long)gop64->mode; ++ info = (void *)(unsigned long)mode->info; ++ current_fb_base = mode->frame_buffer_base; ++ ++ if ((!first_gop || conout_found) && + info->pixel_format != PIXEL_BLT_ONLY) { + /* + * Systems that use the UEFI Console Splitter may +@@ -293,7 +251,7 @@ setup_gop64(efi_system_table_t *sys_table_arg, struct screen_info *si, + + /* Did we find any GOPs? */ + if (!first_gop) +- goto out; ++ return EFI_NOT_FOUND; + + /* EFI framebuffer */ + si->orig_video_isVGA = VIDEO_TYPE_EFI; +@@ -315,8 +273,8 @@ setup_gop64(efi_system_table_t *sys_table_arg, struct screen_info *si, + si->lfb_size = si->lfb_linelength * si->lfb_height; + + si->capabilities |= VIDEO_CAPABILITY_SKIP_QUIRKS; +-out: +- return status; ++ ++ return EFI_SUCCESS; + } + + /* +diff --git a/drivers/gpio/gpiolib-of.c b/drivers/gpio/gpiolib-of.c +index 80ea49f570f4..43ffec3a6fbb 100644 +--- a/drivers/gpio/gpiolib-of.c ++++ b/drivers/gpio/gpiolib-of.c +@@ -23,6 +23,29 @@ + #include "gpiolib.h" + #include "gpiolib-of.h" + ++/** ++ * of_gpio_spi_cs_get_count() - special GPIO counting for SPI ++ * Some elder GPIO controllers need special quirks. Currently we handle ++ * the Freescale GPIO controller with bindings that doesn't use the ++ * established "cs-gpios" for chip selects but instead rely on ++ * "gpios" for the chip select lines. If we detect this, we redirect ++ * the counting of "cs-gpios" to count "gpios" transparent to the ++ * driver. ++ */ ++int of_gpio_spi_cs_get_count(struct device *dev, const char *con_id) ++{ ++ struct device_node *np = dev->of_node; ++ ++ if (!IS_ENABLED(CONFIG_SPI_MASTER)) ++ return 0; ++ if (!con_id || strcmp(con_id, "cs")) ++ return 0; ++ if (!of_device_is_compatible(np, "fsl,spi") && ++ !of_device_is_compatible(np, "aeroflexgaisler,spictrl")) ++ return 0; ++ return of_gpio_named_count(np, "gpios"); ++} ++ + /* + * This is used by external users of of_gpio_count() from + * +@@ -35,6 +58,10 @@ int of_gpio_get_count(struct device *dev, const char *con_id) + char propname[32]; + unsigned int i; + ++ ret = of_gpio_spi_cs_get_count(dev, con_id); ++ if (ret > 0) ++ return ret; ++ + for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) { + if (con_id) + snprintf(propname, sizeof(propname), "%s-%s", +diff --git a/drivers/gpu/drm/exynos/exynos_drm_gsc.c b/drivers/gpu/drm/exynos/exynos_drm_gsc.c +index 7ae087b0504d..88b6fcaa20be 100644 +--- a/drivers/gpu/drm/exynos/exynos_drm_gsc.c ++++ b/drivers/gpu/drm/exynos/exynos_drm_gsc.c +@@ -1313,6 +1313,7 @@ static int gsc_remove(struct platform_device *pdev) + { + struct device *dev = &pdev->dev; + ++ component_del(dev, &gsc_component_ops); + pm_runtime_dont_use_autosuspend(dev); + pm_runtime_disable(dev); + +diff --git a/drivers/iommu/dma-iommu.c b/drivers/iommu/dma-iommu.c +index f321279baf9e..51456e7f264f 100644 +--- a/drivers/iommu/dma-iommu.c ++++ b/drivers/iommu/dma-iommu.c +@@ -19,6 +19,7 @@ + #include + #include + #include ++#include + #include + #include + #include +@@ -43,7 +44,6 @@ struct iommu_dma_cookie { + dma_addr_t msi_iova; + }; + struct list_head msi_page_list; +- spinlock_t msi_lock; + + /* Domain for flush queue callback; NULL if flush queue not in use */ + struct iommu_domain *fq_domain; +@@ -62,7 +62,6 @@ static struct iommu_dma_cookie *cookie_alloc(enum iommu_dma_cookie_type type) + + cookie = kzalloc(sizeof(*cookie), GFP_KERNEL); + if (cookie) { +- spin_lock_init(&cookie->msi_lock); + INIT_LIST_HEAD(&cookie->msi_page_list); + cookie->type = type; + } +@@ -1150,7 +1149,7 @@ static struct iommu_dma_msi_page *iommu_dma_get_msi_page(struct device *dev, + if (msi_page->phys == msi_addr) + return msi_page; + +- msi_page = kzalloc(sizeof(*msi_page), GFP_ATOMIC); ++ msi_page = kzalloc(sizeof(*msi_page), GFP_KERNEL); + if (!msi_page) + return NULL; + +@@ -1180,7 +1179,7 @@ int iommu_dma_prepare_msi(struct msi_desc *desc, phys_addr_t msi_addr) + struct iommu_domain *domain = iommu_get_domain_for_dev(dev); + struct iommu_dma_cookie *cookie; + struct iommu_dma_msi_page *msi_page; +- unsigned long flags; ++ static DEFINE_MUTEX(msi_prepare_lock); /* see below */ + + if (!domain || !domain->iova_cookie) { + desc->iommu_cookie = NULL; +@@ -1190,13 +1189,13 @@ int iommu_dma_prepare_msi(struct msi_desc *desc, phys_addr_t msi_addr) + cookie = domain->iova_cookie; + + /* +- * We disable IRQs to rule out a possible inversion against +- * irq_desc_lock if, say, someone tries to retarget the affinity +- * of an MSI from within an IPI handler. ++ * In fact the whole prepare operation should already be serialised by ++ * irq_domain_mutex further up the callchain, but that's pretty subtle ++ * on its own, so consider this locking as failsafe documentation... + */ +- spin_lock_irqsave(&cookie->msi_lock, flags); ++ mutex_lock(&msi_prepare_lock); + msi_page = iommu_dma_get_msi_page(dev, msi_addr, domain); +- spin_unlock_irqrestore(&cookie->msi_lock, flags); ++ mutex_unlock(&msi_prepare_lock); + + msi_desc_set_iommu_cookie(desc, msi_page); + +diff --git a/drivers/iommu/iova.c b/drivers/iommu/iova.c +index 41c605b0058f..c7a914b9bbbc 100644 +--- a/drivers/iommu/iova.c ++++ b/drivers/iommu/iova.c +@@ -233,7 +233,7 @@ static DEFINE_MUTEX(iova_cache_mutex); + + struct iova *alloc_iova_mem(void) + { +- return kmem_cache_alloc(iova_cache, GFP_ATOMIC); ++ return kmem_cache_zalloc(iova_cache, GFP_ATOMIC); + } + EXPORT_SYMBOL(alloc_iova_mem); + +diff --git a/drivers/misc/habanalabs/command_submission.c b/drivers/misc/habanalabs/command_submission.c +index a9ac045dcfde..447f307ef4d6 100644 +--- a/drivers/misc/habanalabs/command_submission.c ++++ b/drivers/misc/habanalabs/command_submission.c +@@ -777,8 +777,9 @@ int hl_cs_wait_ioctl(struct hl_fpriv *hpriv, void *data) + memset(args, 0, sizeof(*args)); + + if (rc < 0) { +- dev_err(hdev->dev, "Error %ld on waiting for CS handle %llu\n", +- rc, seq); ++ dev_err_ratelimited(hdev->dev, ++ "Error %ld on waiting for CS handle %llu\n", ++ rc, seq); + if (rc == -ERESTARTSYS) { + args->out.status = HL_WAIT_CS_STATUS_INTERRUPTED; + rc = -EINTR; +diff --git a/drivers/misc/habanalabs/context.c b/drivers/misc/habanalabs/context.c +index 17db7b3dfb4c..2df6fb87e7ff 100644 +--- a/drivers/misc/habanalabs/context.c ++++ b/drivers/misc/habanalabs/context.c +@@ -176,7 +176,7 @@ struct dma_fence *hl_ctx_get_fence(struct hl_ctx *ctx, u64 seq) + spin_lock(&ctx->cs_lock); + + if (seq >= ctx->cs_sequence) { +- dev_notice(hdev->dev, ++ dev_notice_ratelimited(hdev->dev, + "Can't wait on seq %llu because current CS is at seq %llu\n", + seq, ctx->cs_sequence); + spin_unlock(&ctx->cs_lock); +diff --git a/drivers/misc/habanalabs/goya/goya.c b/drivers/misc/habanalabs/goya/goya.c +index 6fba14b81f90..fe3574a83b7c 100644 +--- a/drivers/misc/habanalabs/goya/goya.c ++++ b/drivers/misc/habanalabs/goya/goya.c +@@ -2171,7 +2171,7 @@ static int goya_push_linux_to_device(struct hl_device *hdev) + + static int goya_pldm_init_cpu(struct hl_device *hdev) + { +- u32 val, unit_rst_val; ++ u32 unit_rst_val; + int rc; + + /* Must initialize SRAM scrambler before pushing u-boot to SRAM */ +@@ -2179,14 +2179,14 @@ static int goya_pldm_init_cpu(struct hl_device *hdev) + + /* Put ARM cores into reset */ + WREG32(mmCPU_CA53_CFG_ARM_RST_CONTROL, CPU_RESET_ASSERT); +- val = RREG32(mmCPU_CA53_CFG_ARM_RST_CONTROL); ++ RREG32(mmCPU_CA53_CFG_ARM_RST_CONTROL); + + /* Reset the CA53 MACRO */ + unit_rst_val = RREG32(mmPSOC_GLOBAL_CONF_UNIT_RST_N); + WREG32(mmPSOC_GLOBAL_CONF_UNIT_RST_N, CA53_RESET); +- val = RREG32(mmPSOC_GLOBAL_CONF_UNIT_RST_N); ++ RREG32(mmPSOC_GLOBAL_CONF_UNIT_RST_N); + WREG32(mmPSOC_GLOBAL_CONF_UNIT_RST_N, unit_rst_val); +- val = RREG32(mmPSOC_GLOBAL_CONF_UNIT_RST_N); ++ RREG32(mmPSOC_GLOBAL_CONF_UNIT_RST_N); + + rc = goya_push_uboot_to_device(hdev); + if (rc) +@@ -2207,7 +2207,7 @@ static int goya_pldm_init_cpu(struct hl_device *hdev) + /* Release ARM core 0 from reset */ + WREG32(mmCPU_CA53_CFG_ARM_RST_CONTROL, + CPU_RESET_CORE0_DEASSERT); +- val = RREG32(mmCPU_CA53_CFG_ARM_RST_CONTROL); ++ RREG32(mmCPU_CA53_CFG_ARM_RST_CONTROL); + + return 0; + } +@@ -2475,13 +2475,12 @@ err: + static int goya_hw_init(struct hl_device *hdev) + { + struct asic_fixed_properties *prop = &hdev->asic_prop; +- u32 val; + int rc; + + dev_info(hdev->dev, "Starting initialization of H/W\n"); + + /* Perform read from the device to make sure device is up */ +- val = RREG32(mmPCIE_DBI_DEVICE_ID_VENDOR_ID_REG); ++ RREG32(mmPCIE_DBI_DEVICE_ID_VENDOR_ID_REG); + + /* + * Let's mark in the H/W that we have reached this point. We check +@@ -2533,7 +2532,7 @@ static int goya_hw_init(struct hl_device *hdev) + goto disable_queues; + + /* Perform read from the device to flush all MSI-X configuration */ +- val = RREG32(mmPCIE_DBI_DEVICE_ID_VENDOR_ID_REG); ++ RREG32(mmPCIE_DBI_DEVICE_ID_VENDOR_ID_REG); + + return 0; + +diff --git a/drivers/misc/ocxl/context.c b/drivers/misc/ocxl/context.c +index 994563a078eb..de8a66b9d76b 100644 +--- a/drivers/misc/ocxl/context.c ++++ b/drivers/misc/ocxl/context.c +@@ -10,18 +10,17 @@ int ocxl_context_alloc(struct ocxl_context **context, struct ocxl_afu *afu, + int pasid; + struct ocxl_context *ctx; + +- *context = kzalloc(sizeof(struct ocxl_context), GFP_KERNEL); +- if (!*context) ++ ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); ++ if (!ctx) + return -ENOMEM; + +- ctx = *context; +- + ctx->afu = afu; + mutex_lock(&afu->contexts_lock); + pasid = idr_alloc(&afu->contexts_idr, ctx, afu->pasid_base, + afu->pasid_base + afu->pasid_max, GFP_KERNEL); + if (pasid < 0) { + mutex_unlock(&afu->contexts_lock); ++ kfree(ctx); + return pasid; + } + afu->pasid_count++; +@@ -43,6 +42,7 @@ int ocxl_context_alloc(struct ocxl_context **context, struct ocxl_afu *afu, + * duration of the life of the context + */ + ocxl_afu_get(afu); ++ *context = ctx; + return 0; + } + EXPORT_SYMBOL_GPL(ocxl_context_alloc); +diff --git a/drivers/net/dsa/mv88e6xxx/global1.c b/drivers/net/dsa/mv88e6xxx/global1.c +index 25ec4c0ac589..8a903624fdd7 100644 +--- a/drivers/net/dsa/mv88e6xxx/global1.c ++++ b/drivers/net/dsa/mv88e6xxx/global1.c +@@ -332,6 +332,11 @@ int mv88e6390_g1_set_cpu_port(struct mv88e6xxx_chip *chip, int port) + { + u16 ptr = MV88E6390_G1_MONITOR_MGMT_CTL_PTR_CPU_DEST; + ++ /* Use the default high priority for management frames sent to ++ * the CPU. ++ */ ++ port |= MV88E6390_G1_MONITOR_MGMT_CTL_PTR_CPU_DEST_MGMTPRI; ++ + return mv88e6390_g1_monitor_write(chip, ptr, port); + } + +diff --git a/drivers/net/dsa/mv88e6xxx/global1.h b/drivers/net/dsa/mv88e6xxx/global1.h +index 0870fcc8bfc8..0ae96a1e919b 100644 +--- a/drivers/net/dsa/mv88e6xxx/global1.h ++++ b/drivers/net/dsa/mv88e6xxx/global1.h +@@ -210,6 +210,7 @@ + #define MV88E6390_G1_MONITOR_MGMT_CTL_PTR_INGRESS_DEST 0x2000 + #define MV88E6390_G1_MONITOR_MGMT_CTL_PTR_EGRESS_DEST 0x2100 + #define MV88E6390_G1_MONITOR_MGMT_CTL_PTR_CPU_DEST 0x3000 ++#define MV88E6390_G1_MONITOR_MGMT_CTL_PTR_CPU_DEST_MGMTPRI 0x00e0 + #define MV88E6390_G1_MONITOR_MGMT_CTL_DATA_MASK 0x00ff + + /* Offset 0x1C: Global Control 2 */ +diff --git a/drivers/net/dsa/mv88e6xxx/port.c b/drivers/net/dsa/mv88e6xxx/port.c +index 15ef81654b67..330c41e87171 100644 +--- a/drivers/net/dsa/mv88e6xxx/port.c ++++ b/drivers/net/dsa/mv88e6xxx/port.c +@@ -393,7 +393,7 @@ phy_interface_t mv88e6390x_port_max_speed_mode(int port) + } + + static int mv88e6xxx_port_set_cmode(struct mv88e6xxx_chip *chip, int port, +- phy_interface_t mode) ++ phy_interface_t mode, bool force) + { + u8 lane; + u16 cmode; +@@ -427,8 +427,8 @@ static int mv88e6xxx_port_set_cmode(struct mv88e6xxx_chip *chip, int port, + cmode = 0; + } + +- /* cmode doesn't change, nothing to do for us */ +- if (cmode == chip->ports[port].cmode) ++ /* cmode doesn't change, nothing to do for us unless forced */ ++ if (cmode == chip->ports[port].cmode && !force) + return 0; + + lane = mv88e6xxx_serdes_get_lane(chip, port); +@@ -484,7 +484,7 @@ int mv88e6390x_port_set_cmode(struct mv88e6xxx_chip *chip, int port, + if (port != 9 && port != 10) + return -EOPNOTSUPP; + +- return mv88e6xxx_port_set_cmode(chip, port, mode); ++ return mv88e6xxx_port_set_cmode(chip, port, mode, false); + } + + int mv88e6390_port_set_cmode(struct mv88e6xxx_chip *chip, int port, +@@ -504,7 +504,7 @@ int mv88e6390_port_set_cmode(struct mv88e6xxx_chip *chip, int port, + break; + } + +- return mv88e6xxx_port_set_cmode(chip, port, mode); ++ return mv88e6xxx_port_set_cmode(chip, port, mode, false); + } + + static int mv88e6341_port_set_cmode_writable(struct mv88e6xxx_chip *chip, +@@ -555,7 +555,7 @@ int mv88e6341_port_set_cmode(struct mv88e6xxx_chip *chip, int port, + if (err) + return err; + +- return mv88e6xxx_port_set_cmode(chip, port, mode); ++ return mv88e6xxx_port_set_cmode(chip, port, mode, true); + } + + int mv88e6185_port_get_cmode(struct mv88e6xxx_chip *chip, int port, u8 *cmode) +diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h +index 8b08cb18e363..3f63ffd7561b 100644 +--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h ++++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h +@@ -1109,7 +1109,7 @@ static inline u8 bnx2x_get_path_func_num(struct bnx2x *bp) + for (i = 0; i < E1H_FUNC_MAX / 2; i++) { + u32 func_config = + MF_CFG_RD(bp, +- func_mf_config[BP_PORT(bp) + 2 * i]. ++ func_mf_config[BP_PATH(bp) + 2 * i]. + config); + func_num += + ((func_config & FUNC_MF_CFG_FUNC_HIDE) ? 0 : 1); +diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c +index 192ff8d5da32..cff64e43bdd8 100644 +--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c ++++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c +@@ -9976,10 +9976,18 @@ static void bnx2x_recovery_failed(struct bnx2x *bp) + */ + static void bnx2x_parity_recover(struct bnx2x *bp) + { +- bool global = false; + u32 error_recovered, error_unrecovered; +- bool is_parity; ++ bool is_parity, global = false; ++#ifdef CONFIG_BNX2X_SRIOV ++ int vf_idx; ++ ++ for (vf_idx = 0; vf_idx < bp->requested_nr_virtfn; vf_idx++) { ++ struct bnx2x_virtf *vf = BP_VF(bp, vf_idx); + ++ if (vf) ++ vf->state = VF_LOST; ++ } ++#endif + DP(NETIF_MSG_HW, "Handling parity\n"); + while (1) { + switch (bp->recovery_state) { +diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.h +index b6ebd92ec565..3a716c015415 100644 +--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.h ++++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.h +@@ -139,6 +139,7 @@ struct bnx2x_virtf { + #define VF_ACQUIRED 1 /* VF acquired, but not initialized */ + #define VF_ENABLED 2 /* VF Enabled */ + #define VF_RESET 3 /* VF FLR'd, pending cleanup */ ++#define VF_LOST 4 /* Recovery while VFs are loaded */ + + bool flr_clnup_stage; /* true during flr cleanup */ + bool malicious; /* true if FW indicated so, until FLR */ +diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c +index 0752b7fa4d9c..ea0e9394f898 100644 +--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c ++++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c +@@ -2107,6 +2107,18 @@ static void bnx2x_vf_mbx_request(struct bnx2x *bp, struct bnx2x_virtf *vf, + { + int i; + ++ if (vf->state == VF_LOST) { ++ /* Just ack the FW and return if VFs are lost ++ * in case of parity error. VFs are supposed to be timedout ++ * on waiting for PF response. ++ */ ++ DP(BNX2X_MSG_IOV, ++ "VF 0x%x lost, not handling the request\n", vf->abs_vfid); ++ ++ storm_memset_vf_mbx_ack(bp, vf->abs_vfid); ++ return; ++ } ++ + /* check if tlv type is known */ + if (bnx2x_tlv_supported(mbx->first_tlv.tl.type)) { + /* Lock the per vf op mutex and note the locker's identity. +diff --git a/drivers/net/ethernet/cadence/macb_main.c b/drivers/net/ethernet/cadence/macb_main.c +index 0f10a272827c..f496b248bda3 100644 +--- a/drivers/net/ethernet/cadence/macb_main.c ++++ b/drivers/net/ethernet/cadence/macb_main.c +@@ -4027,7 +4027,7 @@ static int fu540_c000_clk_init(struct platform_device *pdev, struct clk **pclk, + mgmt->rate = 0; + mgmt->hw.init = &init; + +- *tx_clk = clk_register(NULL, &mgmt->hw); ++ *tx_clk = devm_clk_register(&pdev->dev, &mgmt->hw); + if (IS_ERR(*tx_clk)) + return PTR_ERR(*tx_clk); + +@@ -4361,7 +4361,6 @@ err_out_free_netdev: + + err_disable_clocks: + clk_disable_unprepare(tx_clk); +- clk_unregister(tx_clk); + clk_disable_unprepare(hclk); + clk_disable_unprepare(pclk); + clk_disable_unprepare(rx_clk); +@@ -4397,7 +4396,6 @@ static int macb_remove(struct platform_device *pdev) + pm_runtime_dont_use_autosuspend(&pdev->dev); + if (!pm_runtime_suspended(&pdev->dev)) { + clk_disable_unprepare(bp->tx_clk); +- clk_unregister(bp->tx_clk); + clk_disable_unprepare(bp->hclk); + clk_disable_unprepare(bp->pclk); + clk_disable_unprepare(bp->rx_clk); +diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c +index ae6a47dd7dc9..fb8ade9a05a9 100644 +--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c ++++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c +@@ -2996,6 +2996,9 @@ static int sge_queue_entries(const struct adapter *adap) + int tot_uld_entries = 0; + int i; + ++ if (!is_uld(adap)) ++ goto lld_only; ++ + mutex_lock(&uld_mutex); + for (i = 0; i < CXGB4_TX_MAX; i++) + tot_uld_entries += sge_qinfo_uld_txq_entries(adap, i); +@@ -3006,6 +3009,7 @@ static int sge_queue_entries(const struct adapter *adap) + } + mutex_unlock(&uld_mutex); + ++lld_only: + return DIV_ROUND_UP(adap->sge.ethqsets, 4) + + tot_uld_entries + + DIV_ROUND_UP(MAX_CTRL_QUEUES, 4) + 1; +diff --git a/drivers/net/ethernet/freescale/fec_main.c b/drivers/net/ethernet/freescale/fec_main.c +index 4bb30761abfc..8336f4cbaf95 100644 +--- a/drivers/net/ethernet/freescale/fec_main.c ++++ b/drivers/net/ethernet/freescale/fec_main.c +@@ -2199,8 +2199,14 @@ static void fec_enet_get_regs(struct net_device *ndev, + { + struct fec_enet_private *fep = netdev_priv(ndev); + u32 __iomem *theregs = (u32 __iomem *)fep->hwp; ++ struct device *dev = &fep->pdev->dev; + u32 *buf = (u32 *)regbuf; + u32 i, off; ++ int ret; ++ ++ ret = pm_runtime_get_sync(dev); ++ if (ret < 0) ++ return; + + regs->version = fec_enet_register_version; + +@@ -2216,6 +2222,9 @@ static void fec_enet_get_regs(struct net_device *ndev, + off >>= 2; + buf[off] = readl(&theregs[off]); + } ++ ++ pm_runtime_mark_last_busy(dev); ++ pm_runtime_put_autosuspend(dev); + } + + static int fec_enet_get_ts_info(struct net_device *ndev, +diff --git a/drivers/net/ethernet/intel/i40e/i40e.h b/drivers/net/ethernet/intel/i40e/i40e.h +index 2af9f6308f84..401304d4d553 100644 +--- a/drivers/net/ethernet/intel/i40e/i40e.h ++++ b/drivers/net/ethernet/intel/i40e/i40e.h +@@ -1151,7 +1151,7 @@ void i40e_set_fec_in_flags(u8 fec_cfg, u32 *flags); + + static inline bool i40e_enabled_xdp_vsi(struct i40e_vsi *vsi) + { +- return !!vsi->xdp_prog; ++ return !!READ_ONCE(vsi->xdp_prog); + } + + int i40e_create_queue_channel(struct i40e_vsi *vsi, struct i40e_channel *ch); +diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c +index 339925af0206..4960c9c3e773 100644 +--- a/drivers/net/ethernet/intel/i40e/i40e_main.c ++++ b/drivers/net/ethernet/intel/i40e/i40e_main.c +@@ -6804,8 +6804,8 @@ void i40e_down(struct i40e_vsi *vsi) + for (i = 0; i < vsi->num_queue_pairs; i++) { + i40e_clean_tx_ring(vsi->tx_rings[i]); + if (i40e_enabled_xdp_vsi(vsi)) { +- /* Make sure that in-progress ndo_xdp_xmit +- * calls are completed. ++ /* Make sure that in-progress ndo_xdp_xmit and ++ * ndo_xsk_wakeup calls are completed. + */ + synchronize_rcu(); + i40e_clean_tx_ring(vsi->xdp_rings[i]); +@@ -12526,8 +12526,12 @@ static int i40e_xdp_setup(struct i40e_vsi *vsi, + + old_prog = xchg(&vsi->xdp_prog, prog); + +- if (need_reset) ++ if (need_reset) { ++ if (!prog) ++ /* Wait until ndo_xsk_wakeup completes. */ ++ synchronize_rcu(); + i40e_reset_and_rebuild(pf, true, true); ++ } + + for (i = 0; i < vsi->num_queue_pairs; i++) + WRITE_ONCE(vsi->rx_rings[i]->xdp_prog, vsi->xdp_prog); +diff --git a/drivers/net/ethernet/intel/i40e/i40e_xsk.c b/drivers/net/ethernet/intel/i40e/i40e_xsk.c +index d07e1a890428..f73cd917c44f 100644 +--- a/drivers/net/ethernet/intel/i40e/i40e_xsk.c ++++ b/drivers/net/ethernet/intel/i40e/i40e_xsk.c +@@ -787,8 +787,12 @@ int i40e_xsk_wakeup(struct net_device *dev, u32 queue_id, u32 flags) + { + struct i40e_netdev_priv *np = netdev_priv(dev); + struct i40e_vsi *vsi = np->vsi; ++ struct i40e_pf *pf = vsi->back; + struct i40e_ring *ring; + ++ if (test_bit(__I40E_CONFIG_BUSY, pf->state)) ++ return -ENETDOWN; ++ + if (test_bit(__I40E_VSI_DOWN, vsi->state)) + return -ENETDOWN; + +diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c +index 1a7203fede12..c6404abf2dd1 100644 +--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c ++++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c +@@ -10248,7 +10248,12 @@ static int ixgbe_xdp_setup(struct net_device *dev, struct bpf_prog *prog) + + /* If transitioning XDP modes reconfigure rings */ + if (need_reset) { +- int err = ixgbe_setup_tc(dev, adapter->hw_tcs); ++ int err; ++ ++ if (!prog) ++ /* Wait until ndo_xsk_wakeup completes. */ ++ synchronize_rcu(); ++ err = ixgbe_setup_tc(dev, adapter->hw_tcs); + + if (err) { + rcu_assign_pointer(adapter->xdp_prog, old_prog); +diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_xsk.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_xsk.c +index d6feaacfbf89..b43be9f14105 100644 +--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_xsk.c ++++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_xsk.c +@@ -709,10 +709,14 @@ int ixgbe_xsk_wakeup(struct net_device *dev, u32 qid, u32 flags) + if (qid >= adapter->num_xdp_queues) + return -ENXIO; + +- if (!adapter->xdp_ring[qid]->xsk_umem) ++ ring = adapter->xdp_ring[qid]; ++ ++ if (test_bit(__IXGBE_TX_DISABLED, &ring->state)) ++ return -ENETDOWN; ++ ++ if (!ring->xsk_umem) + return -ENXIO; + +- ring = adapter->xdp_ring[qid]; + if (!napi_if_scheduled_mark_missed(&ring->q_vector->napi)) { + u64 eics = BIT_ULL(ring->q_vector->v_idx); + +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en.h b/drivers/net/ethernet/mellanox/mlx5/core/en.h +index 2c16add0b642..9c8427698238 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en.h ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en.h +@@ -760,7 +760,7 @@ enum { + MLX5E_STATE_OPENED, + MLX5E_STATE_DESTROYING, + MLX5E_STATE_XDP_TX_ENABLED, +- MLX5E_STATE_XDP_OPEN, ++ MLX5E_STATE_XDP_ACTIVE, + }; + + struct mlx5e_rqt { +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en/fs.h b/drivers/net/ethernet/mellanox/mlx5/core/en/fs.h +index 68d593074f6c..d48292ccda29 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en/fs.h ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en/fs.h +@@ -122,6 +122,22 @@ enum { + #endif + }; + ++#define MLX5E_TTC_NUM_GROUPS 3 ++#define MLX5E_TTC_GROUP1_SIZE (BIT(3) + MLX5E_NUM_TUNNEL_TT) ++#define MLX5E_TTC_GROUP2_SIZE BIT(1) ++#define MLX5E_TTC_GROUP3_SIZE BIT(0) ++#define MLX5E_TTC_TABLE_SIZE (MLX5E_TTC_GROUP1_SIZE +\ ++ MLX5E_TTC_GROUP2_SIZE +\ ++ MLX5E_TTC_GROUP3_SIZE) ++ ++#define MLX5E_INNER_TTC_NUM_GROUPS 3 ++#define MLX5E_INNER_TTC_GROUP1_SIZE BIT(3) ++#define MLX5E_INNER_TTC_GROUP2_SIZE BIT(1) ++#define MLX5E_INNER_TTC_GROUP3_SIZE BIT(0) ++#define MLX5E_INNER_TTC_TABLE_SIZE (MLX5E_INNER_TTC_GROUP1_SIZE +\ ++ MLX5E_INNER_TTC_GROUP2_SIZE +\ ++ MLX5E_INNER_TTC_GROUP3_SIZE) ++ + #ifdef CONFIG_MLX5_EN_RXNFC + + struct mlx5e_ethtool_table { +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en/health.c b/drivers/net/ethernet/mellanox/mlx5/core/en/health.c +index 1d6b58860da6..3a975641f902 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en/health.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en/health.c +@@ -197,9 +197,10 @@ int mlx5e_health_report(struct mlx5e_priv *priv, + struct devlink_health_reporter *reporter, char *err_str, + struct mlx5e_err_ctx *err_ctx) + { +- if (!reporter) { +- netdev_err(priv->netdev, err_str); ++ netdev_err(priv->netdev, err_str); ++ ++ if (!reporter) + return err_ctx->recover(&err_ctx->ctx); +- } ++ + return devlink_health_report(reporter, err_str, err_ctx); + } +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en/xdp.h b/drivers/net/ethernet/mellanox/mlx5/core/en/xdp.h +index 36ac1e3816b9..d7587f40ecae 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en/xdp.h ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en/xdp.h +@@ -75,12 +75,18 @@ int mlx5e_xdp_xmit(struct net_device *dev, int n, struct xdp_frame **frames, + static inline void mlx5e_xdp_tx_enable(struct mlx5e_priv *priv) + { + set_bit(MLX5E_STATE_XDP_TX_ENABLED, &priv->state); ++ ++ if (priv->channels.params.xdp_prog) ++ set_bit(MLX5E_STATE_XDP_ACTIVE, &priv->state); + } + + static inline void mlx5e_xdp_tx_disable(struct mlx5e_priv *priv) + { ++ if (priv->channels.params.xdp_prog) ++ clear_bit(MLX5E_STATE_XDP_ACTIVE, &priv->state); ++ + clear_bit(MLX5E_STATE_XDP_TX_ENABLED, &priv->state); +- /* let other device's napi(s) see our new state */ ++ /* Let other device's napi(s) and XSK wakeups see our new state. */ + synchronize_rcu(); + } + +@@ -89,19 +95,9 @@ static inline bool mlx5e_xdp_tx_is_enabled(struct mlx5e_priv *priv) + return test_bit(MLX5E_STATE_XDP_TX_ENABLED, &priv->state); + } + +-static inline void mlx5e_xdp_set_open(struct mlx5e_priv *priv) +-{ +- set_bit(MLX5E_STATE_XDP_OPEN, &priv->state); +-} +- +-static inline void mlx5e_xdp_set_closed(struct mlx5e_priv *priv) +-{ +- clear_bit(MLX5E_STATE_XDP_OPEN, &priv->state); +-} +- +-static inline bool mlx5e_xdp_is_open(struct mlx5e_priv *priv) ++static inline bool mlx5e_xdp_is_active(struct mlx5e_priv *priv) + { +- return test_bit(MLX5E_STATE_XDP_OPEN, &priv->state); ++ return test_bit(MLX5E_STATE_XDP_ACTIVE, &priv->state); + } + + static inline void mlx5e_xmit_xdp_doorbell(struct mlx5e_xdpsq *sq) +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en/xsk/setup.c b/drivers/net/ethernet/mellanox/mlx5/core/en/xsk/setup.c +index 631af8dee517..c28cbae42331 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en/xsk/setup.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en/xsk/setup.c +@@ -144,6 +144,7 @@ void mlx5e_close_xsk(struct mlx5e_channel *c) + { + clear_bit(MLX5E_CHANNEL_STATE_XSK, c->state); + napi_synchronize(&c->napi); ++ synchronize_rcu(); /* Sync with the XSK wakeup. */ + + mlx5e_close_rq(&c->xskrq); + mlx5e_close_cq(&c->xskrq.cq); +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en/xsk/tx.c b/drivers/net/ethernet/mellanox/mlx5/core/en/xsk/tx.c +index 87827477d38c..fe2d596cb361 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en/xsk/tx.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en/xsk/tx.c +@@ -14,7 +14,7 @@ int mlx5e_xsk_wakeup(struct net_device *dev, u32 qid, u32 flags) + struct mlx5e_channel *c; + u16 ix; + +- if (unlikely(!mlx5e_xdp_is_open(priv))) ++ if (unlikely(!mlx5e_xdp_is_active(priv))) + return -ENETDOWN; + + if (unlikely(!mlx5e_qid_get_ch_if_in_group(params, qid, MLX5E_RQ_GROUP_XSK, &ix))) +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_fs.c b/drivers/net/ethernet/mellanox/mlx5/core/en_fs.c +index 15b7f0f1427c..73d3dc07331f 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en_fs.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en_fs.c +@@ -904,22 +904,6 @@ del_rules: + return err; + } + +-#define MLX5E_TTC_NUM_GROUPS 3 +-#define MLX5E_TTC_GROUP1_SIZE (BIT(3) + MLX5E_NUM_TUNNEL_TT) +-#define MLX5E_TTC_GROUP2_SIZE BIT(1) +-#define MLX5E_TTC_GROUP3_SIZE BIT(0) +-#define MLX5E_TTC_TABLE_SIZE (MLX5E_TTC_GROUP1_SIZE +\ +- MLX5E_TTC_GROUP2_SIZE +\ +- MLX5E_TTC_GROUP3_SIZE) +- +-#define MLX5E_INNER_TTC_NUM_GROUPS 3 +-#define MLX5E_INNER_TTC_GROUP1_SIZE BIT(3) +-#define MLX5E_INNER_TTC_GROUP2_SIZE BIT(1) +-#define MLX5E_INNER_TTC_GROUP3_SIZE BIT(0) +-#define MLX5E_INNER_TTC_TABLE_SIZE (MLX5E_INNER_TTC_GROUP1_SIZE +\ +- MLX5E_INNER_TTC_GROUP2_SIZE +\ +- MLX5E_INNER_TTC_GROUP3_SIZE) +- + static int mlx5e_create_ttc_table_groups(struct mlx5e_ttc_table *ttc, + bool use_ipv) + { +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c +index 6abd4ed5b69b..29a5a8c894e3 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c +@@ -3002,12 +3002,9 @@ void mlx5e_timestamp_init(struct mlx5e_priv *priv) + int mlx5e_open_locked(struct net_device *netdev) + { + struct mlx5e_priv *priv = netdev_priv(netdev); +- bool is_xdp = priv->channels.params.xdp_prog; + int err; + + set_bit(MLX5E_STATE_OPENED, &priv->state); +- if (is_xdp) +- mlx5e_xdp_set_open(priv); + + err = mlx5e_open_channels(priv, &priv->channels); + if (err) +@@ -3022,8 +3019,6 @@ int mlx5e_open_locked(struct net_device *netdev) + return 0; + + err_clear_state_opened_flag: +- if (is_xdp) +- mlx5e_xdp_set_closed(priv); + clear_bit(MLX5E_STATE_OPENED, &priv->state); + return err; + } +@@ -3055,8 +3050,6 @@ int mlx5e_close_locked(struct net_device *netdev) + if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) + return 0; + +- if (priv->channels.params.xdp_prog) +- mlx5e_xdp_set_closed(priv); + clear_bit(MLX5E_STATE_OPENED, &priv->state); + + netif_carrier_off(priv->netdev); +@@ -4373,16 +4366,6 @@ static int mlx5e_xdp_allowed(struct mlx5e_priv *priv, struct bpf_prog *prog) + return 0; + } + +-static int mlx5e_xdp_update_state(struct mlx5e_priv *priv) +-{ +- if (priv->channels.params.xdp_prog) +- mlx5e_xdp_set_open(priv); +- else +- mlx5e_xdp_set_closed(priv); +- +- return 0; +-} +- + static int mlx5e_xdp_set(struct net_device *netdev, struct bpf_prog *prog) + { + struct mlx5e_priv *priv = netdev_priv(netdev); +@@ -4422,7 +4405,7 @@ static int mlx5e_xdp_set(struct net_device *netdev, struct bpf_prog *prog) + mlx5e_set_rq_type(priv->mdev, &new_channels.params); + old_prog = priv->channels.params.xdp_prog; + +- err = mlx5e_safe_switch_channels(priv, &new_channels, mlx5e_xdp_update_state); ++ err = mlx5e_safe_switch_channels(priv, &new_channels, NULL); + if (err) + goto unlock; + } else { +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_tc.c b/drivers/net/ethernet/mellanox/mlx5/core/en_tc.c +index 814a4ba4e7fa..947122c68493 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en_tc.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en_tc.c +@@ -586,7 +586,7 @@ static void mlx5e_hairpin_set_ttc_params(struct mlx5e_hairpin *hp, + for (tt = 0; tt < MLX5E_NUM_INDIR_TIRS; tt++) + ttc_params->indir_tirn[tt] = hp->indir_tirn[tt]; + +- ft_attr->max_fte = MLX5E_NUM_TT; ++ ft_attr->max_fte = MLX5E_TTC_TABLE_SIZE; + ft_attr->level = MLX5E_TC_TTC_FT_LEVEL; + ft_attr->prio = MLX5E_TC_PRIO; + } +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/main.c b/drivers/net/ethernet/mellanox/mlx5/core/main.c +index 50ab88d80033..051ab845b501 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/main.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/main.c +@@ -1197,6 +1197,12 @@ static int mlx5_load_one(struct mlx5_core_dev *dev, bool boot) + if (err) + goto err_load; + ++ if (boot) { ++ err = mlx5_devlink_register(priv_to_devlink(dev), dev->device); ++ if (err) ++ goto err_devlink_reg; ++ } ++ + if (mlx5_device_registered(dev)) { + mlx5_attach_device(dev); + } else { +@@ -1214,6 +1220,9 @@ out: + return err; + + err_reg_dev: ++ if (boot) ++ mlx5_devlink_unregister(priv_to_devlink(dev)); ++err_devlink_reg: + mlx5_unload(dev); + err_load: + if (boot) +@@ -1353,10 +1362,6 @@ static int init_one(struct pci_dev *pdev, const struct pci_device_id *id) + + request_module_nowait(MLX5_IB_MOD); + +- err = mlx5_devlink_register(devlink, &pdev->dev); +- if (err) +- goto clean_load; +- + err = mlx5_crdump_enable(dev); + if (err) + dev_err(&pdev->dev, "mlx5_crdump_enable failed with error code %d\n", err); +@@ -1364,9 +1369,6 @@ static int init_one(struct pci_dev *pdev, const struct pci_device_id *id) + pci_save_state(pdev); + return 0; + +-clean_load: +- mlx5_unload_one(dev, true); +- + err_load_one: + mlx5_pci_close(dev); + pci_init_err: +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_rule.c b/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_rule.c +index bd1699e62142..e1a647dde978 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_rule.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_rule.c +@@ -209,7 +209,7 @@ static void dr_rule_rehash_copy_ste_ctrl(struct mlx5dr_matcher *matcher, + /* We need to copy the refcount since this ste + * may have been traversed several times + */ +- refcount_set(&new_ste->refcount, refcount_read(&cur_ste->refcount)); ++ new_ste->refcount = cur_ste->refcount; + + /* Link old STEs rule_mem list to the new ste */ + mlx5dr_rule_update_rule_member(cur_ste, new_ste); +@@ -638,6 +638,9 @@ static int dr_rule_add_member(struct mlx5dr_rule_rx_tx *nic_rule, + if (!rule_mem) + return -ENOMEM; + ++ INIT_LIST_HEAD(&rule_mem->list); ++ INIT_LIST_HEAD(&rule_mem->use_ste_list); ++ + rule_mem->ste = ste; + list_add_tail(&rule_mem->list, &nic_rule->rule_members_list); + +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_ste.c b/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_ste.c +index 3cbf74b44d1f..2739ed2a2911 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_ste.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_ste.c +@@ -340,7 +340,7 @@ static void dr_ste_replace(struct mlx5dr_ste *dst, struct mlx5dr_ste *src) + if (dst->next_htbl) + dst->next_htbl->pointing_ste = dst; + +- refcount_set(&dst->refcount, refcount_read(&src->refcount)); ++ dst->refcount = src->refcount; + + INIT_LIST_HEAD(&dst->rule_list); + list_splice_tail_init(&src->rule_list, &dst->rule_list); +@@ -557,7 +557,7 @@ bool mlx5dr_ste_is_not_valid_entry(u8 *p_hw_ste) + + bool mlx5dr_ste_not_used_ste(struct mlx5dr_ste *ste) + { +- return !refcount_read(&ste->refcount); ++ return !ste->refcount; + } + + /* Init one ste as a pattern for ste data array */ +@@ -681,14 +681,14 @@ struct mlx5dr_ste_htbl *mlx5dr_ste_htbl_alloc(struct mlx5dr_icm_pool *pool, + htbl->ste_arr = chunk->ste_arr; + htbl->hw_ste_arr = chunk->hw_ste_arr; + htbl->miss_list = chunk->miss_list; +- refcount_set(&htbl->refcount, 0); ++ htbl->refcount = 0; + + for (i = 0; i < chunk->num_of_entries; i++) { + struct mlx5dr_ste *ste = &htbl->ste_arr[i]; + + ste->hw_ste = htbl->hw_ste_arr + i * DR_STE_SIZE_REDUCED; + ste->htbl = htbl; +- refcount_set(&ste->refcount, 0); ++ ste->refcount = 0; + INIT_LIST_HEAD(&ste->miss_list_node); + INIT_LIST_HEAD(&htbl->miss_list[i]); + INIT_LIST_HEAD(&ste->rule_list); +@@ -705,7 +705,7 @@ out_free_htbl: + + int mlx5dr_ste_htbl_free(struct mlx5dr_ste_htbl *htbl) + { +- if (refcount_read(&htbl->refcount)) ++ if (htbl->refcount) + return -EBUSY; + + mlx5dr_icm_free_chunk(htbl->chunk); +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_types.h b/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_types.h +index 1cb3769d4e3c..31737dfca4ea 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_types.h ++++ b/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_types.h +@@ -117,7 +117,7 @@ struct mlx5dr_matcher_rx_tx; + struct mlx5dr_ste { + u8 *hw_ste; + /* refcount: indicates the num of rules that using this ste */ +- refcount_t refcount; ++ u32 refcount; + + /* attached to the miss_list head at each htbl entry */ + struct list_head miss_list_node; +@@ -149,7 +149,7 @@ struct mlx5dr_ste_htbl_ctrl { + struct mlx5dr_ste_htbl { + u8 lu_type; + u16 byte_mask; +- refcount_t refcount; ++ u32 refcount; + struct mlx5dr_icm_chunk *chunk; + struct mlx5dr_ste *ste_arr; + u8 *hw_ste_arr; +@@ -200,13 +200,14 @@ int mlx5dr_ste_htbl_free(struct mlx5dr_ste_htbl *htbl); + + static inline void mlx5dr_htbl_put(struct mlx5dr_ste_htbl *htbl) + { +- if (refcount_dec_and_test(&htbl->refcount)) ++ htbl->refcount--; ++ if (!htbl->refcount) + mlx5dr_ste_htbl_free(htbl); + } + + static inline void mlx5dr_htbl_get(struct mlx5dr_ste_htbl *htbl) + { +- refcount_inc(&htbl->refcount); ++ htbl->refcount++; + } + + /* STE utils */ +@@ -248,14 +249,15 @@ static inline void mlx5dr_ste_put(struct mlx5dr_ste *ste, + struct mlx5dr_matcher *matcher, + struct mlx5dr_matcher_rx_tx *nic_matcher) + { +- if (refcount_dec_and_test(&ste->refcount)) ++ ste->refcount--; ++ if (!ste->refcount) + mlx5dr_ste_free(ste, matcher, nic_matcher); + } + + /* initial as 0, increased only when ste appears in a new rule */ + static inline void mlx5dr_ste_get(struct mlx5dr_ste *ste) + { +- refcount_inc(&ste->refcount); ++ ste->refcount++; + } + + void mlx5dr_ste_set_hit_addr_by_next_htbl(u8 *hw_ste, +diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_qdisc.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_qdisc.c +index bdf53cf350f6..720514b5c006 100644 +--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_qdisc.c ++++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_qdisc.c +@@ -650,6 +650,13 @@ mlxsw_sp_qdisc_prio_graft(struct mlxsw_sp_port *mlxsw_sp_port, + mlxsw_sp_port->tclass_qdiscs[tclass_num].handle == p->child_handle) + return 0; + ++ if (!p->child_handle) { ++ /* This is an invisible FIFO replacing the original Qdisc. ++ * Ignore it--the original Qdisc's destroy will follow. ++ */ ++ return 0; ++ } ++ + /* See if the grafted qdisc is already offloaded on any tclass. If so, + * unoffload it. + */ +diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c b/drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c +index 6e47be63a43c..e9e0867ec139 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c ++++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c +@@ -957,6 +957,9 @@ static int sun8i_dwmac_set_syscon(struct stmmac_priv *priv) + /* default */ + break; + case PHY_INTERFACE_MODE_RGMII: ++ case PHY_INTERFACE_MODE_RGMII_ID: ++ case PHY_INTERFACE_MODE_RGMII_RXID: ++ case PHY_INTERFACE_MODE_RGMII_TXID: + reg |= SYSCON_EPIT | SYSCON_ETCS_INT_GMII; + break; + case PHY_INTERFACE_MODE_RMII: +diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-sunxi.c b/drivers/net/ethernet/stmicro/stmmac/dwmac-sunxi.c +index a299da3971b4..102d637bc84a 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/dwmac-sunxi.c ++++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-sunxi.c +@@ -44,7 +44,7 @@ static int sun7i_gmac_init(struct platform_device *pdev, void *priv) + * rate, which then uses the auto-reparenting feature of the + * clock driver, and enabling/disabling the clock. + */ +- if (gmac->interface == PHY_INTERFACE_MODE_RGMII) { ++ if (phy_interface_mode_is_rgmii(gmac->interface)) { + clk_set_rate(gmac->tx_clk, SUN7I_GMAC_GMII_RGMII_RATE); + clk_prepare_enable(gmac->tx_clk); + gmac->clk_enabled = 1; +diff --git a/drivers/net/ethernet/stmicro/stmmac/dwxgmac2.h b/drivers/net/ethernet/stmicro/stmmac/dwxgmac2.h +index 9d08a934fe4f..ff751ab3d765 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/dwxgmac2.h ++++ b/drivers/net/ethernet/stmicro/stmmac/dwxgmac2.h +@@ -343,6 +343,8 @@ + #define XGMAC_DMA_CH_RX_CONTROL(x) (0x00003108 + (0x80 * (x))) + #define XGMAC_RxPBL GENMASK(21, 16) + #define XGMAC_RxPBL_SHIFT 16 ++#define XGMAC_RBSZ GENMASK(14, 1) ++#define XGMAC_RBSZ_SHIFT 1 + #define XGMAC_RXST BIT(0) + #define XGMAC_DMA_CH_TxDESC_HADDR(x) (0x00003110 + (0x80 * (x))) + #define XGMAC_DMA_CH_TxDESC_LADDR(x) (0x00003114 + (0x80 * (x))) +diff --git a/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c b/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c +index f70ca5300b82..4af7271cea56 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c ++++ b/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c +@@ -489,7 +489,8 @@ static void dwxgmac2_set_bfsize(void __iomem *ioaddr, int bfsize, u32 chan) + u32 value; + + value = readl(ioaddr + XGMAC_DMA_CH_RX_CONTROL(chan)); +- value |= bfsize << 1; ++ value &= ~XGMAC_RBSZ; ++ value |= bfsize << XGMAC_RBSZ_SHIFT; + writel(value, ioaddr + XGMAC_DMA_CH_RX_CONTROL(chan)); + } + +diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c +index 271a00f24f45..903c5d8a226e 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c ++++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c +@@ -45,7 +45,7 @@ + #include "dwxgmac2.h" + #include "hwif.h" + +-#define STMMAC_ALIGN(x) __ALIGN_KERNEL(x, SMP_CACHE_BYTES) ++#define STMMAC_ALIGN(x) ALIGN(ALIGN(x, SMP_CACHE_BYTES), 16) + #define TSO_MAX_BUFF_SIZE (SZ_16K - 1) + + /* Module parameters */ +@@ -1292,19 +1292,9 @@ static int init_dma_rx_desc_rings(struct net_device *dev, gfp_t flags) + struct stmmac_priv *priv = netdev_priv(dev); + u32 rx_count = priv->plat->rx_queues_to_use; + int ret = -ENOMEM; +- int bfsize = 0; + int queue; + int i; + +- bfsize = stmmac_set_16kib_bfsize(priv, dev->mtu); +- if (bfsize < 0) +- bfsize = 0; +- +- if (bfsize < BUF_SIZE_16KiB) +- bfsize = stmmac_set_bfsize(dev->mtu, priv->dma_buf_sz); +- +- priv->dma_buf_sz = bfsize; +- + /* RX INITIALIZATION */ + netif_dbg(priv, probe, priv->dev, + "SKB addresses:\nskb\t\tskb data\tdma data\n"); +@@ -1346,8 +1336,6 @@ static int init_dma_rx_desc_rings(struct net_device *dev, gfp_t flags) + } + } + +- buf_sz = bfsize; +- + return 0; + + err_init_rx_buffers: +@@ -2654,6 +2642,7 @@ static void stmmac_hw_teardown(struct net_device *dev) + static int stmmac_open(struct net_device *dev) + { + struct stmmac_priv *priv = netdev_priv(dev); ++ int bfsize = 0; + u32 chan; + int ret; + +@@ -2673,7 +2662,16 @@ static int stmmac_open(struct net_device *dev) + memset(&priv->xstats, 0, sizeof(struct stmmac_extra_stats)); + priv->xstats.threshold = tc; + +- priv->dma_buf_sz = STMMAC_ALIGN(buf_sz); ++ bfsize = stmmac_set_16kib_bfsize(priv, dev->mtu); ++ if (bfsize < 0) ++ bfsize = 0; ++ ++ if (bfsize < BUF_SIZE_16KiB) ++ bfsize = stmmac_set_bfsize(dev->mtu, priv->dma_buf_sz); ++ ++ priv->dma_buf_sz = bfsize; ++ buf_sz = bfsize; ++ + priv->rx_copybreak = STMMAC_RX_COPYBREAK; + + ret = alloc_dma_desc_resources(priv); +@@ -3103,6 +3101,7 @@ static netdev_tx_t stmmac_tso_xmit(struct sk_buff *skb, struct net_device *dev) + + tx_q->tx_tail_addr = tx_q->dma_tx_phy + (tx_q->cur_tx * sizeof(*desc)); + stmmac_set_tx_tail_ptr(priv, priv->ioaddr, tx_q->tx_tail_addr, queue); ++ stmmac_tx_timer_arm(priv, queue); + + return NETDEV_TX_OK; + +@@ -3330,6 +3329,7 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev) + + tx_q->tx_tail_addr = tx_q->dma_tx_phy + (tx_q->cur_tx * sizeof(*desc)); + stmmac_set_tx_tail_ptr(priv, priv->ioaddr, tx_q->tx_tail_addr, queue); ++ stmmac_tx_timer_arm(priv, queue); + + return NETDEV_TX_OK; + +@@ -3747,12 +3747,24 @@ static void stmmac_set_rx_mode(struct net_device *dev) + static int stmmac_change_mtu(struct net_device *dev, int new_mtu) + { + struct stmmac_priv *priv = netdev_priv(dev); ++ int txfifosz = priv->plat->tx_fifo_size; ++ ++ if (txfifosz == 0) ++ txfifosz = priv->dma_cap.tx_fifo_size; ++ ++ txfifosz /= priv->plat->tx_queues_to_use; + + if (netif_running(dev)) { + netdev_err(priv->dev, "must be stopped to change its MTU\n"); + return -EBUSY; + } + ++ new_mtu = STMMAC_ALIGN(new_mtu); ++ ++ /* If condition true, FIFO is too small or MTU too large */ ++ if ((txfifosz < new_mtu) || (new_mtu > BUF_SIZE_16KiB)) ++ return -EINVAL; ++ + dev->mtu = new_mtu; + + netdev_update_features(dev); +diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c +index 1f230bd854c4..5150551c28be 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c ++++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c +@@ -320,7 +320,7 @@ out: + static int stmmac_dt_phy(struct plat_stmmacenet_data *plat, + struct device_node *np, struct device *dev) + { +- bool mdio = false; ++ bool mdio = !of_phy_is_fixed_link(np); + static const struct of_device_id need_mdio_ids[] = { + { .compatible = "snps,dwc-qos-ethernet-4.10" }, + {}, +diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c +index ac3f658105c0..a0513deab1a0 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c ++++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c +@@ -624,6 +624,8 @@ static int stmmac_test_mcfilt(struct stmmac_priv *priv) + return -EOPNOTSUPP; + if (netdev_uc_count(priv->dev) >= priv->hw->unicast_filter_entries) + return -EOPNOTSUPP; ++ if (netdev_mc_count(priv->dev) >= priv->hw->multicast_filter_bins) ++ return -EOPNOTSUPP; + + while (--tries) { + /* We only need to check the mc_addr for collisions */ +@@ -666,6 +668,8 @@ static int stmmac_test_ucfilt(struct stmmac_priv *priv) + + if (stmmac_filter_check(priv)) + return -EOPNOTSUPP; ++ if (netdev_uc_count(priv->dev) >= priv->hw->unicast_filter_entries) ++ return -EOPNOTSUPP; + if (netdev_mc_count(priv->dev) >= priv->hw->multicast_filter_bins) + return -EOPNOTSUPP; + +diff --git a/drivers/net/gtp.c b/drivers/net/gtp.c +index fca471e27f39..f6222ada6818 100644 +--- a/drivers/net/gtp.c ++++ b/drivers/net/gtp.c +@@ -813,7 +813,7 @@ static struct sock *gtp_encap_enable_socket(int fd, int type, + lock_sock(sock->sk); + if (sock->sk->sk_user_data) { + sk = ERR_PTR(-EBUSY); +- goto out_sock; ++ goto out_rel_sock; + } + + sk = sock->sk; +@@ -826,8 +826,9 @@ static struct sock *gtp_encap_enable_socket(int fd, int type, + + setup_udp_tunnel_sock(sock_net(sock->sk), sock, &tuncfg); + +-out_sock: ++out_rel_sock: + release_sock(sock->sk); ++out_sock: + sockfd_put(sock); + return sk; + } +diff --git a/drivers/net/hyperv/hyperv_net.h b/drivers/net/hyperv/hyperv_net.h +index fb547f37af1e..e74f2d1def80 100644 +--- a/drivers/net/hyperv/hyperv_net.h ++++ b/drivers/net/hyperv/hyperv_net.h +@@ -169,7 +169,6 @@ struct rndis_device { + + u8 hw_mac_adr[ETH_ALEN]; + u8 rss_key[NETVSC_HASH_KEYLEN]; +- u16 rx_table[ITAB_NUM]; + }; + + +@@ -938,6 +937,8 @@ struct net_device_context { + + u32 tx_table[VRSS_SEND_TAB_SIZE]; + ++ u16 rx_table[ITAB_NUM]; ++ + /* Ethtool settings */ + u8 duplex; + u32 speed; +diff --git a/drivers/net/hyperv/netvsc_drv.c b/drivers/net/hyperv/netvsc_drv.c +index 963509add611..78e3e689a733 100644 +--- a/drivers/net/hyperv/netvsc_drv.c ++++ b/drivers/net/hyperv/netvsc_drv.c +@@ -1659,7 +1659,7 @@ static int netvsc_get_rxfh(struct net_device *dev, u32 *indir, u8 *key, + rndis_dev = ndev->extension; + if (indir) { + for (i = 0; i < ITAB_NUM; i++) +- indir[i] = rndis_dev->rx_table[i]; ++ indir[i] = ndc->rx_table[i]; + } + + if (key) +@@ -1689,7 +1689,7 @@ static int netvsc_set_rxfh(struct net_device *dev, const u32 *indir, + return -EINVAL; + + for (i = 0; i < ITAB_NUM; i++) +- rndis_dev->rx_table[i] = indir[i]; ++ ndc->rx_table[i] = indir[i]; + } + + if (!key) { +diff --git a/drivers/net/hyperv/rndis_filter.c b/drivers/net/hyperv/rndis_filter.c +index e3d3c9097ff1..f81e58267a6e 100644 +--- a/drivers/net/hyperv/rndis_filter.c ++++ b/drivers/net/hyperv/rndis_filter.c +@@ -767,6 +767,7 @@ static int rndis_set_rss_param_msg(struct rndis_device *rdev, + const u8 *rss_key, u16 flag) + { + struct net_device *ndev = rdev->ndev; ++ struct net_device_context *ndc = netdev_priv(ndev); + struct rndis_request *request; + struct rndis_set_request *set; + struct rndis_set_complete *set_complete; +@@ -806,7 +807,7 @@ static int rndis_set_rss_param_msg(struct rndis_device *rdev, + /* Set indirection table entries */ + itab = (u32 *)(rssp + 1); + for (i = 0; i < ITAB_NUM; i++) +- itab[i] = rdev->rx_table[i]; ++ itab[i] = ndc->rx_table[i]; + + /* Set hask key values */ + keyp = (u8 *)((unsigned long)rssp + rssp->hashkey_offset); +@@ -1305,6 +1306,7 @@ struct netvsc_device *rndis_filter_device_add(struct hv_device *dev, + struct netvsc_device_info *device_info) + { + struct net_device *net = hv_get_drvdata(dev); ++ struct net_device_context *ndc = netdev_priv(net); + struct netvsc_device *net_device; + struct rndis_device *rndis_device; + struct ndis_recv_scale_cap rsscap; +@@ -1391,9 +1393,11 @@ struct netvsc_device *rndis_filter_device_add(struct hv_device *dev, + /* We will use the given number of channels if available. */ + net_device->num_chn = min(net_device->max_chn, device_info->num_chn); + +- for (i = 0; i < ITAB_NUM; i++) +- rndis_device->rx_table[i] = ethtool_rxfh_indir_default( ++ if (!netif_is_rxfh_configured(net)) { ++ for (i = 0; i < ITAB_NUM; i++) ++ ndc->rx_table[i] = ethtool_rxfh_indir_default( + i, net_device->num_chn); ++ } + + atomic_set(&net_device->open_chn, 1); + vmbus_set_sc_create_callback(dev->channel, netvsc_sc_open); +diff --git a/drivers/net/macvlan.c b/drivers/net/macvlan.c +index 05631d97eeb4..747c0542a53c 100644 +--- a/drivers/net/macvlan.c ++++ b/drivers/net/macvlan.c +@@ -259,7 +259,7 @@ static void macvlan_broadcast(struct sk_buff *skb, + struct net_device *src, + enum macvlan_mode mode) + { +- const struct ethhdr *eth = eth_hdr(skb); ++ const struct ethhdr *eth = skb_eth_hdr(skb); + const struct macvlan_dev *vlan; + struct sk_buff *nskb; + unsigned int i; +diff --git a/drivers/net/usb/lan78xx.c b/drivers/net/usb/lan78xx.c +index 0becc79fd431..3e5f2f7a155e 100644 +--- a/drivers/net/usb/lan78xx.c ++++ b/drivers/net/usb/lan78xx.c +@@ -511,7 +511,7 @@ static int lan78xx_read_stats(struct lan78xx_net *dev, + } + } else { + netdev_warn(dev->net, +- "Failed to read stat ret = 0x%x", ret); ++ "Failed to read stat ret = %d", ret); + } + + kfree(stats); +@@ -2724,11 +2724,6 @@ static int lan78xx_stop(struct net_device *net) + return 0; + } + +-static int lan78xx_linearize(struct sk_buff *skb) +-{ +- return skb_linearize(skb); +-} +- + static struct sk_buff *lan78xx_tx_prep(struct lan78xx_net *dev, + struct sk_buff *skb, gfp_t flags) + { +@@ -2740,8 +2735,10 @@ static struct sk_buff *lan78xx_tx_prep(struct lan78xx_net *dev, + return NULL; + } + +- if (lan78xx_linearize(skb) < 0) ++ if (skb_linearize(skb)) { ++ dev_kfree_skb_any(skb); + return NULL; ++ } + + tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_; + +diff --git a/drivers/net/vxlan.c b/drivers/net/vxlan.c +index 404ac3a0d1c3..283dfeb406ad 100644 +--- a/drivers/net/vxlan.c ++++ b/drivers/net/vxlan.c +@@ -2542,7 +2542,7 @@ static void vxlan_xmit_one(struct sk_buff *skb, struct net_device *dev, + ndst = &rt->dst; + skb_tunnel_check_pmtu(skb, ndst, VXLAN_HEADROOM); + +- tos = ip_tunnel_ecn_encap(tos, old_iph, skb); ++ tos = ip_tunnel_ecn_encap(RT_TOS(tos), old_iph, skb); + ttl = ttl ? : ip4_dst_hoplimit(&rt->dst); + err = vxlan_build_skb(skb, ndst, sizeof(struct iphdr), + vni, md, flags, udp_sum); +@@ -2582,7 +2582,7 @@ static void vxlan_xmit_one(struct sk_buff *skb, struct net_device *dev, + + skb_tunnel_check_pmtu(skb, ndst, VXLAN6_HEADROOM); + +- tos = ip_tunnel_ecn_encap(tos, old_iph, skb); ++ tos = ip_tunnel_ecn_encap(RT_TOS(tos), old_iph, skb); + ttl = ttl ? : ip6_dst_hoplimit(ndst); + skb_scrub_packet(skb, xnet); + err = vxlan_build_skb(skb, ndst, sizeof(struct ipv6hdr), +diff --git a/drivers/net/wireless/marvell/mwifiex/tdls.c b/drivers/net/wireless/marvell/mwifiex/tdls.c +index 09313047beed..7caf1d26124a 100644 +--- a/drivers/net/wireless/marvell/mwifiex/tdls.c ++++ b/drivers/net/wireless/marvell/mwifiex/tdls.c +@@ -953,59 +953,117 @@ void mwifiex_process_tdls_action_frame(struct mwifiex_private *priv, + + switch (*pos) { + case WLAN_EID_SUPP_RATES: ++ if (pos[1] > 32) ++ return; + sta_ptr->tdls_cap.rates_len = pos[1]; + for (i = 0; i < pos[1]; i++) + sta_ptr->tdls_cap.rates[i] = pos[i + 2]; + break; + + case WLAN_EID_EXT_SUPP_RATES: ++ if (pos[1] > 32) ++ return; + basic = sta_ptr->tdls_cap.rates_len; ++ if (pos[1] > 32 - basic) ++ return; + for (i = 0; i < pos[1]; i++) + sta_ptr->tdls_cap.rates[basic + i] = pos[i + 2]; + sta_ptr->tdls_cap.rates_len += pos[1]; + break; + case WLAN_EID_HT_CAPABILITY: +- memcpy((u8 *)&sta_ptr->tdls_cap.ht_capb, pos, ++ if (pos > end - sizeof(struct ieee80211_ht_cap) - 2) ++ return; ++ if (pos[1] != sizeof(struct ieee80211_ht_cap)) ++ return; ++ /* copy the ie's value into ht_capb*/ ++ memcpy((u8 *)&sta_ptr->tdls_cap.ht_capb, pos + 2, + sizeof(struct ieee80211_ht_cap)); + sta_ptr->is_11n_enabled = 1; + break; + case WLAN_EID_HT_OPERATION: +- memcpy(&sta_ptr->tdls_cap.ht_oper, pos, ++ if (pos > end - ++ sizeof(struct ieee80211_ht_operation) - 2) ++ return; ++ if (pos[1] != sizeof(struct ieee80211_ht_operation)) ++ return; ++ /* copy the ie's value into ht_oper*/ ++ memcpy(&sta_ptr->tdls_cap.ht_oper, pos + 2, + sizeof(struct ieee80211_ht_operation)); + break; + case WLAN_EID_BSS_COEX_2040: ++ if (pos > end - 3) ++ return; ++ if (pos[1] != 1) ++ return; + sta_ptr->tdls_cap.coex_2040 = pos[2]; + break; + case WLAN_EID_EXT_CAPABILITY: ++ if (pos > end - sizeof(struct ieee_types_header)) ++ return; ++ if (pos[1] < sizeof(struct ieee_types_header)) ++ return; ++ if (pos[1] > 8) ++ return; + memcpy((u8 *)&sta_ptr->tdls_cap.extcap, pos, + sizeof(struct ieee_types_header) + + min_t(u8, pos[1], 8)); + break; + case WLAN_EID_RSN: ++ if (pos > end - sizeof(struct ieee_types_header)) ++ return; ++ if (pos[1] < sizeof(struct ieee_types_header)) ++ return; ++ if (pos[1] > IEEE_MAX_IE_SIZE - ++ sizeof(struct ieee_types_header)) ++ return; + memcpy((u8 *)&sta_ptr->tdls_cap.rsn_ie, pos, + sizeof(struct ieee_types_header) + + min_t(u8, pos[1], IEEE_MAX_IE_SIZE - + sizeof(struct ieee_types_header))); + break; + case WLAN_EID_QOS_CAPA: ++ if (pos > end - 3) ++ return; ++ if (pos[1] != 1) ++ return; + sta_ptr->tdls_cap.qos_info = pos[2]; + break; + case WLAN_EID_VHT_OPERATION: +- if (priv->adapter->is_hw_11ac_capable) +- memcpy(&sta_ptr->tdls_cap.vhtoper, pos, ++ if (priv->adapter->is_hw_11ac_capable) { ++ if (pos > end - ++ sizeof(struct ieee80211_vht_operation) - 2) ++ return; ++ if (pos[1] != ++ sizeof(struct ieee80211_vht_operation)) ++ return; ++ /* copy the ie's value into vhtoper*/ ++ memcpy(&sta_ptr->tdls_cap.vhtoper, pos + 2, + sizeof(struct ieee80211_vht_operation)); ++ } + break; + case WLAN_EID_VHT_CAPABILITY: + if (priv->adapter->is_hw_11ac_capable) { +- memcpy((u8 *)&sta_ptr->tdls_cap.vhtcap, pos, ++ if (pos > end - ++ sizeof(struct ieee80211_vht_cap) - 2) ++ return; ++ if (pos[1] != sizeof(struct ieee80211_vht_cap)) ++ return; ++ /* copy the ie's value into vhtcap*/ ++ memcpy((u8 *)&sta_ptr->tdls_cap.vhtcap, pos + 2, + sizeof(struct ieee80211_vht_cap)); + sta_ptr->is_11ac_enabled = 1; + } + break; + case WLAN_EID_AID: +- if (priv->adapter->is_hw_11ac_capable) ++ if (priv->adapter->is_hw_11ac_capable) { ++ if (pos > end - 4) ++ return; ++ if (pos[1] != 2) ++ return; + sta_ptr->tdls_cap.aid = + get_unaligned_le16((pos + 2)); ++ } ++ break; + default: + break; + } +diff --git a/drivers/perf/arm_smmuv3_pmu.c b/drivers/perf/arm_smmuv3_pmu.c +index abcf54f7d19c..191f410cf35c 100644 +--- a/drivers/perf/arm_smmuv3_pmu.c ++++ b/drivers/perf/arm_smmuv3_pmu.c +@@ -815,7 +815,7 @@ static int smmu_pmu_probe(struct platform_device *pdev) + if (err) { + dev_err(dev, "Error %d registering hotplug, PMU @%pa\n", + err, &res_0->start); +- goto out_cpuhp_err; ++ return err; + } + + err = perf_pmu_register(&smmu_pmu->pmu, name, -1); +@@ -834,8 +834,6 @@ static int smmu_pmu_probe(struct platform_device *pdev) + + out_unregister: + cpuhp_state_remove_instance_nocalls(cpuhp_state_num, &smmu_pmu->node); +-out_cpuhp_err: +- put_cpu(); + return err; + } + +diff --git a/drivers/pinctrl/aspeed/pinctrl-aspeed-g6.c b/drivers/pinctrl/aspeed/pinctrl-aspeed-g6.c +index c6800d220920..bb07024d22ed 100644 +--- a/drivers/pinctrl/aspeed/pinctrl-aspeed-g6.c ++++ b/drivers/pinctrl/aspeed/pinctrl-aspeed-g6.c +@@ -1088,60 +1088,52 @@ SSSF_PIN_DECL(AF15, GPIOV7, LPCSMI, SIG_DESC_SET(SCU434, 15)); + + #define AB7 176 + SIG_EXPR_LIST_DECL_SESG(AB7, LAD0, LPC, SIG_DESC_SET(SCU434, 16), +- SIG_DESC_CLEAR(SCU510, 6)); +-SIG_EXPR_LIST_DECL_SESG(AB7, ESPID0, ESPI, SIG_DESC_SET(SCU434, 16), + SIG_DESC_SET(SCU510, 6)); ++SIG_EXPR_LIST_DECL_SESG(AB7, ESPID0, ESPI, SIG_DESC_SET(SCU434, 16)); + PIN_DECL_2(AB7, GPIOW0, LAD0, ESPID0); + + #define AB8 177 + SIG_EXPR_LIST_DECL_SESG(AB8, LAD1, LPC, SIG_DESC_SET(SCU434, 17), +- SIG_DESC_CLEAR(SCU510, 6)); +-SIG_EXPR_LIST_DECL_SESG(AB8, ESPID1, ESPI, SIG_DESC_SET(SCU434, 17), + SIG_DESC_SET(SCU510, 6)); ++SIG_EXPR_LIST_DECL_SESG(AB8, ESPID1, ESPI, SIG_DESC_SET(SCU434, 17)); + PIN_DECL_2(AB8, GPIOW1, LAD1, ESPID1); + + #define AC8 178 + SIG_EXPR_LIST_DECL_SESG(AC8, LAD2, LPC, SIG_DESC_SET(SCU434, 18), +- SIG_DESC_CLEAR(SCU510, 6)); +-SIG_EXPR_LIST_DECL_SESG(AC8, ESPID2, ESPI, SIG_DESC_SET(SCU434, 18), + SIG_DESC_SET(SCU510, 6)); ++SIG_EXPR_LIST_DECL_SESG(AC8, ESPID2, ESPI, SIG_DESC_SET(SCU434, 18)); + PIN_DECL_2(AC8, GPIOW2, LAD2, ESPID2); + + #define AC7 179 + SIG_EXPR_LIST_DECL_SESG(AC7, LAD3, LPC, SIG_DESC_SET(SCU434, 19), +- SIG_DESC_CLEAR(SCU510, 6)); +-SIG_EXPR_LIST_DECL_SESG(AC7, ESPID3, ESPI, SIG_DESC_SET(SCU434, 19), + SIG_DESC_SET(SCU510, 6)); ++SIG_EXPR_LIST_DECL_SESG(AC7, ESPID3, ESPI, SIG_DESC_SET(SCU434, 19)); + PIN_DECL_2(AC7, GPIOW3, LAD3, ESPID3); + + #define AE7 180 + SIG_EXPR_LIST_DECL_SESG(AE7, LCLK, LPC, SIG_DESC_SET(SCU434, 20), +- SIG_DESC_CLEAR(SCU510, 6)); +-SIG_EXPR_LIST_DECL_SESG(AE7, ESPICK, ESPI, SIG_DESC_SET(SCU434, 20), + SIG_DESC_SET(SCU510, 6)); ++SIG_EXPR_LIST_DECL_SESG(AE7, ESPICK, ESPI, SIG_DESC_SET(SCU434, 20)); + PIN_DECL_2(AE7, GPIOW4, LCLK, ESPICK); + + #define AF7 181 + SIG_EXPR_LIST_DECL_SESG(AF7, LFRAME, LPC, SIG_DESC_SET(SCU434, 21), +- SIG_DESC_CLEAR(SCU510, 6)); +-SIG_EXPR_LIST_DECL_SESG(AF7, ESPICS, ESPI, SIG_DESC_SET(SCU434, 21), + SIG_DESC_SET(SCU510, 6)); ++SIG_EXPR_LIST_DECL_SESG(AF7, ESPICS, ESPI, SIG_DESC_SET(SCU434, 21)); + PIN_DECL_2(AF7, GPIOW5, LFRAME, ESPICS); + + #define AD7 182 + SIG_EXPR_LIST_DECL_SESG(AD7, LSIRQ, LSIRQ, SIG_DESC_SET(SCU434, 22), +- SIG_DESC_CLEAR(SCU510, 6)); +-SIG_EXPR_LIST_DECL_SESG(AD7, ESPIALT, ESPIALT, SIG_DESC_SET(SCU434, 22), + SIG_DESC_SET(SCU510, 6)); ++SIG_EXPR_LIST_DECL_SESG(AD7, ESPIALT, ESPIALT, SIG_DESC_SET(SCU434, 22)); + PIN_DECL_2(AD7, GPIOW6, LSIRQ, ESPIALT); + FUNC_GROUP_DECL(LSIRQ, AD7); + FUNC_GROUP_DECL(ESPIALT, AD7); + + #define AD8 183 + SIG_EXPR_LIST_DECL_SESG(AD8, LPCRST, LPC, SIG_DESC_SET(SCU434, 23), +- SIG_DESC_CLEAR(SCU510, 6)); +-SIG_EXPR_LIST_DECL_SESG(AD8, ESPIRST, ESPI, SIG_DESC_SET(SCU434, 23), + SIG_DESC_SET(SCU510, 6)); ++SIG_EXPR_LIST_DECL_SESG(AD8, ESPIRST, ESPI, SIG_DESC_SET(SCU434, 23)); + PIN_DECL_2(AD8, GPIOW7, LPCRST, ESPIRST); + + FUNC_GROUP_DECL(LPC, AB7, AB8, AC8, AC7, AE7, AF7, AD8); +diff --git a/drivers/pinctrl/pinmux.c b/drivers/pinctrl/pinmux.c +index e914f6efd39e..9503ddf2edc7 100644 +--- a/drivers/pinctrl/pinmux.c ++++ b/drivers/pinctrl/pinmux.c +@@ -85,7 +85,7 @@ bool pinmux_can_be_used_for_gpio(struct pinctrl_dev *pctldev, unsigned pin) + const struct pinmux_ops *ops = pctldev->desc->pmxops; + + /* Can't inspect pin, assume it can be used */ +- if (!desc) ++ if (!desc || !ops) + return true; + + if (ops->strict && desc->mux_usecount) +diff --git a/drivers/platform/x86/pcengines-apuv2.c b/drivers/platform/x86/pcengines-apuv2.c +index 48b112b4f0b0..c32daf087640 100644 +--- a/drivers/platform/x86/pcengines-apuv2.c ++++ b/drivers/platform/x86/pcengines-apuv2.c +@@ -95,7 +95,7 @@ static struct gpiod_lookup_table gpios_led_table = { + NULL, 1, GPIO_ACTIVE_LOW), + GPIO_LOOKUP_IDX(AMD_FCH_GPIO_DRIVER_NAME, APU2_GPIO_LINE_LED3, + NULL, 2, GPIO_ACTIVE_LOW), +- GPIO_LOOKUP_IDX(AMD_FCH_GPIO_DRIVER_NAME, APU2_GPIO_REG_SIMSWAP, ++ GPIO_LOOKUP_IDX(AMD_FCH_GPIO_DRIVER_NAME, APU2_GPIO_LINE_SIMSWAP, + NULL, 3, GPIO_ACTIVE_LOW), + } + }; +diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c +index 87bc06b386a0..1dba0bdf3762 100644 +--- a/drivers/regulator/core.c ++++ b/drivers/regulator/core.c +@@ -1937,8 +1937,8 @@ struct regulator *_regulator_get(struct device *dev, const char *id, + regulator = create_regulator(rdev, dev, id); + if (regulator == NULL) { + regulator = ERR_PTR(-ENOMEM); +- put_device(&rdev->dev); + module_put(rdev->owner); ++ put_device(&rdev->dev); + return regulator; + } + +@@ -2059,13 +2059,13 @@ static void _regulator_put(struct regulator *regulator) + + rdev->open_count--; + rdev->exclusive = 0; +- put_device(&rdev->dev); + regulator_unlock(rdev); + + kfree_const(regulator->supply_name); + kfree(regulator); + + module_put(rdev->owner); ++ put_device(&rdev->dev); + } + + /** +@@ -4992,6 +4992,7 @@ regulator_register(const struct regulator_desc *regulator_desc, + struct regulator_dev *rdev; + bool dangling_cfg_gpiod = false; + bool dangling_of_gpiod = false; ++ bool reg_device_fail = false; + struct device *dev; + int ret, i; + +@@ -5177,7 +5178,7 @@ regulator_register(const struct regulator_desc *regulator_desc, + dev_set_drvdata(&rdev->dev, rdev); + ret = device_register(&rdev->dev); + if (ret != 0) { +- put_device(&rdev->dev); ++ reg_device_fail = true; + goto unset_supplies; + } + +@@ -5208,7 +5209,10 @@ wash: + clean: + if (dangling_of_gpiod) + gpiod_put(config->ena_gpiod); +- kfree(rdev); ++ if (reg_device_fail) ++ put_device(&rdev->dev); ++ else ++ kfree(rdev); + kfree(config); + rinse: + if (dangling_cfg_gpiod) +diff --git a/drivers/regulator/rn5t618-regulator.c b/drivers/regulator/rn5t618-regulator.c +index eb807a059479..aa6e7c5341ce 100644 +--- a/drivers/regulator/rn5t618-regulator.c ++++ b/drivers/regulator/rn5t618-regulator.c +@@ -148,6 +148,7 @@ static struct platform_driver rn5t618_regulator_driver = { + + module_platform_driver(rn5t618_regulator_driver); + ++MODULE_ALIAS("platform:rn5t618-regulator"); + MODULE_AUTHOR("Beniamino Galvani "); + MODULE_DESCRIPTION("RN5T618 regulator driver"); + MODULE_LICENSE("GPL v2"); +diff --git a/drivers/reset/core.c b/drivers/reset/core.c +index 3c9a64c1b7a8..f343bd814d32 100644 +--- a/drivers/reset/core.c ++++ b/drivers/reset/core.c +@@ -787,7 +787,7 @@ struct reset_control *__devm_reset_control_get(struct device *dev, + return ERR_PTR(-ENOMEM); + + rstc = __reset_control_get(dev, id, index, shared, optional, acquired); +- if (!IS_ERR(rstc)) { ++ if (!IS_ERR_OR_NULL(rstc)) { + *ptr = rstc; + devres_add(dev, ptr); + } else { +@@ -930,7 +930,7 @@ devm_reset_control_array_get(struct device *dev, bool shared, bool optional) + return ERR_PTR(-ENOMEM); + + rstc = of_reset_control_array_get(dev->of_node, shared, optional, true); +- if (IS_ERR(rstc)) { ++ if (IS_ERR_OR_NULL(rstc)) { + devres_free(devres); + return rstc; + } +diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c +index c94184d080f8..a28b9ff82378 100644 +--- a/drivers/s390/block/dasd_eckd.c ++++ b/drivers/s390/block/dasd_eckd.c +@@ -1128,7 +1128,8 @@ static u32 get_fcx_max_data(struct dasd_device *device) + { + struct dasd_eckd_private *private = device->private; + int fcx_in_css, fcx_in_gneq, fcx_in_features; +- int tpm, mdc; ++ unsigned int mdc; ++ int tpm; + + if (dasd_nofcx) + return 0; +@@ -1142,7 +1143,7 @@ static u32 get_fcx_max_data(struct dasd_device *device) + return 0; + + mdc = ccw_device_get_mdc(device->cdev, 0); +- if (mdc < 0) { ++ if (mdc == 0) { + dev_warn(&device->cdev->dev, "Detecting the maximum supported data size for zHPF requests failed\n"); + return 0; + } else { +@@ -1153,12 +1154,12 @@ static u32 get_fcx_max_data(struct dasd_device *device) + static int verify_fcx_max_data(struct dasd_device *device, __u8 lpm) + { + struct dasd_eckd_private *private = device->private; +- int mdc; ++ unsigned int mdc; + u32 fcx_max_data; + + if (private->fcx_max_data) { + mdc = ccw_device_get_mdc(device->cdev, lpm); +- if ((mdc < 0)) { ++ if (mdc == 0) { + dev_warn(&device->cdev->dev, + "Detecting the maximum data size for zHPF " + "requests failed (rc=%d) for a new path %x\n", +@@ -2073,7 +2074,7 @@ out_err2: + dasd_free_block(device->block); + device->block = NULL; + out_err1: +- kfree(private->conf_data); ++ dasd_eckd_clear_conf_data(device); + kfree(device->private); + device->private = NULL; + return rc; +@@ -2082,7 +2083,6 @@ out_err1: + static void dasd_eckd_uncheck_device(struct dasd_device *device) + { + struct dasd_eckd_private *private = device->private; +- int i; + + if (!private) + return; +@@ -2092,21 +2092,7 @@ static void dasd_eckd_uncheck_device(struct dasd_device *device) + private->sneq = NULL; + private->vdsneq = NULL; + private->gneq = NULL; +- private->conf_len = 0; +- for (i = 0; i < 8; i++) { +- kfree(device->path[i].conf_data); +- if ((__u8 *)device->path[i].conf_data == +- private->conf_data) { +- private->conf_data = NULL; +- private->conf_len = 0; +- } +- device->path[i].conf_data = NULL; +- device->path[i].cssid = 0; +- device->path[i].ssid = 0; +- device->path[i].chpid = 0; +- } +- kfree(private->conf_data); +- private->conf_data = NULL; ++ dasd_eckd_clear_conf_data(device); + } + + static struct dasd_ccw_req * +diff --git a/drivers/s390/cio/device_ops.c b/drivers/s390/cio/device_ops.c +index 65841af15748..ccecf6b9504e 100644 +--- a/drivers/s390/cio/device_ops.c ++++ b/drivers/s390/cio/device_ops.c +@@ -635,7 +635,7 @@ EXPORT_SYMBOL(ccw_device_tm_start_timeout); + * @mask: mask of paths to use + * + * Return the number of 64K-bytes blocks all paths at least support +- * for a transport command. Return values <= 0 indicate failures. ++ * for a transport command. Return value 0 indicates failure. + */ + int ccw_device_get_mdc(struct ccw_device *cdev, u8 mask) + { +diff --git a/drivers/s390/net/qeth_core_main.c b/drivers/s390/net/qeth_core_main.c +index 83794d7494d4..9df47421d69c 100644 +--- a/drivers/s390/net/qeth_core_main.c ++++ b/drivers/s390/net/qeth_core_main.c +@@ -653,17 +653,17 @@ static int qeth_check_idx_response(struct qeth_card *card, + unsigned char *buffer) + { + QETH_DBF_HEX(CTRL, 2, buffer, QETH_DBF_CTRL_LEN); +- if ((buffer[2] & 0xc0) == 0xc0) { ++ if ((buffer[2] & QETH_IDX_TERMINATE_MASK) == QETH_IDX_TERMINATE) { + QETH_DBF_MESSAGE(2, "received an IDX TERMINATE with cause code %#04x\n", + buffer[4]); + QETH_CARD_TEXT(card, 2, "ckidxres"); + QETH_CARD_TEXT(card, 2, " idxterm"); +- QETH_CARD_TEXT_(card, 2, " rc%d", -EIO); +- if (buffer[4] == 0xf6) { ++ QETH_CARD_TEXT_(card, 2, "rc%x", buffer[4]); ++ if (buffer[4] == QETH_IDX_TERM_BAD_TRANSPORT || ++ buffer[4] == QETH_IDX_TERM_BAD_TRANSPORT_VM) { + dev_err(&card->gdev->dev, +- "The qeth device is not configured " +- "for the OSI layer required by z/VM\n"); +- return -EPERM; ++ "The device does not support the configured transport mode\n"); ++ return -EPROTONOSUPPORT; + } + return -EIO; + } +@@ -740,10 +740,10 @@ static void qeth_issue_next_read_cb(struct qeth_card *card, + case 0: + break; + case -EIO: +- qeth_clear_ipacmd_list(card); + qeth_schedule_recovery(card); + /* fall through */ + default: ++ qeth_clear_ipacmd_list(card); + goto out; + } + +diff --git a/drivers/s390/net/qeth_core_mpc.h b/drivers/s390/net/qeth_core_mpc.h +index 6420b58cf42b..b7c17b5c823b 100644 +--- a/drivers/s390/net/qeth_core_mpc.h ++++ b/drivers/s390/net/qeth_core_mpc.h +@@ -912,6 +912,11 @@ extern unsigned char IDX_ACTIVATE_WRITE[]; + #define QETH_IDX_ACT_ERR_AUTH 0x1E + #define QETH_IDX_ACT_ERR_AUTH_USER 0x20 + ++#define QETH_IDX_TERMINATE 0xc0 ++#define QETH_IDX_TERMINATE_MASK 0xc0 ++#define QETH_IDX_TERM_BAD_TRANSPORT 0x41 ++#define QETH_IDX_TERM_BAD_TRANSPORT_VM 0xf6 ++ + #define PDU_ENCAPSULATION(buffer) \ + (buffer + *(buffer + (*(buffer + 0x0b)) + \ + *(buffer + *(buffer + 0x0b) + 0x11) + 0x07)) +diff --git a/drivers/s390/net/qeth_core_sys.c b/drivers/s390/net/qeth_core_sys.c +index 9f392497d570..4c3e222e5572 100644 +--- a/drivers/s390/net/qeth_core_sys.c ++++ b/drivers/s390/net/qeth_core_sys.c +@@ -227,7 +227,7 @@ static ssize_t qeth_dev_prioqing_store(struct device *dev, + card->qdio.default_out_queue = QETH_DEFAULT_QUEUE; + } else if (sysfs_streq(buf, "prio_queueing_vlan")) { + if (IS_LAYER3(card)) { +- rc = -ENOTSUPP; ++ rc = -EOPNOTSUPP; + goto out; + } + card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_VLAN; +diff --git a/drivers/s390/net/qeth_l2_main.c b/drivers/s390/net/qeth_l2_main.c +index 4bccdce19b5a..8b7d911dccd8 100644 +--- a/drivers/s390/net/qeth_l2_main.c ++++ b/drivers/s390/net/qeth_l2_main.c +@@ -295,6 +295,7 @@ static void qeth_l2_stop_card(struct qeth_card *card) + + flush_workqueue(card->event_wq); + card->info.mac_bits &= ~QETH_LAYER2_MAC_REGISTERED; ++ card->info.promisc_mode = 0; + } + + static int qeth_l2_process_inbound_buffer(struct qeth_card *card, +diff --git a/drivers/s390/net/qeth_l2_sys.c b/drivers/s390/net/qeth_l2_sys.c +index e2bcb26105a3..fc7101ad84de 100644 +--- a/drivers/s390/net/qeth_l2_sys.c ++++ b/drivers/s390/net/qeth_l2_sys.c +@@ -279,7 +279,8 @@ void qeth_l2_setup_bridgeport_attrs(struct qeth_card *card) + return; + + mutex_lock(&card->sbp_lock); +- if (card->options.sbp.role != QETH_SBP_ROLE_NONE) { ++ if (!card->options.sbp.reflect_promisc && ++ card->options.sbp.role != QETH_SBP_ROLE_NONE) { + /* Conditional to avoid spurious error messages */ + qeth_bridgeport_setrole(card, card->options.sbp.role); + /* Let the callback function refresh the stored role value. */ +diff --git a/drivers/s390/net/qeth_l3_main.c b/drivers/s390/net/qeth_l3_main.c +index d7bfc7a0e4c0..32385327539b 100644 +--- a/drivers/s390/net/qeth_l3_main.c ++++ b/drivers/s390/net/qeth_l3_main.c +@@ -1433,6 +1433,7 @@ static void qeth_l3_stop_card(struct qeth_card *card) + } + + flush_workqueue(card->event_wq); ++ card->info.promisc_mode = 0; + } + + static void qeth_l3_set_promisc_mode(struct qeth_card *card) +diff --git a/drivers/spi/spi-cavium-thunderx.c b/drivers/spi/spi-cavium-thunderx.c +index d12e149f1a41..fd6b9caffaf0 100644 +--- a/drivers/spi/spi-cavium-thunderx.c ++++ b/drivers/spi/spi-cavium-thunderx.c +@@ -82,6 +82,7 @@ static int thunderx_spi_probe(struct pci_dev *pdev, + + error: + clk_disable_unprepare(p->clk); ++ pci_release_regions(pdev); + spi_master_put(master); + return ret; + } +@@ -96,6 +97,7 @@ static void thunderx_spi_remove(struct pci_dev *pdev) + return; + + clk_disable_unprepare(p->clk); ++ pci_release_regions(pdev); + /* Put everything in a known state. */ + writeq(0, p->register_base + OCTEON_SPI_CFG(p)); + } +diff --git a/drivers/spi/spi-fsl-spi.c b/drivers/spi/spi-fsl-spi.c +index 2d563874b4ac..be7c6ba73072 100644 +--- a/drivers/spi/spi-fsl-spi.c ++++ b/drivers/spi/spi-fsl-spi.c +@@ -612,6 +612,7 @@ static struct spi_master * fsl_spi_probe(struct device *dev, + master->setup = fsl_spi_setup; + master->cleanup = fsl_spi_cleanup; + master->transfer_one_message = fsl_spi_do_one_msg; ++ master->use_gpio_descriptors = true; + + mpc8xxx_spi = spi_master_get_devdata(master); + mpc8xxx_spi->max_bits_per_word = 32; +@@ -728,8 +729,18 @@ static int of_fsl_spi_probe(struct platform_device *ofdev) + } + } + #endif +- +- pdata->cs_control = fsl_spi_cs_control; ++ /* ++ * Handle the case where we have one hardwired (always selected) ++ * device on the first "chipselect". Else we let the core code ++ * handle any GPIOs or native chip selects and assign the ++ * appropriate callback for dealing with the CS lines. This isn't ++ * supported on the GRLIB variant. ++ */ ++ ret = gpiod_count(dev, "cs"); ++ if (ret <= 0) ++ pdata->max_chipselect = 1; ++ else ++ pdata->cs_control = fsl_spi_cs_control; + } + + ret = of_address_to_resource(np, 0, &mem); +diff --git a/drivers/spi/spi-nxp-fspi.c b/drivers/spi/spi-nxp-fspi.c +index 501b923f2c27..28ae5229f889 100644 +--- a/drivers/spi/spi-nxp-fspi.c ++++ b/drivers/spi/spi-nxp-fspi.c +@@ -439,7 +439,7 @@ static bool nxp_fspi_supports_op(struct spi_mem *mem, + op->data.nbytes > f->devtype_data->txfifo) + return false; + +- return true; ++ return spi_mem_default_supports_op(mem, op); + } + + /* Instead of busy looping invoke readl_poll_timeout functionality. */ +diff --git a/drivers/spi/spi-pxa2xx.c b/drivers/spi/spi-pxa2xx.c +index 2e73d75a6ac5..ae95ec0bc964 100644 +--- a/drivers/spi/spi-pxa2xx.c ++++ b/drivers/spi/spi-pxa2xx.c +@@ -1441,6 +1441,10 @@ static const struct pci_device_id pxa2xx_spi_pci_compound_match[] = { + { PCI_VDEVICE(INTEL, 0x4b2a), LPSS_BXT_SSP }, + { PCI_VDEVICE(INTEL, 0x4b2b), LPSS_BXT_SSP }, + { PCI_VDEVICE(INTEL, 0x4b37), LPSS_BXT_SSP }, ++ /* JSL */ ++ { PCI_VDEVICE(INTEL, 0x4daa), LPSS_CNL_SSP }, ++ { PCI_VDEVICE(INTEL, 0x4dab), LPSS_CNL_SSP }, ++ { PCI_VDEVICE(INTEL, 0x4dfb), LPSS_CNL_SSP }, + /* APL */ + { PCI_VDEVICE(INTEL, 0x5ac2), LPSS_BXT_SSP }, + { PCI_VDEVICE(INTEL, 0x5ac4), LPSS_BXT_SSP }, +diff --git a/drivers/spi/spi-ti-qspi.c b/drivers/spi/spi-ti-qspi.c +index 3cb65371ae3b..66dcb6128539 100644 +--- a/drivers/spi/spi-ti-qspi.c ++++ b/drivers/spi/spi-ti-qspi.c +@@ -62,6 +62,7 @@ struct ti_qspi { + u32 dc; + + bool mmap_enabled; ++ int current_cs; + }; + + #define QSPI_PID (0x0) +@@ -487,6 +488,7 @@ static void ti_qspi_enable_memory_map(struct spi_device *spi) + MEM_CS_EN(spi->chip_select)); + } + qspi->mmap_enabled = true; ++ qspi->current_cs = spi->chip_select; + } + + static void ti_qspi_disable_memory_map(struct spi_device *spi) +@@ -498,6 +500,7 @@ static void ti_qspi_disable_memory_map(struct spi_device *spi) + regmap_update_bits(qspi->ctrl_base, qspi->ctrl_reg, + MEM_CS_MASK, 0); + qspi->mmap_enabled = false; ++ qspi->current_cs = -1; + } + + static void ti_qspi_setup_mmap_read(struct spi_device *spi, u8 opcode, +@@ -543,7 +546,7 @@ static int ti_qspi_exec_mem_op(struct spi_mem *mem, + + mutex_lock(&qspi->list_lock); + +- if (!qspi->mmap_enabled) ++ if (!qspi->mmap_enabled || qspi->current_cs != mem->spi->chip_select) + ti_qspi_enable_memory_map(mem->spi); + ti_qspi_setup_mmap_read(mem->spi, op->cmd.opcode, op->data.buswidth, + op->addr.nbytes, op->dummy.nbytes); +@@ -799,6 +802,7 @@ no_dma: + } + } + qspi->mmap_enabled = false; ++ qspi->current_cs = -1; + + ret = devm_spi_register_master(&pdev->dev, master); + if (!ret) +diff --git a/drivers/staging/axis-fifo/Kconfig b/drivers/staging/axis-fifo/Kconfig +index 3fffe4d6f327..f180a8e9f58a 100644 +--- a/drivers/staging/axis-fifo/Kconfig ++++ b/drivers/staging/axis-fifo/Kconfig +@@ -4,7 +4,7 @@ + # + config XIL_AXIS_FIFO + tristate "Xilinx AXI-Stream FIFO IP core driver" +- depends on OF ++ depends on OF && HAS_IOMEM + help + This adds support for the Xilinx AXI-Stream FIFO IP core driver. + The AXI Streaming FIFO allows memory mapped access to a AXI Streaming +diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c +index 1ac1095bfeac..5e92c6abe306 100644 +--- a/drivers/usb/core/config.c ++++ b/drivers/usb/core/config.c +@@ -203,9 +203,58 @@ static const unsigned short super_speed_maxpacket_maxes[4] = { + [USB_ENDPOINT_XFER_INT] = 1024, + }; + +-static int usb_parse_endpoint(struct device *ddev, int cfgno, int inum, +- int asnum, struct usb_host_interface *ifp, int num_ep, +- unsigned char *buffer, int size) ++static bool endpoint_is_duplicate(struct usb_endpoint_descriptor *e1, ++ struct usb_endpoint_descriptor *e2) ++{ ++ if (e1->bEndpointAddress == e2->bEndpointAddress) ++ return true; ++ ++ if (usb_endpoint_xfer_control(e1) || usb_endpoint_xfer_control(e2)) { ++ if (usb_endpoint_num(e1) == usb_endpoint_num(e2)) ++ return true; ++ } ++ ++ return false; ++} ++ ++/* ++ * Check for duplicate endpoint addresses in other interfaces and in the ++ * altsetting currently being parsed. ++ */ ++static bool config_endpoint_is_duplicate(struct usb_host_config *config, ++ int inum, int asnum, struct usb_endpoint_descriptor *d) ++{ ++ struct usb_endpoint_descriptor *epd; ++ struct usb_interface_cache *intfc; ++ struct usb_host_interface *alt; ++ int i, j, k; ++ ++ for (i = 0; i < config->desc.bNumInterfaces; ++i) { ++ intfc = config->intf_cache[i]; ++ ++ for (j = 0; j < intfc->num_altsetting; ++j) { ++ alt = &intfc->altsetting[j]; ++ ++ if (alt->desc.bInterfaceNumber == inum && ++ alt->desc.bAlternateSetting != asnum) ++ continue; ++ ++ for (k = 0; k < alt->desc.bNumEndpoints; ++k) { ++ epd = &alt->endpoint[k].desc; ++ ++ if (endpoint_is_duplicate(epd, d)) ++ return true; ++ } ++ } ++ } ++ ++ return false; ++} ++ ++static int usb_parse_endpoint(struct device *ddev, int cfgno, ++ struct usb_host_config *config, int inum, int asnum, ++ struct usb_host_interface *ifp, int num_ep, ++ unsigned char *buffer, int size) + { + unsigned char *buffer0 = buffer; + struct usb_endpoint_descriptor *d; +@@ -242,13 +291,10 @@ static int usb_parse_endpoint(struct device *ddev, int cfgno, int inum, + goto skip_to_next_endpoint_or_interface_descriptor; + + /* Check for duplicate endpoint addresses */ +- for (i = 0; i < ifp->desc.bNumEndpoints; ++i) { +- if (ifp->endpoint[i].desc.bEndpointAddress == +- d->bEndpointAddress) { +- dev_warn(ddev, "config %d interface %d altsetting %d has a duplicate endpoint with address 0x%X, skipping\n", +- cfgno, inum, asnum, d->bEndpointAddress); +- goto skip_to_next_endpoint_or_interface_descriptor; +- } ++ if (config_endpoint_is_duplicate(config, inum, asnum, d)) { ++ dev_warn(ddev, "config %d interface %d altsetting %d has a duplicate endpoint with address 0x%X, skipping\n", ++ cfgno, inum, asnum, d->bEndpointAddress); ++ goto skip_to_next_endpoint_or_interface_descriptor; + } + + endpoint = &ifp->endpoint[ifp->desc.bNumEndpoints]; +@@ -522,8 +568,8 @@ static int usb_parse_interface(struct device *ddev, int cfgno, + if (((struct usb_descriptor_header *) buffer)->bDescriptorType + == USB_DT_INTERFACE) + break; +- retval = usb_parse_endpoint(ddev, cfgno, inum, asnum, alt, +- num_ep, buffer, size); ++ retval = usb_parse_endpoint(ddev, cfgno, config, inum, asnum, ++ alt, num_ep, buffer, size); + if (retval < 0) + return retval; + ++n; +diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c +index dfe9ac8d2375..8b23162e4239 100644 +--- a/drivers/usb/core/hub.c ++++ b/drivers/usb/core/hub.c +@@ -2691,7 +2691,7 @@ static unsigned hub_is_wusb(struct usb_hub *hub) + #define SET_ADDRESS_TRIES 2 + #define GET_DESCRIPTOR_TRIES 2 + #define SET_CONFIG_TRIES (2 * (use_both_schemes + 1)) +-#define USE_NEW_SCHEME(i, scheme) ((i) / 2 == (int)scheme) ++#define USE_NEW_SCHEME(i, scheme) ((i) / 2 == (int)(scheme)) + + #define HUB_ROOT_RESET_TIME 60 /* times are in msec */ + #define HUB_SHORT_RESET_TIME 10 +diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c +index 0c960a97ea02..154f3f3e8cff 100644 +--- a/drivers/usb/dwc3/gadget.c ++++ b/drivers/usb/dwc3/gadget.c +@@ -2467,6 +2467,13 @@ static int dwc3_gadget_ep_reclaim_trb_linear(struct dwc3_ep *dep, + + static bool dwc3_gadget_ep_request_completed(struct dwc3_request *req) + { ++ /* ++ * For OUT direction, host may send less than the setup ++ * length. Return true for all OUT requests. ++ */ ++ if (!req->direction) ++ return true; ++ + return req->request.actual == req->request.length; + } + +diff --git a/drivers/usb/gadget/udc/dummy_hcd.c b/drivers/usb/gadget/udc/dummy_hcd.c +index a8f1e5707c14..4c9d1e49d5ed 100644 +--- a/drivers/usb/gadget/udc/dummy_hcd.c ++++ b/drivers/usb/gadget/udc/dummy_hcd.c +@@ -1321,7 +1321,7 @@ static int dummy_perform_transfer(struct urb *urb, struct dummy_request *req, + u32 this_sg; + bool next_sg; + +- to_host = usb_pipein(urb->pipe); ++ to_host = usb_urb_dir_in(urb); + rbuf = req->req.buf + req->req.actual; + + if (!urb->num_sgs) { +@@ -1409,7 +1409,7 @@ top: + + /* FIXME update emulated data toggle too */ + +- to_host = usb_pipein(urb->pipe); ++ to_host = usb_urb_dir_in(urb); + if (unlikely(len == 0)) + is_short = 1; + else { +@@ -1830,7 +1830,7 @@ restart: + + /* find the gadget's ep for this request (if configured) */ + address = usb_pipeendpoint (urb->pipe); +- if (usb_pipein(urb->pipe)) ++ if (usb_urb_dir_in(urb)) + address |= USB_DIR_IN; + ep = find_endpoint(dum, address); + if (!ep) { +@@ -2385,7 +2385,7 @@ static inline ssize_t show_urb(char *buf, size_t size, struct urb *urb) + s = "?"; + break; + } s; }), +- ep, ep ? (usb_pipein(urb->pipe) ? "in" : "out") : "", ++ ep, ep ? (usb_urb_dir_in(urb) ? "in" : "out") : "", + ({ char *s; \ + switch (usb_pipetype(urb->pipe)) { \ + case PIPE_CONTROL: \ +diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c +index e9491d400a24..fea09a3f491f 100644 +--- a/drivers/usb/serial/option.c ++++ b/drivers/usb/serial/option.c +@@ -1172,6 +1172,8 @@ static const struct usb_device_id option_ids[] = { + .driver_info = NCTRL(0) | RSVD(3) }, + { USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1102, 0xff), /* Telit ME910 (ECM) */ + .driver_info = NCTRL(0) }, ++ { USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x110a, 0xff), /* Telit ME910G1 */ ++ .driver_info = NCTRL(0) | RSVD(3) }, + { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_LE910), + .driver_info = NCTRL(0) | RSVD(1) | RSVD(2) }, + { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_LE910_USBCFG4), +diff --git a/drivers/usb/typec/tcpm/Kconfig b/drivers/usb/typec/tcpm/Kconfig +index 72481bbb2af3..5b986d6c801d 100644 +--- a/drivers/usb/typec/tcpm/Kconfig ++++ b/drivers/usb/typec/tcpm/Kconfig +@@ -32,6 +32,7 @@ endif # TYPEC_TCPCI + config TYPEC_FUSB302 + tristate "Fairchild FUSB302 Type-C chip driver" + depends on I2C ++ depends on EXTCON || !EXTCON + help + The Fairchild FUSB302 Type-C chip driver that works with + Type-C Port Controller Manager to provide USB PD and USB +diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c +index eb95ed78a18e..dc50605ecbda 100644 +--- a/fs/btrfs/extent-tree.c ++++ b/fs/btrfs/extent-tree.c +@@ -3781,6 +3781,7 @@ static noinline int find_free_extent(struct btrfs_fs_info *fs_info, + u64 flags, int delalloc) + { + int ret = 0; ++ int cache_block_group_error = 0; + struct btrfs_free_cluster *last_ptr = NULL; + struct btrfs_block_group_cache *block_group = NULL; + struct find_free_extent_ctl ffe_ctl = {0}; +@@ -3940,7 +3941,20 @@ have_block_group: + if (unlikely(!ffe_ctl.cached)) { + ffe_ctl.have_caching_bg = true; + ret = btrfs_cache_block_group(block_group, 0); +- BUG_ON(ret < 0); ++ ++ /* ++ * If we get ENOMEM here or something else we want to ++ * try other block groups, because it may not be fatal. ++ * However if we can't find anything else we need to ++ * save our return here so that we return the actual ++ * error that caused problems, not ENOSPC. ++ */ ++ if (ret < 0) { ++ if (!cache_block_group_error) ++ cache_block_group_error = ret; ++ ret = 0; ++ goto loop; ++ } + ret = 0; + } + +@@ -4027,7 +4041,7 @@ loop: + if (ret > 0) + goto search; + +- if (ret == -ENOSPC) { ++ if (ret == -ENOSPC && !cache_block_group_error) { + /* + * Use ffe_ctl->total_free_space as fallback if we can't find + * any contiguous hole. +@@ -4038,6 +4052,8 @@ loop: + space_info->max_extent_size = ffe_ctl.max_extent_size; + spin_unlock(&space_info->lock); + ins->offset = ffe_ctl.max_extent_size; ++ } else if (ret == -ENOSPC) { ++ ret = cache_block_group_error; + } + return ret; + } +diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c +index c332968f9056..eaafd00f93d4 100644 +--- a/fs/btrfs/file.c ++++ b/fs/btrfs/file.c +@@ -2601,8 +2601,8 @@ int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path, + } + } + +- if (clone_info) { +- u64 clone_len = drop_end - cur_offset; ++ if (clone_info && drop_end > clone_info->file_offset) { ++ u64 clone_len = drop_end - clone_info->file_offset; + + ret = btrfs_insert_clone_extent(trans, inode, path, + clone_info, clone_len); +diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c +index a56dcc0c9c2a..5720e450a46f 100644 +--- a/fs/btrfs/ioctl.c ++++ b/fs/btrfs/ioctl.c +@@ -3727,24 +3727,18 @@ process_slot: + ret = 0; + + if (last_dest_end < destoff + len) { +- struct btrfs_clone_extent_info clone_info = { 0 }; + /* +- * We have an implicit hole (NO_HOLES feature is enabled) that +- * fully or partially overlaps our cloning range at its end. ++ * We have an implicit hole that fully or partially overlaps our ++ * cloning range at its end. This means that we either have the ++ * NO_HOLES feature enabled or the implicit hole happened due to ++ * mixing buffered and direct IO writes against this file. + */ + btrfs_release_path(path); + path->leave_spinning = 0; + +- /* +- * We are dealing with a hole and our clone_info already has a +- * disk_offset of 0, we only need to fill the data length and +- * file offset. +- */ +- clone_info.data_len = destoff + len - last_dest_end; +- clone_info.file_offset = last_dest_end; + ret = btrfs_punch_hole_range(inode, path, + last_dest_end, destoff + len - 1, +- &clone_info, &trans); ++ NULL, &trans); + if (ret) + goto out; + +diff --git a/fs/btrfs/qgroup.c b/fs/btrfs/qgroup.c +index 27a903aaf43b..aeb5f2f3cdd7 100644 +--- a/fs/btrfs/qgroup.c ++++ b/fs/btrfs/qgroup.c +@@ -3232,12 +3232,12 @@ qgroup_rescan_init(struct btrfs_fs_info *fs_info, u64 progress_objectid, + if (!(fs_info->qgroup_flags & + BTRFS_QGROUP_STATUS_FLAG_RESCAN)) { + btrfs_warn(fs_info, +- "qgroup rescan init failed, qgroup is not enabled"); ++ "qgroup rescan init failed, qgroup rescan is not queued"); + ret = -EINVAL; + } else if (!(fs_info->qgroup_flags & + BTRFS_QGROUP_STATUS_FLAG_ON)) { + btrfs_warn(fs_info, +- "qgroup rescan init failed, qgroup rescan is not queued"); ++ "qgroup rescan init failed, qgroup is not enabled"); + ret = -EINVAL; + } + +diff --git a/fs/drop_caches.c b/fs/drop_caches.c +index d31b6c72b476..dc1a1d5d825b 100644 +--- a/fs/drop_caches.c ++++ b/fs/drop_caches.c +@@ -35,11 +35,11 @@ static void drop_pagecache_sb(struct super_block *sb, void *unused) + spin_unlock(&inode->i_lock); + spin_unlock(&sb->s_inode_list_lock); + +- cond_resched(); + invalidate_mapping_pages(inode->i_mapping, 0, -1); + iput(toput_inode); + toput_inode = inode; + ++ cond_resched(); + spin_lock(&sb->s_inode_list_lock); + } + spin_unlock(&sb->s_inode_list_lock); +diff --git a/fs/inode.c b/fs/inode.c +index fef457a42882..96d62d97694e 100644 +--- a/fs/inode.c ++++ b/fs/inode.c +@@ -676,6 +676,7 @@ int invalidate_inodes(struct super_block *sb, bool kill_dirty) + struct inode *inode, *next; + LIST_HEAD(dispose); + ++again: + spin_lock(&sb->s_inode_list_lock); + list_for_each_entry_safe(inode, next, &sb->s_inodes, i_sb_list) { + spin_lock(&inode->i_lock); +@@ -698,6 +699,12 @@ int invalidate_inodes(struct super_block *sb, bool kill_dirty) + inode_lru_list_del(inode); + spin_unlock(&inode->i_lock); + list_add(&inode->i_lru, &dispose); ++ if (need_resched()) { ++ spin_unlock(&sb->s_inode_list_lock); ++ cond_resched(); ++ dispose_list(&dispose); ++ goto again; ++ } + } + spin_unlock(&sb->s_inode_list_lock); + +diff --git a/fs/io_uring.c b/fs/io_uring.c +index a60c6315a348..709671faaed6 100644 +--- a/fs/io_uring.c ++++ b/fs/io_uring.c +@@ -3721,6 +3721,9 @@ SYSCALL_DEFINE6(io_uring_enter, unsigned int, fd, u32, to_submit, + mutex_lock(&ctx->uring_lock); + submitted = io_ring_submit(ctx, to_submit); + mutex_unlock(&ctx->uring_lock); ++ ++ if (submitted != to_submit) ++ goto out; + } + if (flags & IORING_ENTER_GETEVENTS) { + unsigned nr_events = 0; +@@ -3734,6 +3737,7 @@ SYSCALL_DEFINE6(io_uring_enter, unsigned int, fd, u32, to_submit, + } + } + ++out: + percpu_ref_put(&ctx->refs); + out_fput: + fdput(f); +diff --git a/fs/notify/fsnotify.c b/fs/notify/fsnotify.c +index 2ecef6155fc0..f44e39c68328 100644 +--- a/fs/notify/fsnotify.c ++++ b/fs/notify/fsnotify.c +@@ -57,6 +57,9 @@ static void fsnotify_unmount_inodes(struct super_block *sb) + * doing an __iget/iput with SB_ACTIVE clear would actually + * evict all inodes with zero i_count from icache which is + * unnecessarily violent and may in fact be illegal to do. ++ * However, we should have been called /after/ evict_inodes ++ * removed all zero refcount inodes, in any case. Test to ++ * be sure. + */ + if (!atomic_read(&inode->i_count)) { + spin_unlock(&inode->i_lock); +@@ -77,6 +80,7 @@ static void fsnotify_unmount_inodes(struct super_block *sb) + + iput_inode = inode; + ++ cond_resched(); + spin_lock(&sb->s_inode_list_lock); + } + spin_unlock(&sb->s_inode_list_lock); +diff --git a/fs/quota/dquot.c b/fs/quota/dquot.c +index 9b96243de081..7abc3230c21a 100644 +--- a/fs/quota/dquot.c ++++ b/fs/quota/dquot.c +@@ -986,6 +986,7 @@ static int add_dquot_ref(struct super_block *sb, int type) + * later. + */ + old_inode = inode; ++ cond_resched(); + spin_lock(&sb->s_inode_list_lock); + } + spin_unlock(&sb->s_inode_list_lock); +diff --git a/fs/super.c b/fs/super.c +index cfadab2cbf35..cd352530eca9 100644 +--- a/fs/super.c ++++ b/fs/super.c +@@ -448,10 +448,12 @@ void generic_shutdown_super(struct super_block *sb) + sync_filesystem(sb); + sb->s_flags &= ~SB_ACTIVE; + +- fsnotify_sb_delete(sb); + cgroup_writeback_umount(); + ++ /* evict all inodes with zero refcount */ + evict_inodes(sb); ++ /* only nonzero refcount inodes can have marks */ ++ fsnotify_sb_delete(sb); + + if (sb->s_dio_done_wq) { + destroy_workqueue(sb->s_dio_done_wq); +diff --git a/include/linux/if_ether.h b/include/linux/if_ether.h +index 76cf11e905e1..8a9792a6427a 100644 +--- a/include/linux/if_ether.h ++++ b/include/linux/if_ether.h +@@ -24,6 +24,14 @@ static inline struct ethhdr *eth_hdr(const struct sk_buff *skb) + return (struct ethhdr *)skb_mac_header(skb); + } + ++/* Prefer this version in TX path, instead of ++ * skb_reset_mac_header() + eth_hdr() ++ */ ++static inline struct ethhdr *skb_eth_hdr(const struct sk_buff *skb) ++{ ++ return (struct ethhdr *)skb->data; ++} ++ + static inline struct ethhdr *inner_eth_hdr(const struct sk_buff *skb) + { + return (struct ethhdr *)skb_inner_mac_header(skb); +diff --git a/include/uapi/linux/netfilter/xt_sctp.h b/include/uapi/linux/netfilter/xt_sctp.h +index 4bc6d1a08781..b4d804a9fccb 100644 +--- a/include/uapi/linux/netfilter/xt_sctp.h ++++ b/include/uapi/linux/netfilter/xt_sctp.h +@@ -41,19 +41,19 @@ struct xt_sctp_info { + #define SCTP_CHUNKMAP_SET(chunkmap, type) \ + do { \ + (chunkmap)[type / bytes(__u32)] |= \ +- 1 << (type % bytes(__u32)); \ ++ 1u << (type % bytes(__u32)); \ + } while (0) + + #define SCTP_CHUNKMAP_CLEAR(chunkmap, type) \ + do { \ + (chunkmap)[type / bytes(__u32)] &= \ +- ~(1 << (type % bytes(__u32))); \ ++ ~(1u << (type % bytes(__u32))); \ + } while (0) + + #define SCTP_CHUNKMAP_IS_SET(chunkmap, type) \ + ({ \ + ((chunkmap)[type / bytes (__u32)] & \ +- (1 << (type % bytes (__u32)))) ? 1: 0; \ ++ (1u << (type % bytes (__u32)))) ? 1: 0; \ + }) + + #define SCTP_CHUNKMAP_RESET(chunkmap) \ +diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c +index 5c51021775af..9c74c98f6501 100644 +--- a/kernel/bpf/verifier.c ++++ b/kernel/bpf/verifier.c +@@ -6039,6 +6039,7 @@ static bool may_access_skb(enum bpf_prog_type type) + static int check_ld_abs(struct bpf_verifier_env *env, struct bpf_insn *insn) + { + struct bpf_reg_state *regs = cur_regs(env); ++ static const int ctx_reg = BPF_REG_6; + u8 mode = BPF_MODE(insn->code); + int i, err; + +@@ -6072,7 +6073,7 @@ static int check_ld_abs(struct bpf_verifier_env *env, struct bpf_insn *insn) + } + + /* check whether implicit source operand (register R6) is readable */ +- err = check_reg_arg(env, BPF_REG_6, SRC_OP); ++ err = check_reg_arg(env, ctx_reg, SRC_OP); + if (err) + return err; + +@@ -6091,7 +6092,7 @@ static int check_ld_abs(struct bpf_verifier_env *env, struct bpf_insn *insn) + return -EINVAL; + } + +- if (regs[BPF_REG_6].type != PTR_TO_CTX) { ++ if (regs[ctx_reg].type != PTR_TO_CTX) { + verbose(env, + "at the time of BPF_LD_ABS|IND R6 != pointer to skb\n"); + return -EINVAL; +@@ -6104,6 +6105,10 @@ static int check_ld_abs(struct bpf_verifier_env *env, struct bpf_insn *insn) + return err; + } + ++ err = check_ctx_reg(env, ®s[ctx_reg], ctx_reg); ++ if (err < 0) ++ return err; ++ + /* reset caller saved regs to unreadable */ + for (i = 0; i < CALLER_SAVED_REGS; i++) { + mark_reg_not_init(env, regs, caller_saved[i]); +diff --git a/kernel/locking/spinlock_debug.c b/kernel/locking/spinlock_debug.c +index 399669f7eba8..472dd462a40c 100644 +--- a/kernel/locking/spinlock_debug.c ++++ b/kernel/locking/spinlock_debug.c +@@ -51,19 +51,19 @@ EXPORT_SYMBOL(__rwlock_init); + + static void spin_dump(raw_spinlock_t *lock, const char *msg) + { +- struct task_struct *owner = NULL; ++ struct task_struct *owner = READ_ONCE(lock->owner); + +- if (lock->owner && lock->owner != SPINLOCK_OWNER_INIT) +- owner = lock->owner; ++ if (owner == SPINLOCK_OWNER_INIT) ++ owner = NULL; + printk(KERN_EMERG "BUG: spinlock %s on CPU#%d, %s/%d\n", + msg, raw_smp_processor_id(), + current->comm, task_pid_nr(current)); + printk(KERN_EMERG " lock: %pS, .magic: %08x, .owner: %s/%d, " + ".owner_cpu: %d\n", +- lock, lock->magic, ++ lock, READ_ONCE(lock->magic), + owner ? owner->comm : "", + owner ? task_pid_nr(owner) : -1, +- lock->owner_cpu); ++ READ_ONCE(lock->owner_cpu)); + dump_stack(); + } + +@@ -80,16 +80,16 @@ static void spin_bug(raw_spinlock_t *lock, const char *msg) + static inline void + debug_spin_lock_before(raw_spinlock_t *lock) + { +- SPIN_BUG_ON(lock->magic != SPINLOCK_MAGIC, lock, "bad magic"); +- SPIN_BUG_ON(lock->owner == current, lock, "recursion"); +- SPIN_BUG_ON(lock->owner_cpu == raw_smp_processor_id(), ++ SPIN_BUG_ON(READ_ONCE(lock->magic) != SPINLOCK_MAGIC, lock, "bad magic"); ++ SPIN_BUG_ON(READ_ONCE(lock->owner) == current, lock, "recursion"); ++ SPIN_BUG_ON(READ_ONCE(lock->owner_cpu) == raw_smp_processor_id(), + lock, "cpu recursion"); + } + + static inline void debug_spin_lock_after(raw_spinlock_t *lock) + { +- lock->owner_cpu = raw_smp_processor_id(); +- lock->owner = current; ++ WRITE_ONCE(lock->owner_cpu, raw_smp_processor_id()); ++ WRITE_ONCE(lock->owner, current); + } + + static inline void debug_spin_unlock(raw_spinlock_t *lock) +@@ -99,8 +99,8 @@ static inline void debug_spin_unlock(raw_spinlock_t *lock) + SPIN_BUG_ON(lock->owner != current, lock, "wrong owner"); + SPIN_BUG_ON(lock->owner_cpu != raw_smp_processor_id(), + lock, "wrong CPU"); +- lock->owner = SPINLOCK_OWNER_INIT; +- lock->owner_cpu = -1; ++ WRITE_ONCE(lock->owner, SPINLOCK_OWNER_INIT); ++ WRITE_ONCE(lock->owner_cpu, -1); + } + + /* +@@ -187,8 +187,8 @@ static inline void debug_write_lock_before(rwlock_t *lock) + + static inline void debug_write_lock_after(rwlock_t *lock) + { +- lock->owner_cpu = raw_smp_processor_id(); +- lock->owner = current; ++ WRITE_ONCE(lock->owner_cpu, raw_smp_processor_id()); ++ WRITE_ONCE(lock->owner, current); + } + + static inline void debug_write_unlock(rwlock_t *lock) +@@ -197,8 +197,8 @@ static inline void debug_write_unlock(rwlock_t *lock) + RWLOCK_BUG_ON(lock->owner != current, lock, "wrong owner"); + RWLOCK_BUG_ON(lock->owner_cpu != raw_smp_processor_id(), + lock, "wrong CPU"); +- lock->owner = SPINLOCK_OWNER_INIT; +- lock->owner_cpu = -1; ++ WRITE_ONCE(lock->owner, SPINLOCK_OWNER_INIT); ++ WRITE_ONCE(lock->owner_cpu, -1); + } + + void do_raw_write_lock(rwlock_t *lock) +diff --git a/kernel/sched/psi.c b/kernel/sched/psi.c +index 517e3719027e..ce8f6748678a 100644 +--- a/kernel/sched/psi.c ++++ b/kernel/sched/psi.c +@@ -185,7 +185,8 @@ static void group_init(struct psi_group *group) + + for_each_possible_cpu(cpu) + seqcount_init(&per_cpu_ptr(group->pcpu, cpu)->seq); +- group->avg_next_update = sched_clock() + psi_period; ++ group->avg_last_update = sched_clock(); ++ group->avg_next_update = group->avg_last_update + psi_period; + INIT_DELAYED_WORK(&group->avgs_work, psi_avgs_work); + mutex_init(&group->avgs_lock); + /* Init trigger-related members */ +@@ -481,7 +482,7 @@ static u64 window_update(struct psi_window *win, u64 now, u64 value) + u32 remaining; + + remaining = win->size - elapsed; +- growth += div_u64(win->prev_growth * remaining, win->size); ++ growth += div64_u64(win->prev_growth * remaining, win->size); + } + + return growth; +diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c +index 66358d66c933..4bf050fcfe3b 100644 +--- a/kernel/trace/ring_buffer.c ++++ b/kernel/trace/ring_buffer.c +@@ -11,6 +11,7 @@ + #include + #include + #include ++#include + #include + #include + #include /* for self test */ +@@ -5068,6 +5069,11 @@ static __init int test_ringbuffer(void) + int cpu; + int ret = 0; + ++ if (security_locked_down(LOCKDOWN_TRACEFS)) { ++ pr_warning("Lockdown is enabled, skipping ring buffer tests\n"); ++ return 0; ++ } ++ + pr_info("Running ring buffer tests...\n"); + + buffer = ring_buffer_alloc(RB_TEST_BUFFER_SIZE, RB_FL_OVERWRITE); +diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c +index d8bd9b1d8bce..bcb72f102613 100644 +--- a/kernel/trace/trace.c ++++ b/kernel/trace/trace.c +@@ -1804,6 +1804,12 @@ int __init register_tracer(struct tracer *type) + return -1; + } + ++ if (security_locked_down(LOCKDOWN_TRACEFS)) { ++ pr_warning("Can not register tracer %s due to lockdown\n", ++ type->name); ++ return -EPERM; ++ } ++ + mutex_lock(&trace_types_lock); + + tracing_selftest_running = true; +@@ -8647,6 +8653,11 @@ struct dentry *tracing_init_dentry(void) + { + struct trace_array *tr = &global_trace; + ++ if (security_locked_down(LOCKDOWN_TRACEFS)) { ++ pr_warning("Tracing disabled due to lockdown\n"); ++ return ERR_PTR(-EPERM); ++ } ++ + /* The top level trace array uses NULL as parent */ + if (tr->dir) + return NULL; +@@ -9089,6 +9100,12 @@ __init static int tracer_alloc_buffers(void) + int ring_buf_size; + int ret = -ENOMEM; + ++ ++ if (security_locked_down(LOCKDOWN_TRACEFS)) { ++ pr_warning("Tracing disabled due to lockdown\n"); ++ return -EPERM; ++ } ++ + /* + * Make sure we don't accidently add more trace options + * than we have bits for. +diff --git a/lib/sbitmap.c b/lib/sbitmap.c +index 969e5400a615..ee3ce1494568 100644 +--- a/lib/sbitmap.c ++++ b/lib/sbitmap.c +@@ -667,8 +667,8 @@ void sbitmap_add_wait_queue(struct sbitmap_queue *sbq, + if (!sbq_wait->sbq) { + sbq_wait->sbq = sbq; + atomic_inc(&sbq->ws_active); ++ add_wait_queue(&ws->wait, &sbq_wait->wait); + } +- add_wait_queue(&ws->wait, &sbq_wait->wait); + } + EXPORT_SYMBOL_GPL(sbitmap_add_wait_queue); + +diff --git a/net/8021q/vlan.h b/net/8021q/vlan.h +index c46daf09a501..bb7ec1a3915d 100644 +--- a/net/8021q/vlan.h ++++ b/net/8021q/vlan.h +@@ -126,6 +126,7 @@ int vlan_check_real_dev(struct net_device *real_dev, + void vlan_setup(struct net_device *dev); + int register_vlan_dev(struct net_device *dev, struct netlink_ext_ack *extack); + void unregister_vlan_dev(struct net_device *dev, struct list_head *head); ++void vlan_dev_uninit(struct net_device *dev); + bool vlan_dev_inherit_address(struct net_device *dev, + struct net_device *real_dev); + +diff --git a/net/8021q/vlan_dev.c b/net/8021q/vlan_dev.c +index e5bff5cc6f97..2a78da4072de 100644 +--- a/net/8021q/vlan_dev.c ++++ b/net/8021q/vlan_dev.c +@@ -586,7 +586,8 @@ static int vlan_dev_init(struct net_device *dev) + return 0; + } + +-static void vlan_dev_uninit(struct net_device *dev) ++/* Note: this function might be called multiple times for the same device. */ ++void vlan_dev_uninit(struct net_device *dev) + { + struct vlan_priority_tci_mapping *pm; + struct vlan_dev_priv *vlan = vlan_dev_priv(dev); +diff --git a/net/8021q/vlan_netlink.c b/net/8021q/vlan_netlink.c +index c482a6fe9393..0db85aeb119b 100644 +--- a/net/8021q/vlan_netlink.c ++++ b/net/8021q/vlan_netlink.c +@@ -108,11 +108,13 @@ static int vlan_changelink(struct net_device *dev, struct nlattr *tb[], + struct ifla_vlan_flags *flags; + struct ifla_vlan_qos_mapping *m; + struct nlattr *attr; +- int rem; ++ int rem, err; + + if (data[IFLA_VLAN_FLAGS]) { + flags = nla_data(data[IFLA_VLAN_FLAGS]); +- vlan_dev_change_flags(dev, flags->flags, flags->mask); ++ err = vlan_dev_change_flags(dev, flags->flags, flags->mask); ++ if (err) ++ return err; + } + if (data[IFLA_VLAN_INGRESS_QOS]) { + nla_for_each_nested(attr, data[IFLA_VLAN_INGRESS_QOS], rem) { +@@ -123,7 +125,9 @@ static int vlan_changelink(struct net_device *dev, struct nlattr *tb[], + if (data[IFLA_VLAN_EGRESS_QOS]) { + nla_for_each_nested(attr, data[IFLA_VLAN_EGRESS_QOS], rem) { + m = nla_data(attr); +- vlan_dev_set_egress_priority(dev, m->from, m->to); ++ err = vlan_dev_set_egress_priority(dev, m->from, m->to); ++ if (err) ++ return err; + } + } + return 0; +@@ -179,10 +183,11 @@ static int vlan_newlink(struct net *src_net, struct net_device *dev, + return -EINVAL; + + err = vlan_changelink(dev, tb, data, extack); +- if (err < 0) +- return err; +- +- return register_vlan_dev(dev, extack); ++ if (!err) ++ err = register_vlan_dev(dev, extack); ++ if (err) ++ vlan_dev_uninit(dev); ++ return err; + } + + static inline size_t vlan_qos_map_size(unsigned int n) +diff --git a/net/core/filter.c b/net/core/filter.c +index 6d0111bfdb4a..2f76461c120d 100644 +--- a/net/core/filter.c ++++ b/net/core/filter.c +@@ -2055,6 +2055,7 @@ static inline int __bpf_tx_skb(struct net_device *dev, struct sk_buff *skb) + } + + skb->dev = dev; ++ skb->tstamp = 0; + + dev_xmit_recursion_inc(); + ret = dev_queue_xmit(skb); +diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c +index a2e52ad7cdab..67e44e6717b0 100644 +--- a/net/ipv4/tcp_input.c ++++ b/net/ipv4/tcp_input.c +@@ -1727,8 +1727,11 @@ tcp_sacktag_write_queue(struct sock *sk, const struct sk_buff *ack_skb, + } + + /* Ignore very old stuff early */ +- if (!after(sp[used_sacks].end_seq, prior_snd_una)) ++ if (!after(sp[used_sacks].end_seq, prior_snd_una)) { ++ if (i == 0) ++ first_sack_index = -1; + continue; ++ } + + used_sacks++; + } +diff --git a/net/llc/llc_station.c b/net/llc/llc_station.c +index 204a8351efff..c29170e767a8 100644 +--- a/net/llc/llc_station.c ++++ b/net/llc/llc_station.c +@@ -32,7 +32,7 @@ static int llc_stat_ev_rx_null_dsap_xid_c(struct sk_buff *skb) + return LLC_PDU_IS_CMD(pdu) && /* command PDU */ + LLC_PDU_TYPE_IS_U(pdu) && /* U type PDU */ + LLC_U_PDU_CMD(pdu) == LLC_1_PDU_CMD_XID && +- !pdu->dsap ? 0 : 1; /* NULL DSAP value */ ++ !pdu->dsap; /* NULL DSAP value */ + } + + static int llc_stat_ev_rx_null_dsap_test_c(struct sk_buff *skb) +@@ -42,7 +42,7 @@ static int llc_stat_ev_rx_null_dsap_test_c(struct sk_buff *skb) + return LLC_PDU_IS_CMD(pdu) && /* command PDU */ + LLC_PDU_TYPE_IS_U(pdu) && /* U type PDU */ + LLC_U_PDU_CMD(pdu) == LLC_1_PDU_CMD_TEST && +- !pdu->dsap ? 0 : 1; /* NULL DSAP */ ++ !pdu->dsap; /* NULL DSAP */ + } + + static int llc_station_ac_send_xid_r(struct sk_buff *skb) +diff --git a/net/mac80211/tx.c b/net/mac80211/tx.c +index 1fa422782905..cbd273c0b275 100644 +--- a/net/mac80211/tx.c ++++ b/net/mac80211/tx.c +@@ -2263,6 +2263,15 @@ netdev_tx_t ieee80211_monitor_start_xmit(struct sk_buff *skb, + payload[7]); + } + ++ /* ++ * Initialize skb->priority for QoS frames. This is put in the TID field ++ * of the frame before passing it to the driver. ++ */ ++ if (ieee80211_is_data_qos(hdr->frame_control)) { ++ u8 *p = ieee80211_get_qos_ctl(hdr); ++ skb->priority = *p & IEEE80211_QOS_CTL_TAG1D_MASK; ++ } ++ + memset(info, 0, sizeof(*info)); + + info->flags = IEEE80211_TX_CTL_REQ_TX_STATUS | +diff --git a/net/netfilter/nf_conntrack_netlink.c b/net/netfilter/nf_conntrack_netlink.c +index e2d13cd18875..aa8adf930b3c 100644 +--- a/net/netfilter/nf_conntrack_netlink.c ++++ b/net/netfilter/nf_conntrack_netlink.c +@@ -3602,6 +3602,9 @@ static void __net_exit ctnetlink_net_exit_batch(struct list_head *net_exit_list) + + list_for_each_entry(net, net_exit_list, exit_list) + ctnetlink_net_exit(net); ++ ++ /* wait for other cpus until they are done with ctnl_notifiers */ ++ synchronize_rcu(); + } + + static struct pernet_operations ctnetlink_net_ops = { +diff --git a/net/netfilter/nf_tables_api.c b/net/netfilter/nf_tables_api.c +index 712a428509ad..67ca47c7ce54 100644 +--- a/net/netfilter/nf_tables_api.c ++++ b/net/netfilter/nf_tables_api.c +@@ -4252,8 +4252,10 @@ static int nft_get_set_elem(struct nft_ctx *ctx, struct nft_set *set, + return err; + + err = -EINVAL; +- if (desc.type != NFT_DATA_VALUE || desc.len != set->klen) ++ if (desc.type != NFT_DATA_VALUE || desc.len != set->klen) { ++ nft_data_release(&elem.key.val, desc.type); + return err; ++ } + + priv = set->ops->get(ctx->net, set, &elem, flags); + if (IS_ERR(priv)) +@@ -4489,14 +4491,20 @@ static int nft_add_set_elem(struct nft_ctx *ctx, struct nft_set *set, + if (nla[NFTA_SET_ELEM_DATA] == NULL && + !(flags & NFT_SET_ELEM_INTERVAL_END)) + return -EINVAL; +- if (nla[NFTA_SET_ELEM_DATA] != NULL && +- flags & NFT_SET_ELEM_INTERVAL_END) +- return -EINVAL; + } else { + if (nla[NFTA_SET_ELEM_DATA] != NULL) + return -EINVAL; + } + ++ if ((flags & NFT_SET_ELEM_INTERVAL_END) && ++ (nla[NFTA_SET_ELEM_DATA] || ++ nla[NFTA_SET_ELEM_OBJREF] || ++ nla[NFTA_SET_ELEM_TIMEOUT] || ++ nla[NFTA_SET_ELEM_EXPIRATION] || ++ nla[NFTA_SET_ELEM_USERDATA] || ++ nla[NFTA_SET_ELEM_EXPR])) ++ return -EINVAL; ++ + timeout = 0; + if (nla[NFTA_SET_ELEM_TIMEOUT] != NULL) { + if (!(set->flags & NFT_SET_TIMEOUT)) +@@ -5209,7 +5217,7 @@ static int nf_tables_newobj(struct net *net, struct sock *nlsk, + if (nlh->nlmsg_flags & NLM_F_REPLACE) + return -EOPNOTSUPP; + +- type = nft_obj_type_get(net, objtype); ++ type = __nft_obj_type_get(objtype); + nft_ctx_init(&ctx, net, skb, nlh, family, table, NULL, nla); + + return nf_tables_updobj(&ctx, type, nla[NFTA_OBJ_DATA], obj); +diff --git a/net/netfilter/nf_tables_offload.c b/net/netfilter/nf_tables_offload.c +index 5f6037695dee..e743f811245f 100644 +--- a/net/netfilter/nf_tables_offload.c ++++ b/net/netfilter/nf_tables_offload.c +@@ -44,6 +44,9 @@ struct nft_flow_rule *nft_flow_rule_create(struct net *net, + expr = nft_expr_next(expr); + } + ++ if (num_actions == 0) ++ return ERR_PTR(-EOPNOTSUPP); ++ + flow = nft_flow_rule_alloc(num_actions); + if (!flow) + return ERR_PTR(-ENOMEM); +@@ -446,6 +449,9 @@ static int nft_offload_netdev_event(struct notifier_block *this, + struct net *net = dev_net(dev); + struct nft_chain *chain; + ++ if (event != NETDEV_UNREGISTER) ++ return NOTIFY_DONE; ++ + mutex_lock(&net->nft.commit_mutex); + chain = __nft_offload_get_chain(dev); + if (chain) +diff --git a/net/netfilter/nft_bitwise.c b/net/netfilter/nft_bitwise.c +index 02afa752dd2e..10e9d50e4e19 100644 +--- a/net/netfilter/nft_bitwise.c ++++ b/net/netfilter/nft_bitwise.c +@@ -80,7 +80,7 @@ static int nft_bitwise_init(const struct nft_ctx *ctx, + tb[NFTA_BITWISE_MASK]); + if (err < 0) + return err; +- if (d1.len != priv->len) { ++ if (d1.type != NFT_DATA_VALUE || d1.len != priv->len) { + err = -EINVAL; + goto err1; + } +@@ -89,7 +89,7 @@ static int nft_bitwise_init(const struct nft_ctx *ctx, + tb[NFTA_BITWISE_XOR]); + if (err < 0) + goto err1; +- if (d2.len != priv->len) { ++ if (d2.type != NFT_DATA_VALUE || d2.len != priv->len) { + err = -EINVAL; + goto err2; + } +diff --git a/net/netfilter/nft_cmp.c b/net/netfilter/nft_cmp.c +index 0744b2bb46da..ae730dba60c8 100644 +--- a/net/netfilter/nft_cmp.c ++++ b/net/netfilter/nft_cmp.c +@@ -80,6 +80,12 @@ static int nft_cmp_init(const struct nft_ctx *ctx, const struct nft_expr *expr, + if (err < 0) + return err; + ++ if (desc.type != NFT_DATA_VALUE) { ++ err = -EINVAL; ++ nft_data_release(&priv->data, desc.type); ++ return err; ++ } ++ + priv->sreg = nft_parse_register(tb[NFTA_CMP_SREG]); + err = nft_validate_register_load(priv->sreg, desc.len); + if (err < 0) +diff --git a/net/netfilter/nft_range.c b/net/netfilter/nft_range.c +index 4701fa8a45e7..89efcc5a533d 100644 +--- a/net/netfilter/nft_range.c ++++ b/net/netfilter/nft_range.c +@@ -66,11 +66,21 @@ static int nft_range_init(const struct nft_ctx *ctx, const struct nft_expr *expr + if (err < 0) + return err; + ++ if (desc_from.type != NFT_DATA_VALUE) { ++ err = -EINVAL; ++ goto err1; ++ } ++ + err = nft_data_init(NULL, &priv->data_to, sizeof(priv->data_to), + &desc_to, tb[NFTA_RANGE_TO_DATA]); + if (err < 0) + goto err1; + ++ if (desc_to.type != NFT_DATA_VALUE) { ++ err = -EINVAL; ++ goto err2; ++ } ++ + if (desc_from.len != desc_to.len) { + err = -EINVAL; + goto err2; +diff --git a/net/netfilter/nft_set_rbtree.c b/net/netfilter/nft_set_rbtree.c +index 57123259452f..a9f804f7a04a 100644 +--- a/net/netfilter/nft_set_rbtree.c ++++ b/net/netfilter/nft_set_rbtree.c +@@ -74,8 +74,13 @@ static bool __nft_rbtree_lookup(const struct net *net, const struct nft_set *set + parent = rcu_dereference_raw(parent->rb_left); + continue; + } +- if (nft_rbtree_interval_end(rbe)) +- goto out; ++ if (nft_rbtree_interval_end(rbe)) { ++ if (nft_set_is_anonymous(set)) ++ return false; ++ parent = rcu_dereference_raw(parent->rb_left); ++ interval = NULL; ++ continue; ++ } + + *ext = &rbe->ext; + return true; +@@ -88,7 +93,7 @@ static bool __nft_rbtree_lookup(const struct net *net, const struct nft_set *set + *ext = &interval->ext; + return true; + } +-out: ++ + return false; + } + +@@ -139,8 +144,10 @@ static bool __nft_rbtree_get(const struct net *net, const struct nft_set *set, + if (flags & NFT_SET_ELEM_INTERVAL_END) + interval = rbe; + } else { +- if (!nft_set_elem_active(&rbe->ext, genmask)) ++ if (!nft_set_elem_active(&rbe->ext, genmask)) { + parent = rcu_dereference_raw(parent->rb_left); ++ continue; ++ } + + if (!nft_set_ext_exists(&rbe->ext, NFT_SET_EXT_FLAGS) || + (*nft_set_ext_flags(&rbe->ext) & NFT_SET_ELEM_INTERVAL_END) == +@@ -148,7 +155,11 @@ static bool __nft_rbtree_get(const struct net *net, const struct nft_set *set, + *elem = rbe; + return true; + } +- return false; ++ ++ if (nft_rbtree_interval_end(rbe)) ++ interval = NULL; ++ ++ parent = rcu_dereference_raw(parent->rb_left); + } + } + +diff --git a/net/rfkill/core.c b/net/rfkill/core.c +index 0bf9bf1ceb8f..6c089320ae4f 100644 +--- a/net/rfkill/core.c ++++ b/net/rfkill/core.c +@@ -1002,10 +1002,13 @@ static void rfkill_sync_work(struct work_struct *work) + int __must_check rfkill_register(struct rfkill *rfkill) + { + static unsigned long rfkill_no; +- struct device *dev = &rfkill->dev; ++ struct device *dev; + int error; + +- BUG_ON(!rfkill); ++ if (!rfkill) ++ return -EINVAL; ++ ++ dev = &rfkill->dev; + + mutex_lock(&rfkill_global_mutex); + +diff --git a/net/sched/sch_cake.c b/net/sched/sch_cake.c +index 53a80bc6b13a..dd0e8680b030 100644 +--- a/net/sched/sch_cake.c ++++ b/net/sched/sch_cake.c +@@ -1769,7 +1769,7 @@ static s32 cake_enqueue(struct sk_buff *skb, struct Qdisc *sch, + q->avg_window_begin)); + u64 b = q->avg_window_bytes * (u64)NSEC_PER_SEC; + +- do_div(b, window_interval); ++ b = div64_u64(b, window_interval); + q->avg_peak_bandwidth = + cake_ewma(q->avg_peak_bandwidth, b, + b > q->avg_peak_bandwidth ? 2 : 8); +diff --git a/net/sched/sch_fq.c b/net/sched/sch_fq.c +index 78ecdf146882..712ad248d6a7 100644 +--- a/net/sched/sch_fq.c ++++ b/net/sched/sch_fq.c +@@ -787,10 +787,12 @@ static int fq_change(struct Qdisc *sch, struct nlattr *opt, + if (tb[TCA_FQ_QUANTUM]) { + u32 quantum = nla_get_u32(tb[TCA_FQ_QUANTUM]); + +- if (quantum > 0) ++ if (quantum > 0 && quantum <= (1 << 20)) { + q->quantum = quantum; +- else ++ } else { ++ NL_SET_ERR_MSG_MOD(extack, "invalid quantum"); + err = -EINVAL; ++ } + } + + if (tb[TCA_FQ_INITIAL_QUANTUM]) +diff --git a/net/sched/sch_prio.c b/net/sched/sch_prio.c +index 18b884cfdfe8..647941702f9f 100644 +--- a/net/sched/sch_prio.c ++++ b/net/sched/sch_prio.c +@@ -292,8 +292,14 @@ static int prio_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new, + struct tc_prio_qopt_offload graft_offload; + unsigned long band = arg - 1; + +- if (new == NULL) +- new = &noop_qdisc; ++ if (!new) { ++ new = qdisc_create_dflt(sch->dev_queue, &pfifo_qdisc_ops, ++ TC_H_MAKE(sch->handle, arg), extack); ++ if (!new) ++ new = &noop_qdisc; ++ else ++ qdisc_hash_add(new, true); ++ } + + *old = qdisc_replace(sch, new, &q->queues[band]); + +diff --git a/net/sctp/sm_sideeffect.c b/net/sctp/sm_sideeffect.c +index e52b2128e43b..b06cae508158 100644 +--- a/net/sctp/sm_sideeffect.c ++++ b/net/sctp/sm_sideeffect.c +@@ -1358,8 +1358,10 @@ static int sctp_cmd_interpreter(enum sctp_event_type event_type, + /* Generate an INIT ACK chunk. */ + new_obj = sctp_make_init_ack(asoc, chunk, GFP_ATOMIC, + 0); +- if (!new_obj) +- goto nomem; ++ if (!new_obj) { ++ error = -ENOMEM; ++ break; ++ } + + sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, + SCTP_CHUNK(new_obj)); +@@ -1381,7 +1383,8 @@ static int sctp_cmd_interpreter(enum sctp_event_type event_type, + if (!new_obj) { + if (cmd->obj.chunk) + sctp_chunk_free(cmd->obj.chunk); +- goto nomem; ++ error = -ENOMEM; ++ break; + } + sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, + SCTP_CHUNK(new_obj)); +@@ -1428,8 +1431,10 @@ static int sctp_cmd_interpreter(enum sctp_event_type event_type, + + /* Generate a SHUTDOWN chunk. */ + new_obj = sctp_make_shutdown(asoc, chunk); +- if (!new_obj) +- goto nomem; ++ if (!new_obj) { ++ error = -ENOMEM; ++ break; ++ } + sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, + SCTP_CHUNK(new_obj)); + break; +@@ -1765,11 +1770,17 @@ static int sctp_cmd_interpreter(enum sctp_event_type event_type, + break; + } + +- if (error) ++ if (error) { ++ cmd = sctp_next_cmd(commands); ++ while (cmd) { ++ if (cmd->verb == SCTP_CMD_REPLY) ++ sctp_chunk_free(cmd->obj.chunk); ++ cmd = sctp_next_cmd(commands); ++ } + break; ++ } + } + +-out: + /* If this is in response to a received chunk, wait until + * we are done with the packet to open the queue so that we don't + * send multiple packets in response to a single request. +@@ -1784,7 +1795,4 @@ out: + sp->data_ready_signalled = 0; + + return error; +-nomem: +- error = -ENOMEM; +- goto out; + } +diff --git a/net/wireless/core.c b/net/wireless/core.c +index 350513744575..3e25229a059d 100644 +--- a/net/wireless/core.c ++++ b/net/wireless/core.c +@@ -1102,6 +1102,7 @@ static void __cfg80211_unregister_wdev(struct wireless_dev *wdev, bool sync) + + #ifdef CONFIG_CFG80211_WEXT + kzfree(wdev->wext.keys); ++ wdev->wext.keys = NULL; + #endif + /* only initialized if we have a netdev */ + if (wdev->netdev) +diff --git a/net/xdp/xsk.c b/net/xdp/xsk.c +index 9044073fbf22..d426fc01c529 100644 +--- a/net/xdp/xsk.c ++++ b/net/xdp/xsk.c +@@ -305,12 +305,21 @@ out: + } + EXPORT_SYMBOL(xsk_umem_consume_tx); + +-static int xsk_zc_xmit(struct xdp_sock *xs) ++static int xsk_wakeup(struct xdp_sock *xs, u8 flags) + { + struct net_device *dev = xs->dev; ++ int err; ++ ++ rcu_read_lock(); ++ err = dev->netdev_ops->ndo_xsk_wakeup(dev, xs->queue_id, flags); ++ rcu_read_unlock(); ++ ++ return err; ++} + +- return dev->netdev_ops->ndo_xsk_wakeup(dev, xs->queue_id, +- XDP_WAKEUP_TX); ++static int xsk_zc_xmit(struct xdp_sock *xs) ++{ ++ return xsk_wakeup(xs, XDP_WAKEUP_TX); + } + + static void xsk_destruct_skb(struct sk_buff *skb) +@@ -424,19 +433,16 @@ static unsigned int xsk_poll(struct file *file, struct socket *sock, + unsigned int mask = datagram_poll(file, sock, wait); + struct sock *sk = sock->sk; + struct xdp_sock *xs = xdp_sk(sk); +- struct net_device *dev; + struct xdp_umem *umem; + + if (unlikely(!xsk_is_bound(xs))) + return mask; + +- dev = xs->dev; + umem = xs->umem; + + if (umem->need_wakeup) { +- if (dev->netdev_ops->ndo_xsk_wakeup) +- dev->netdev_ops->ndo_xsk_wakeup(dev, xs->queue_id, +- umem->need_wakeup); ++ if (xs->zc) ++ xsk_wakeup(xs, umem->need_wakeup); + else + /* Poll needs to drive Tx also in copy mode */ + __xsk_sendmsg(sk); +diff --git a/samples/bpf/syscall_tp_kern.c b/samples/bpf/syscall_tp_kern.c +index 1d78819ffef1..630ce8c4d5a2 100644 +--- a/samples/bpf/syscall_tp_kern.c ++++ b/samples/bpf/syscall_tp_kern.c +@@ -47,13 +47,27 @@ static __always_inline void count(void *map) + SEC("tracepoint/syscalls/sys_enter_open") + int trace_enter_open(struct syscalls_enter_open_args *ctx) + { +- count((void *)&enter_open_map); ++ count(&enter_open_map); ++ return 0; ++} ++ ++SEC("tracepoint/syscalls/sys_enter_openat") ++int trace_enter_open_at(struct syscalls_enter_open_args *ctx) ++{ ++ count(&enter_open_map); + return 0; + } + + SEC("tracepoint/syscalls/sys_exit_open") + int trace_enter_exit(struct syscalls_exit_open_args *ctx) + { +- count((void *)&exit_open_map); ++ count(&exit_open_map); ++ return 0; ++} ++ ++SEC("tracepoint/syscalls/sys_exit_openat") ++int trace_enter_exit_at(struct syscalls_exit_open_args *ctx) ++{ ++ count(&exit_open_map); + return 0; + } +diff --git a/samples/bpf/trace_event_user.c b/samples/bpf/trace_event_user.c +index 16a16eadd509..749a50f2f9f3 100644 +--- a/samples/bpf/trace_event_user.c ++++ b/samples/bpf/trace_event_user.c +@@ -37,9 +37,9 @@ static void print_ksym(__u64 addr) + } + + printf("%s;", sym->name); +- if (!strcmp(sym->name, "sys_read")) ++ if (!strstr(sym->name, "sys_read")) + sys_read_seen = true; +- else if (!strcmp(sym->name, "sys_write")) ++ else if (!strstr(sym->name, "sys_write")) + sys_write_seen = true; + } + +diff --git a/scripts/kconfig/expr.c b/scripts/kconfig/expr.c +index 77ffff3a053c..9f1de58e9f0c 100644 +--- a/scripts/kconfig/expr.c ++++ b/scripts/kconfig/expr.c +@@ -254,6 +254,13 @@ static int expr_eq(struct expr *e1, struct expr *e2) + { + int res, old_count; + ++ /* ++ * A NULL expr is taken to be yes, but there's also a different way to ++ * represent yes. expr_is_yes() checks for either representation. ++ */ ++ if (!e1 || !e2) ++ return expr_is_yes(e1) && expr_is_yes(e2); ++ + if (e1->type != e2->type) + return 0; + switch (e1->type) { +diff --git a/scripts/package/mkdebian b/scripts/package/mkdebian +index e0750b70453f..7c230016b08d 100755 +--- a/scripts/package/mkdebian ++++ b/scripts/package/mkdebian +@@ -174,7 +174,7 @@ Source: $sourcename + Section: kernel + Priority: optional + Maintainer: $maintainer +-Build-Depends: bc, kmod, cpio, bison, flex | flex:native $extra_build_depends ++Build-Depends: bc, rsync, kmod, cpio, bison, flex | flex:native $extra_build_depends + Homepage: http://www.kernel.org/ + + Package: $packagename +diff --git a/sound/soc/codecs/max98090.c b/sound/soc/codecs/max98090.c +index f6bf4cfbea23..45da2b51543e 100644 +--- a/sound/soc/codecs/max98090.c ++++ b/sound/soc/codecs/max98090.c +@@ -2103,10 +2103,8 @@ static void max98090_pll_det_disable_work(struct work_struct *work) + M98090_IULK_MASK, 0); + } + +-static void max98090_pll_work(struct work_struct *work) ++static void max98090_pll_work(struct max98090_priv *max98090) + { +- struct max98090_priv *max98090 = +- container_of(work, struct max98090_priv, pll_work); + struct snd_soc_component *component = max98090->component; + + if (!snd_soc_component_is_active(component)) +@@ -2259,7 +2257,7 @@ static irqreturn_t max98090_interrupt(int irq, void *data) + + if (active & M98090_ULK_MASK) { + dev_dbg(component->dev, "M98090_ULK_MASK\n"); +- schedule_work(&max98090->pll_work); ++ max98090_pll_work(max98090); + } + + if (active & M98090_JDET_MASK) { +@@ -2422,7 +2420,6 @@ static int max98090_probe(struct snd_soc_component *component) + max98090_pll_det_enable_work); + INIT_WORK(&max98090->pll_det_disable_work, + max98090_pll_det_disable_work); +- INIT_WORK(&max98090->pll_work, max98090_pll_work); + + /* Enable jack detection */ + snd_soc_component_write(component, M98090_REG_JACK_DETECT, +@@ -2475,7 +2472,6 @@ static void max98090_remove(struct snd_soc_component *component) + cancel_delayed_work_sync(&max98090->jack_work); + cancel_delayed_work_sync(&max98090->pll_det_enable_work); + cancel_work_sync(&max98090->pll_det_disable_work); +- cancel_work_sync(&max98090->pll_work); + max98090->component = NULL; + } + +diff --git a/sound/soc/codecs/max98090.h b/sound/soc/codecs/max98090.h +index 57965cd678b4..a197114b0dad 100644 +--- a/sound/soc/codecs/max98090.h ++++ b/sound/soc/codecs/max98090.h +@@ -1530,7 +1530,6 @@ struct max98090_priv { + struct delayed_work jack_work; + struct delayed_work pll_det_enable_work; + struct work_struct pll_det_disable_work; +- struct work_struct pll_work; + struct snd_soc_jack *jack; + unsigned int dai_fmt; + int tdm_slots; +diff --git a/sound/soc/codecs/rt5682.c b/sound/soc/codecs/rt5682.c +index c50b75ce82e0..05e883a65d7a 100644 +--- a/sound/soc/codecs/rt5682.c ++++ b/sound/soc/codecs/rt5682.c +@@ -72,6 +72,7 @@ struct rt5682_priv { + static const struct reg_sequence patch_list[] = { + {RT5682_HP_IMP_SENS_CTRL_19, 0x1000}, + {RT5682_DAC_ADC_DIG_VOL1, 0xa020}, ++ {RT5682_I2C_CTRL, 0x000f}, + }; + + static const struct reg_default rt5682_reg[] = { +@@ -2481,6 +2482,7 @@ static void rt5682_calibrate(struct rt5682_priv *rt5682) + mutex_lock(&rt5682->calibrate_mutex); + + rt5682_reset(rt5682->regmap); ++ regmap_write(rt5682->regmap, RT5682_I2C_CTRL, 0x000f); + regmap_write(rt5682->regmap, RT5682_PWR_ANLG_1, 0xa2af); + usleep_range(15000, 20000); + regmap_write(rt5682->regmap, RT5682_PWR_ANLG_1, 0xf2af); +diff --git a/sound/soc/codecs/wm8962.c b/sound/soc/codecs/wm8962.c +index 3e5c69fbc33a..d9d59f45833f 100644 +--- a/sound/soc/codecs/wm8962.c ++++ b/sound/soc/codecs/wm8962.c +@@ -2788,7 +2788,7 @@ static int fll_factors(struct _fll_div *fll_div, unsigned int Fref, + + if (target % Fref == 0) { + fll_div->theta = 0; +- fll_div->lambda = 0; ++ fll_div->lambda = 1; + } else { + gcd_fll = gcd(target, fratio * Fref); + +@@ -2858,7 +2858,7 @@ static int wm8962_set_fll(struct snd_soc_component *component, int fll_id, int s + return -EINVAL; + } + +- if (fll_div.theta || fll_div.lambda) ++ if (fll_div.theta) + fll1 |= WM8962_FLL_FRAC; + + /* Stop the FLL while we reconfigure */ +diff --git a/sound/soc/intel/boards/bytcr_rt5640.c b/sound/soc/intel/boards/bytcr_rt5640.c +index dd2b5ad08659..243f683bc02a 100644 +--- a/sound/soc/intel/boards/bytcr_rt5640.c ++++ b/sound/soc/intel/boards/bytcr_rt5640.c +@@ -707,13 +707,17 @@ static const struct dmi_system_id byt_rt5640_quirk_table[] = { + BYT_RT5640_MCLK_EN), + }, + { ++ /* Teclast X89 */ + .matches = { + DMI_MATCH(DMI_BOARD_VENDOR, "TECLAST"), + DMI_MATCH(DMI_BOARD_NAME, "tPAD"), + }, + .driver_data = (void *)(BYT_RT5640_IN3_MAP | +- BYT_RT5640_MCLK_EN | +- BYT_RT5640_SSP0_AIF1), ++ BYT_RT5640_JD_SRC_JD1_IN4P | ++ BYT_RT5640_OVCD_TH_2000UA | ++ BYT_RT5640_OVCD_SF_1P0 | ++ BYT_RT5640_SSP0_AIF1 | ++ BYT_RT5640_MCLK_EN), + }, + { /* Toshiba Satellite Click Mini L9W-B */ + .matches = { +diff --git a/sound/soc/soc-topology.c b/sound/soc/soc-topology.c +index 0fd032914a31..fd2d22ddc81b 100644 +--- a/sound/soc/soc-topology.c ++++ b/sound/soc/soc-topology.c +@@ -1918,11 +1918,13 @@ static int soc_tplg_fe_link_create(struct soc_tplg *tplg, + ret = soc_tplg_dai_link_load(tplg, link, NULL); + if (ret < 0) { + dev_err(tplg->comp->dev, "ASoC: FE link loading failed\n"); +- kfree(link->name); +- kfree(link->stream_name); +- kfree(link->cpus->dai_name); +- kfree(link); +- return ret; ++ goto err; ++ } ++ ++ ret = snd_soc_add_dai_link(tplg->comp->card, link); ++ if (ret < 0) { ++ dev_err(tplg->comp->dev, "ASoC: adding FE link failed\n"); ++ goto err; + } + + link->dobj.index = tplg->index; +@@ -1930,8 +1932,13 @@ static int soc_tplg_fe_link_create(struct soc_tplg *tplg, + link->dobj.type = SND_SOC_DOBJ_DAI_LINK; + list_add(&link->dobj.list, &tplg->comp->dobj_list); + +- snd_soc_add_dai_link(tplg->comp->card, link); + return 0; ++err: ++ kfree(link->name); ++ kfree(link->stream_name); ++ kfree(link->cpus->dai_name); ++ kfree(link); ++ return ret; + } + + /* create a FE DAI and DAI link from the PCM object */ +@@ -2024,6 +2031,7 @@ static int soc_tplg_pcm_elems_load(struct soc_tplg *tplg, + int size; + int i; + bool abi_match; ++ int ret; + + count = le32_to_cpu(hdr->count); + +@@ -2065,7 +2073,12 @@ static int soc_tplg_pcm_elems_load(struct soc_tplg *tplg, + } + + /* create the FE DAIs and DAI links */ +- soc_tplg_pcm_create(tplg, _pcm); ++ ret = soc_tplg_pcm_create(tplg, _pcm); ++ if (ret < 0) { ++ if (!abi_match) ++ kfree(_pcm); ++ return ret; ++ } + + /* offset by version-specific struct size and + * real priv data size +diff --git a/sound/soc/sof/intel/byt.c b/sound/soc/sof/intel/byt.c +index a1e514f71739..41008c974ac6 100644 +--- a/sound/soc/sof/intel/byt.c ++++ b/sound/soc/sof/intel/byt.c +@@ -24,7 +24,8 @@ + #define DRAM_OFFSET 0x100000 + #define DRAM_SIZE (160 * 1024) + #define SHIM_OFFSET 0x140000 +-#define SHIM_SIZE 0x100 ++#define SHIM_SIZE_BYT 0x100 ++#define SHIM_SIZE_CHT 0x118 + #define MBOX_OFFSET 0x144000 + #define MBOX_SIZE 0x1000 + #define EXCEPT_OFFSET 0x800 +@@ -75,7 +76,7 @@ static const struct snd_sof_debugfs_map byt_debugfs[] = { + SOF_DEBUGFS_ACCESS_D0_ONLY}, + {"dram", BYT_DSP_BAR, DRAM_OFFSET, DRAM_SIZE, + SOF_DEBUGFS_ACCESS_D0_ONLY}, +- {"shim", BYT_DSP_BAR, SHIM_OFFSET, SHIM_SIZE, ++ {"shim", BYT_DSP_BAR, SHIM_OFFSET, SHIM_SIZE_BYT, + SOF_DEBUGFS_ACCESS_ALWAYS}, + }; + +@@ -102,7 +103,7 @@ static const struct snd_sof_debugfs_map cht_debugfs[] = { + SOF_DEBUGFS_ACCESS_D0_ONLY}, + {"dram", BYT_DSP_BAR, DRAM_OFFSET, DRAM_SIZE, + SOF_DEBUGFS_ACCESS_D0_ONLY}, +- {"shim", BYT_DSP_BAR, SHIM_OFFSET, SHIM_SIZE, ++ {"shim", BYT_DSP_BAR, SHIM_OFFSET, SHIM_SIZE_CHT, + SOF_DEBUGFS_ACCESS_ALWAYS}, + }; + +diff --git a/sound/soc/sof/loader.c b/sound/soc/sof/loader.c +index 9a9a381a908d..a041adf0669d 100644 +--- a/sound/soc/sof/loader.c ++++ b/sound/soc/sof/loader.c +@@ -66,6 +66,8 @@ int snd_sof_fw_parse_ext_data(struct snd_sof_dev *sdev, u32 bar, u32 offset) + ret = get_ext_windows(sdev, ext_hdr); + break; + default: ++ dev_warn(sdev->dev, "warning: unknown ext header type %d size 0x%x\n", ++ ext_hdr->type, ext_hdr->hdr.size); + break; + } + +diff --git a/tools/bpf/bpftool/prog.c b/tools/bpf/bpftool/prog.c +index 43fdbbfe41bb..ea0bcd58bcb9 100644 +--- a/tools/bpf/bpftool/prog.c ++++ b/tools/bpf/bpftool/prog.c +@@ -493,7 +493,7 @@ static int do_dump(int argc, char **argv) + + info = &info_linear->info; + if (mode == DUMP_JITED) { +- if (info->jited_prog_len == 0) { ++ if (info->jited_prog_len == 0 || !info->jited_prog_insns) { + p_info("no instructions returned"); + goto err_free; + } +diff --git a/tools/bpf/bpftool/xlated_dumper.c b/tools/bpf/bpftool/xlated_dumper.c +index 494d7ae3614d..5b91ee65a080 100644 +--- a/tools/bpf/bpftool/xlated_dumper.c ++++ b/tools/bpf/bpftool/xlated_dumper.c +@@ -174,7 +174,7 @@ static const char *print_call(void *private_data, + struct kernel_sym *sym; + + if (insn->src_reg == BPF_PSEUDO_CALL && +- (__u32) insn->imm < dd->nr_jited_ksyms) ++ (__u32) insn->imm < dd->nr_jited_ksyms && dd->jited_ksyms) + address = dd->jited_ksyms[insn->imm]; + + sym = kernel_syms_search(dd, address); +diff --git a/tools/lib/traceevent/Makefile b/tools/lib/traceevent/Makefile +index 5315f3787f8d..ecf882308d8a 100644 +--- a/tools/lib/traceevent/Makefile ++++ b/tools/lib/traceevent/Makefile +@@ -97,6 +97,7 @@ EVENT_PARSE_VERSION = $(EP_VERSION).$(EP_PATCHLEVEL).$(EP_EXTRAVERSION) + + LIB_TARGET = libtraceevent.a libtraceevent.so.$(EVENT_PARSE_VERSION) + LIB_INSTALL = libtraceevent.a libtraceevent.so* ++LIB_INSTALL := $(addprefix $(OUTPUT),$(LIB_INSTALL)) + + INCLUDES = -I. -I $(srctree)/tools/include $(CONFIG_INCLUDES) + +@@ -207,10 +208,11 @@ define do_install + $(INSTALL) $(if $3,-m $3,) $1 '$(DESTDIR_SQ)$2' + endef + +-PKG_CONFIG_FILE = libtraceevent.pc ++PKG_CONFIG_SOURCE_FILE = libtraceevent.pc ++PKG_CONFIG_FILE := $(addprefix $(OUTPUT),$(PKG_CONFIG_SOURCE_FILE)) + define do_install_pkgconfig_file + if [ -n "${pkgconfig_dir}" ]; then \ +- cp -f ${PKG_CONFIG_FILE}.template ${PKG_CONFIG_FILE}; \ ++ cp -f ${PKG_CONFIG_SOURCE_FILE}.template ${PKG_CONFIG_FILE}; \ + sed -i "s|INSTALL_PREFIX|${1}|g" ${PKG_CONFIG_FILE}; \ + sed -i "s|LIB_VERSION|${EVENT_PARSE_VERSION}|g" ${PKG_CONFIG_FILE}; \ + sed -i "s|LIB_DIR|${libdir}|g" ${PKG_CONFIG_FILE}; \ +diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c +index becc2d109423..d3412f2c0d18 100644 +--- a/tools/perf/util/header.c ++++ b/tools/perf/util/header.c +@@ -1089,21 +1089,18 @@ static void cpu_cache_level__fprintf(FILE *out, struct cpu_cache_level *c) + fprintf(out, "L%d %-15s %8s [%s]\n", c->level, c->type, c->size, c->map); + } + +-static int build_caches(struct cpu_cache_level caches[], u32 size, u32 *cntp) ++#define MAX_CACHE_LVL 4 ++ ++static int build_caches(struct cpu_cache_level caches[], u32 *cntp) + { + u32 i, cnt = 0; +- long ncpus; + u32 nr, cpu; + u16 level; + +- ncpus = sysconf(_SC_NPROCESSORS_CONF); +- if (ncpus < 0) +- return -1; +- +- nr = (u32)(ncpus & UINT_MAX); ++ nr = cpu__max_cpu(); + + for (cpu = 0; cpu < nr; cpu++) { +- for (level = 0; level < 10; level++) { ++ for (level = 0; level < MAX_CACHE_LVL; level++) { + struct cpu_cache_level c; + int err; + +@@ -1123,18 +1120,12 @@ static int build_caches(struct cpu_cache_level caches[], u32 size, u32 *cntp) + caches[cnt++] = c; + else + cpu_cache_level__free(&c); +- +- if (WARN_ONCE(cnt == size, "way too many cpu caches..")) +- goto out; + } + } +- out: + *cntp = cnt; + return 0; + } + +-#define MAX_CACHE_LVL 4 +- + static int write_cache(struct feat_fd *ff, + struct evlist *evlist __maybe_unused) + { +@@ -1143,7 +1134,7 @@ static int write_cache(struct feat_fd *ff, + u32 cnt = 0, i, version = 1; + int ret; + +- ret = build_caches(caches, max_caches, &cnt); ++ ret = build_caches(caches, &cnt); + if (ret) + goto out; + +diff --git a/tools/perf/util/metricgroup.c b/tools/perf/util/metricgroup.c +index a7c0424dbda3..940a6e7a6854 100644 +--- a/tools/perf/util/metricgroup.c ++++ b/tools/perf/util/metricgroup.c +@@ -103,8 +103,11 @@ static struct evsel *find_evsel_group(struct evlist *perf_evlist, + if (!strcmp(ev->name, ids[i])) { + if (!metric_events[i]) + metric_events[i] = ev; ++ i++; ++ if (i == idnum) ++ break; + } else { +- if (++i == idnum) { ++ if (i + 1 == idnum) { + /* Discard the whole match and start again */ + i = 0; + memset(metric_events, 0, +@@ -124,7 +127,7 @@ static struct evsel *find_evsel_group(struct evlist *perf_evlist, + } + } + +- if (i != idnum - 1) { ++ if (i != idnum) { + /* Not whole match */ + return NULL; + } +diff --git a/tools/testing/selftests/ftrace/test.d/ftrace/func-filter-stacktrace.tc b/tools/testing/selftests/ftrace/test.d/ftrace/func-filter-stacktrace.tc +index 36fb59f886ea..1a52f2883fe0 100644 +--- a/tools/testing/selftests/ftrace/test.d/ftrace/func-filter-stacktrace.tc ++++ b/tools/testing/selftests/ftrace/test.d/ftrace/func-filter-stacktrace.tc +@@ -3,6 +3,8 @@ + # description: ftrace - stacktrace filter command + # flags: instance + ++[ ! -f set_ftrace_filter ] && exit_unsupported ++ + echo _do_fork:stacktrace >> set_ftrace_filter + + grep -q "_do_fork:stacktrace:unlimited" set_ftrace_filter +diff --git a/tools/testing/selftests/ftrace/test.d/ftrace/func_cpumask.tc b/tools/testing/selftests/ftrace/test.d/ftrace/func_cpumask.tc +index 86a1f07ef2ca..71fa3f49e35e 100644 +--- a/tools/testing/selftests/ftrace/test.d/ftrace/func_cpumask.tc ++++ b/tools/testing/selftests/ftrace/test.d/ftrace/func_cpumask.tc +@@ -15,6 +15,11 @@ if [ $NP -eq 1 ] ;then + exit_unresolved + fi + ++if ! grep -q "function" available_tracers ; then ++ echo "Function trace is not enabled" ++ exit_unsupported ++fi ++ + ORIG_CPUMASK=`cat tracing_cpumask` + + do_reset() { +diff --git a/tools/testing/selftests/ftrace/test.d/functions b/tools/testing/selftests/ftrace/test.d/functions +index 86986c4bba54..5d4550591ff9 100644 +--- a/tools/testing/selftests/ftrace/test.d/functions ++++ b/tools/testing/selftests/ftrace/test.d/functions +@@ -46,6 +46,9 @@ reset_events_filter() { # reset all current setting filters + } + + reset_ftrace_filter() { # reset all triggers in set_ftrace_filter ++ if [ ! -f set_ftrace_filter ]; then ++ return 0 ++ fi + echo > set_ftrace_filter + grep -v '^#' set_ftrace_filter | while read t; do + tr=`echo $t | cut -d: -f2` +@@ -93,7 +96,7 @@ initialize_ftrace() { # Reset ftrace to initial-state + disable_events + [ -f set_event_pid ] && echo > set_event_pid + [ -f set_ftrace_pid ] && echo > set_ftrace_pid +- [ -f set_ftrace_filter ] && echo | tee set_ftrace_* ++ [ -f set_ftrace_notrace ] && echo > set_ftrace_notrace + [ -f set_graph_function ] && echo | tee set_graph_* + [ -f stack_trace_filter ] && echo > stack_trace_filter + [ -f kprobe_events ] && echo > kprobe_events +diff --git a/tools/testing/selftests/ftrace/test.d/kprobe/multiple_kprobes.tc b/tools/testing/selftests/ftrace/test.d/kprobe/multiple_kprobes.tc +index 5862eee91e1d..6e3dbe5f96b7 100644 +--- a/tools/testing/selftests/ftrace/test.d/kprobe/multiple_kprobes.tc ++++ b/tools/testing/selftests/ftrace/test.d/kprobe/multiple_kprobes.tc +@@ -20,9 +20,9 @@ while read i; do + test $N -eq 256 && break + done + +-L=`wc -l kprobe_events` +-if [ $L -ne $N ]; then +- echo "The number of kprobes events ($L) is not $N" ++L=`cat kprobe_events | wc -l` ++if [ $L -ne 256 ]; then ++ echo "The number of kprobes events ($L) is not 256" + exit_fail + fi + +diff --git a/tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-action-hist-xfail.tc b/tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-action-hist-xfail.tc +index 1221240f8cf6..3f2aee115f6e 100644 +--- a/tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-action-hist-xfail.tc ++++ b/tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-action-hist-xfail.tc +@@ -21,10 +21,10 @@ grep -q "snapshot()" README || exit_unsupported # version issue + + echo "Test expected snapshot action failure" + +-echo 'hist:keys=comm:onmatch(sched.sched_wakeup).snapshot()' >> /sys/kernel/debug/tracing/events/sched/sched_waking/trigger && exit_fail ++echo 'hist:keys=comm:onmatch(sched.sched_wakeup).snapshot()' >> events/sched/sched_waking/trigger && exit_fail + + echo "Test expected save action failure" + +-echo 'hist:keys=comm:onmatch(sched.sched_wakeup).save(comm,prio)' >> /sys/kernel/debug/tracing/events/sched/sched_waking/trigger && exit_fail ++echo 'hist:keys=comm:onmatch(sched.sched_wakeup).save(comm,prio)' >> events/sched/sched_waking/trigger && exit_fail + + exit_xfail +diff --git a/tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-onchange-action-hist.tc b/tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-onchange-action-hist.tc +index 064a284e4e75..c80007aa9f86 100644 +--- a/tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-onchange-action-hist.tc ++++ b/tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-onchange-action-hist.tc +@@ -16,7 +16,7 @@ grep -q "onchange(var)" README || exit_unsupported # version issue + + echo "Test onchange action" + +-echo 'hist:keys=comm:newprio=prio:onchange($newprio).save(comm,prio) if comm=="ping"' >> /sys/kernel/debug/tracing/events/sched/sched_waking/trigger ++echo 'hist:keys=comm:newprio=prio:onchange($newprio).save(comm,prio) if comm=="ping"' >> events/sched/sched_waking/trigger + + ping $LOCALHOST -c 3 + nice -n 1 ping $LOCALHOST -c 3 +diff --git a/tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-snapshot-action-hist.tc b/tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-snapshot-action-hist.tc +index 18fff69fc433..f546c1b66a9b 100644 +--- a/tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-snapshot-action-hist.tc ++++ b/tools/testing/selftests/ftrace/test.d/trigger/inter-event/trigger-snapshot-action-hist.tc +@@ -23,9 +23,9 @@ grep -q "snapshot()" README || exit_unsupported # version issue + + echo "Test snapshot action" + +-echo 1 > /sys/kernel/debug/tracing/events/sched/enable ++echo 1 > events/sched/enable + +-echo 'hist:keys=comm:newprio=prio:onchange($newprio).save(comm,prio):onchange($newprio).snapshot() if comm=="ping"' >> /sys/kernel/debug/tracing/events/sched/sched_waking/trigger ++echo 'hist:keys=comm:newprio=prio:onchange($newprio).save(comm,prio):onchange($newprio).snapshot() if comm=="ping"' >> events/sched/sched_waking/trigger + + ping $LOCALHOST -c 3 + nice -n 1 ping $LOCALHOST -c 3 +diff --git a/tools/testing/selftests/kselftest/prefix.pl b/tools/testing/selftests/kselftest/prefix.pl +index ec7e48118183..31f7c2a0a8bd 100755 +--- a/tools/testing/selftests/kselftest/prefix.pl ++++ b/tools/testing/selftests/kselftest/prefix.pl +@@ -3,6 +3,7 @@ + # Prefix all lines with "# ", unbuffered. Command being piped in may need + # to have unbuffering forced with "stdbuf -i0 -o0 -e0 $cmd". + use strict; ++use IO::Handle; + + binmode STDIN; + binmode STDOUT; +diff --git a/tools/testing/selftests/kselftest/runner.sh b/tools/testing/selftests/kselftest/runner.sh +index 84de7bc74f2c..a8d20cbb711c 100644 +--- a/tools/testing/selftests/kselftest/runner.sh ++++ b/tools/testing/selftests/kselftest/runner.sh +@@ -79,6 +79,7 @@ run_one() + if [ $rc -eq $skip_rc ]; then \ + echo "not ok $test_num $TEST_HDR_MSG # SKIP" + elif [ $rc -eq $timeout_rc ]; then \ ++ echo "#" + echo "not ok $test_num $TEST_HDR_MSG # TIMEOUT" + else + echo "not ok $test_num $TEST_HDR_MSG # exit=$rc" +diff --git a/tools/testing/selftests/net/pmtu.sh b/tools/testing/selftests/net/pmtu.sh +index d697815d2785..71a62e7e35b1 100755 +--- a/tools/testing/selftests/net/pmtu.sh ++++ b/tools/testing/selftests/net/pmtu.sh +@@ -11,9 +11,9 @@ + # R1 and R2 (also implemented with namespaces), with different MTUs: + # + # segment a_r1 segment b_r1 a_r1: 2000 +-# .--------------R1--------------. a_r2: 1500 +-# A B a_r3: 2000 +-# '--------------R2--------------' a_r4: 1400 ++# .--------------R1--------------. b_r1: 1400 ++# A B a_r2: 2000 ++# '--------------R2--------------' b_r2: 1500 + # segment a_r2 segment b_r2 + # + # Check that PMTU exceptions with the correct PMTU are created. Then +diff --git a/tools/testing/selftests/netfilter/nft_nat.sh b/tools/testing/selftests/netfilter/nft_nat.sh +index 1be55e705780..d7e07f4c3d7f 100755 +--- a/tools/testing/selftests/netfilter/nft_nat.sh ++++ b/tools/testing/selftests/netfilter/nft_nat.sh +@@ -8,9 +8,14 @@ ksft_skip=4 + ret=0 + test_inet_nat=true + ++sfx=$(mktemp -u "XXXXXXXX") ++ns0="ns0-$sfx" ++ns1="ns1-$sfx" ++ns2="ns2-$sfx" ++ + cleanup() + { +- for i in 0 1 2; do ip netns del ns$i;done ++ for i in 0 1 2; do ip netns del ns$i-"$sfx";done + } + + nft --version > /dev/null 2>&1 +@@ -25,40 +30,49 @@ if [ $? -ne 0 ];then + exit $ksft_skip + fi + +-ip netns add ns0 ++ip netns add "$ns0" + if [ $? -ne 0 ];then +- echo "SKIP: Could not create net namespace" ++ echo "SKIP: Could not create net namespace $ns0" + exit $ksft_skip + fi + + trap cleanup EXIT + +-ip netns add ns1 +-ip netns add ns2 ++ip netns add "$ns1" ++if [ $? -ne 0 ];then ++ echo "SKIP: Could not create net namespace $ns1" ++ exit $ksft_skip ++fi ++ ++ip netns add "$ns2" ++if [ $? -ne 0 ];then ++ echo "SKIP: Could not create net namespace $ns2" ++ exit $ksft_skip ++fi + +-ip link add veth0 netns ns0 type veth peer name eth0 netns ns1 > /dev/null 2>&1 ++ip link add veth0 netns "$ns0" type veth peer name eth0 netns "$ns1" > /dev/null 2>&1 + if [ $? -ne 0 ];then + echo "SKIP: No virtual ethernet pair device support in kernel" + exit $ksft_skip + fi +-ip link add veth1 netns ns0 type veth peer name eth0 netns ns2 ++ip link add veth1 netns "$ns0" type veth peer name eth0 netns "$ns2" + +-ip -net ns0 link set lo up +-ip -net ns0 link set veth0 up +-ip -net ns0 addr add 10.0.1.1/24 dev veth0 +-ip -net ns0 addr add dead:1::1/64 dev veth0 ++ip -net "$ns0" link set lo up ++ip -net "$ns0" link set veth0 up ++ip -net "$ns0" addr add 10.0.1.1/24 dev veth0 ++ip -net "$ns0" addr add dead:1::1/64 dev veth0 + +-ip -net ns0 link set veth1 up +-ip -net ns0 addr add 10.0.2.1/24 dev veth1 +-ip -net ns0 addr add dead:2::1/64 dev veth1 ++ip -net "$ns0" link set veth1 up ++ip -net "$ns0" addr add 10.0.2.1/24 dev veth1 ++ip -net "$ns0" addr add dead:2::1/64 dev veth1 + + for i in 1 2; do +- ip -net ns$i link set lo up +- ip -net ns$i link set eth0 up +- ip -net ns$i addr add 10.0.$i.99/24 dev eth0 +- ip -net ns$i route add default via 10.0.$i.1 +- ip -net ns$i addr add dead:$i::99/64 dev eth0 +- ip -net ns$i route add default via dead:$i::1 ++ ip -net ns$i-$sfx link set lo up ++ ip -net ns$i-$sfx link set eth0 up ++ ip -net ns$i-$sfx addr add 10.0.$i.99/24 dev eth0 ++ ip -net ns$i-$sfx route add default via 10.0.$i.1 ++ ip -net ns$i-$sfx addr add dead:$i::99/64 dev eth0 ++ ip -net ns$i-$sfx route add default via dead:$i::1 + done + + bad_counter() +@@ -66,8 +80,9 @@ bad_counter() + local ns=$1 + local counter=$2 + local expect=$3 ++ local tag=$4 + +- echo "ERROR: $counter counter in $ns has unexpected value (expected $expect)" 1>&2 ++ echo "ERROR: $counter counter in $ns has unexpected value (expected $expect) at $tag" 1>&2 + ip netns exec $ns nft list counter inet filter $counter 1>&2 + } + +@@ -78,24 +93,24 @@ check_counters() + + cnt=$(ip netns exec $ns nft list counter inet filter ns0in | grep -q "packets 1 bytes 84") + if [ $? -ne 0 ]; then +- bad_counter $ns ns0in "packets 1 bytes 84" ++ bad_counter $ns ns0in "packets 1 bytes 84" "check_counters 1" + lret=1 + fi + cnt=$(ip netns exec $ns nft list counter inet filter ns0out | grep -q "packets 1 bytes 84") + if [ $? -ne 0 ]; then +- bad_counter $ns ns0out "packets 1 bytes 84" ++ bad_counter $ns ns0out "packets 1 bytes 84" "check_counters 2" + lret=1 + fi + + expect="packets 1 bytes 104" + cnt=$(ip netns exec $ns nft list counter inet filter ns0in6 | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter $ns ns0in6 "$expect" ++ bad_counter $ns ns0in6 "$expect" "check_counters 3" + lret=1 + fi + cnt=$(ip netns exec $ns nft list counter inet filter ns0out6 | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter $ns ns0out6 "$expect" ++ bad_counter $ns ns0out6 "$expect" "check_counters 4" + lret=1 + fi + +@@ -107,41 +122,41 @@ check_ns0_counters() + local ns=$1 + local lret=0 + +- cnt=$(ip netns exec ns0 nft list counter inet filter ns0in | grep -q "packets 0 bytes 0") ++ cnt=$(ip netns exec "$ns0" nft list counter inet filter ns0in | grep -q "packets 0 bytes 0") + if [ $? -ne 0 ]; then +- bad_counter ns0 ns0in "packets 0 bytes 0" ++ bad_counter "$ns0" ns0in "packets 0 bytes 0" "check_ns0_counters 1" + lret=1 + fi + +- cnt=$(ip netns exec ns0 nft list counter inet filter ns0in6 | grep -q "packets 0 bytes 0") ++ cnt=$(ip netns exec "$ns0" nft list counter inet filter ns0in6 | grep -q "packets 0 bytes 0") + if [ $? -ne 0 ]; then +- bad_counter ns0 ns0in6 "packets 0 bytes 0" ++ bad_counter "$ns0" ns0in6 "packets 0 bytes 0" + lret=1 + fi + +- cnt=$(ip netns exec ns0 nft list counter inet filter ns0out | grep -q "packets 0 bytes 0") ++ cnt=$(ip netns exec "$ns0" nft list counter inet filter ns0out | grep -q "packets 0 bytes 0") + if [ $? -ne 0 ]; then +- bad_counter ns0 ns0out "packets 0 bytes 0" ++ bad_counter "$ns0" ns0out "packets 0 bytes 0" "check_ns0_counters 2" + lret=1 + fi +- cnt=$(ip netns exec ns0 nft list counter inet filter ns0out6 | grep -q "packets 0 bytes 0") ++ cnt=$(ip netns exec "$ns0" nft list counter inet filter ns0out6 | grep -q "packets 0 bytes 0") + if [ $? -ne 0 ]; then +- bad_counter ns0 ns0out6 "packets 0 bytes 0" ++ bad_counter "$ns0" ns0out6 "packets 0 bytes 0" "check_ns0_counters3 " + lret=1 + fi + + for dir in "in" "out" ; do + expect="packets 1 bytes 84" +- cnt=$(ip netns exec ns0 nft list counter inet filter ${ns}${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns0" nft list counter inet filter ${ns}${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns0 $ns$dir "$expect" ++ bad_counter "$ns0" $ns$dir "$expect" "check_ns0_counters 4" + lret=1 + fi + + expect="packets 1 bytes 104" +- cnt=$(ip netns exec ns0 nft list counter inet filter ${ns}${dir}6 | grep -q "$expect") ++ cnt=$(ip netns exec "$ns0" nft list counter inet filter ${ns}${dir}6 | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns0 $ns$dir6 "$expect" ++ bad_counter "$ns0" $ns$dir6 "$expect" "check_ns0_counters 5" + lret=1 + fi + done +@@ -152,7 +167,7 @@ check_ns0_counters() + reset_counters() + { + for i in 0 1 2;do +- ip netns exec ns$i nft reset counters inet > /dev/null ++ ip netns exec ns$i-$sfx nft reset counters inet > /dev/null + done + } + +@@ -166,7 +181,7 @@ test_local_dnat6() + IPF="ip6" + fi + +-ip netns exec ns0 nft -f - < /dev/null ++ ip netns exec "$ns0" ping -q -c 1 dead:1::99 > /dev/null + if [ $? -ne 0 ]; then + lret=1 + echo "ERROR: ping6 failed" +@@ -189,18 +204,18 @@ EOF + + expect="packets 0 bytes 0" + for dir in "in6" "out6" ; do +- cnt=$(ip netns exec ns0 nft list counter inet filter ns1${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns0" nft list counter inet filter ns1${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns0 ns1$dir "$expect" ++ bad_counter "$ns0" ns1$dir "$expect" "test_local_dnat6 1" + lret=1 + fi + done + + expect="packets 1 bytes 104" + for dir in "in6" "out6" ; do +- cnt=$(ip netns exec ns0 nft list counter inet filter ns2${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns0" nft list counter inet filter ns2${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns0 ns2$dir "$expect" ++ bad_counter "$ns0" ns2$dir "$expect" "test_local_dnat6 2" + lret=1 + fi + done +@@ -208,9 +223,9 @@ EOF + # expect 0 count in ns1 + expect="packets 0 bytes 0" + for dir in "in6" "out6" ; do +- cnt=$(ip netns exec ns1 nft list counter inet filter ns0${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns1" nft list counter inet filter ns0${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns1 ns0$dir "$expect" ++ bad_counter "$ns1" ns0$dir "$expect" "test_local_dnat6 3" + lret=1 + fi + done +@@ -218,15 +233,15 @@ EOF + # expect 1 packet in ns2 + expect="packets 1 bytes 104" + for dir in "in6" "out6" ; do +- cnt=$(ip netns exec ns2 nft list counter inet filter ns0${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns2" nft list counter inet filter ns0${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns2 ns0$dir "$expect" ++ bad_counter "$ns2" ns0$dir "$expect" "test_local_dnat6 4" + lret=1 + fi + done + +- test $lret -eq 0 && echo "PASS: ipv6 ping to ns1 was $family NATted to ns2" +- ip netns exec ns0 nft flush chain ip6 nat output ++ test $lret -eq 0 && echo "PASS: ipv6 ping to $ns1 was $family NATted to $ns2" ++ ip netns exec "$ns0" nft flush chain ip6 nat output + + return $lret + } +@@ -241,7 +256,7 @@ test_local_dnat() + IPF="ip" + fi + +-ip netns exec ns0 nft -f - </dev/null ++ip netns exec "$ns0" nft -f /dev/stdin </dev/null + table $family nat { + chain output { + type nat hook output priority 0; policy accept; +@@ -260,7 +275,7 @@ EOF + fi + + # ping netns1, expect rewrite to netns2 +- ip netns exec ns0 ping -q -c 1 10.0.1.99 > /dev/null ++ ip netns exec "$ns0" ping -q -c 1 10.0.1.99 > /dev/null + if [ $? -ne 0 ]; then + lret=1 + echo "ERROR: ping failed" +@@ -269,18 +284,18 @@ EOF + + expect="packets 0 bytes 0" + for dir in "in" "out" ; do +- cnt=$(ip netns exec ns0 nft list counter inet filter ns1${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns0" nft list counter inet filter ns1${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns0 ns1$dir "$expect" ++ bad_counter "$ns0" ns1$dir "$expect" "test_local_dnat 1" + lret=1 + fi + done + + expect="packets 1 bytes 84" + for dir in "in" "out" ; do +- cnt=$(ip netns exec ns0 nft list counter inet filter ns2${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns0" nft list counter inet filter ns2${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns0 ns2$dir "$expect" ++ bad_counter "$ns0" ns2$dir "$expect" "test_local_dnat 2" + lret=1 + fi + done +@@ -288,9 +303,9 @@ EOF + # expect 0 count in ns1 + expect="packets 0 bytes 0" + for dir in "in" "out" ; do +- cnt=$(ip netns exec ns1 nft list counter inet filter ns0${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns1" nft list counter inet filter ns0${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns1 ns0$dir "$expect" ++ bad_counter "$ns1" ns0$dir "$expect" "test_local_dnat 3" + lret=1 + fi + done +@@ -298,19 +313,19 @@ EOF + # expect 1 packet in ns2 + expect="packets 1 bytes 84" + for dir in "in" "out" ; do +- cnt=$(ip netns exec ns2 nft list counter inet filter ns0${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns2" nft list counter inet filter ns0${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns2 ns0$dir "$expect" ++ bad_counter "$ns2" ns0$dir "$expect" "test_local_dnat 4" + lret=1 + fi + done + +- test $lret -eq 0 && echo "PASS: ping to ns1 was $family NATted to ns2" ++ test $lret -eq 0 && echo "PASS: ping to $ns1 was $family NATted to $ns2" + +- ip netns exec ns0 nft flush chain $family nat output ++ ip netns exec "$ns0" nft flush chain $family nat output + + reset_counters +- ip netns exec ns0 ping -q -c 1 10.0.1.99 > /dev/null ++ ip netns exec "$ns0" ping -q -c 1 10.0.1.99 > /dev/null + if [ $? -ne 0 ]; then + lret=1 + echo "ERROR: ping failed" +@@ -319,17 +334,17 @@ EOF + + expect="packets 1 bytes 84" + for dir in "in" "out" ; do +- cnt=$(ip netns exec ns0 nft list counter inet filter ns1${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns0" nft list counter inet filter ns1${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns1 ns1$dir "$expect" ++ bad_counter "$ns1" ns1$dir "$expect" "test_local_dnat 5" + lret=1 + fi + done + expect="packets 0 bytes 0" + for dir in "in" "out" ; do +- cnt=$(ip netns exec ns0 nft list counter inet filter ns2${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns0" nft list counter inet filter ns2${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns0 ns2$dir "$expect" ++ bad_counter "$ns0" ns2$dir "$expect" "test_local_dnat 6" + lret=1 + fi + done +@@ -337,9 +352,9 @@ EOF + # expect 1 count in ns1 + expect="packets 1 bytes 84" + for dir in "in" "out" ; do +- cnt=$(ip netns exec ns1 nft list counter inet filter ns0${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns1" nft list counter inet filter ns0${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns0 ns0$dir "$expect" ++ bad_counter "$ns0" ns0$dir "$expect" "test_local_dnat 7" + lret=1 + fi + done +@@ -347,14 +362,14 @@ EOF + # expect 0 packet in ns2 + expect="packets 0 bytes 0" + for dir in "in" "out" ; do +- cnt=$(ip netns exec ns2 nft list counter inet filter ns0${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns2" nft list counter inet filter ns0${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns2 ns2$dir "$expect" ++ bad_counter "$ns2" ns0$dir "$expect" "test_local_dnat 8" + lret=1 + fi + done + +- test $lret -eq 0 && echo "PASS: ping to ns1 OK after $family nat output chain flush" ++ test $lret -eq 0 && echo "PASS: ping to $ns1 OK after $family nat output chain flush" + + return $lret + } +@@ -366,26 +381,26 @@ test_masquerade6() + local natflags=$2 + local lret=0 + +- ip netns exec ns0 sysctl net.ipv6.conf.all.forwarding=1 > /dev/null ++ ip netns exec "$ns0" sysctl net.ipv6.conf.all.forwarding=1 > /dev/null + +- ip netns exec ns2 ping -q -c 1 dead:1::99 > /dev/null # ping ns2->ns1 ++ ip netns exec "$ns2" ping -q -c 1 dead:1::99 > /dev/null # ping ns2->ns1 + if [ $? -ne 0 ] ; then +- echo "ERROR: cannot ping ns1 from ns2 via ipv6" ++ echo "ERROR: cannot ping $ns1 from $ns2 via ipv6" + return 1 + lret=1 + fi + + expect="packets 1 bytes 104" + for dir in "in6" "out6" ; do +- cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns1" nft list counter inet filter ns2${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns1 ns2$dir "$expect" ++ bad_counter "$ns1" ns2$dir "$expect" "test_masquerade6 1" + lret=1 + fi + +- cnt=$(ip netns exec ns2 nft list counter inet filter ns1${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns2" nft list counter inet filter ns1${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns2 ns1$dir "$expect" ++ bad_counter "$ns2" ns1$dir "$expect" "test_masquerade6 2" + lret=1 + fi + done +@@ -393,7 +408,7 @@ test_masquerade6() + reset_counters + + # add masquerading rule +-ip netns exec ns0 nft -f - < /dev/null # ping ns2->ns1 ++ ip netns exec "$ns2" ping -q -c 1 dead:1::99 > /dev/null # ping ns2->ns1 + if [ $? -ne 0 ] ; then +- echo "ERROR: cannot ping ns1 from ns2 with active $family masquerade $natflags" ++ echo "ERROR: cannot ping $ns1 from $ns2 with active $family masquerade $natflags" + lret=1 + fi + + # ns1 should have seen packets from ns0, due to masquerade + expect="packets 1 bytes 104" + for dir in "in6" "out6" ; do +- cnt=$(ip netns exec ns1 nft list counter inet filter ns0${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns1" nft list counter inet filter ns0${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns1 ns0$dir "$expect" ++ bad_counter "$ns1" ns0$dir "$expect" "test_masquerade6 3" + lret=1 + fi + +- cnt=$(ip netns exec ns2 nft list counter inet filter ns1${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns2" nft list counter inet filter ns1${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns2 ns1$dir "$expect" ++ bad_counter "$ns2" ns1$dir "$expect" "test_masquerade6 4" + lret=1 + fi + done +@@ -431,32 +446,32 @@ EOF + # ns1 should not have seen packets from ns2, due to masquerade + expect="packets 0 bytes 0" + for dir in "in6" "out6" ; do +- cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns1" nft list counter inet filter ns2${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns1 ns0$dir "$expect" ++ bad_counter "$ns1" ns0$dir "$expect" "test_masquerade6 5" + lret=1 + fi + +- cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns0" nft list counter inet filter ns1${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns2 ns1$dir "$expect" ++ bad_counter "$ns0" ns1$dir "$expect" "test_masquerade6 6" + lret=1 + fi + done + +- ip netns exec ns2 ping -q -c 1 dead:1::99 > /dev/null # ping ns2->ns1 ++ ip netns exec "$ns2" ping -q -c 1 dead:1::99 > /dev/null # ping ns2->ns1 + if [ $? -ne 0 ] ; then +- echo "ERROR: cannot ping ns1 from ns2 with active ipv6 masquerade $natflags (attempt 2)" ++ echo "ERROR: cannot ping $ns1 from $ns2 with active ipv6 masquerade $natflags (attempt 2)" + lret=1 + fi + +- ip netns exec ns0 nft flush chain $family nat postrouting ++ ip netns exec "$ns0" nft flush chain $family nat postrouting + if [ $? -ne 0 ]; then + echo "ERROR: Could not flush $family nat postrouting" 1>&2 + lret=1 + fi + +- test $lret -eq 0 && echo "PASS: $family IPv6 masquerade $natflags for ns2" ++ test $lret -eq 0 && echo "PASS: $family IPv6 masquerade $natflags for $ns2" + + return $lret + } +@@ -467,26 +482,26 @@ test_masquerade() + local natflags=$2 + local lret=0 + +- ip netns exec ns0 sysctl net.ipv4.conf.veth0.forwarding=1 > /dev/null +- ip netns exec ns0 sysctl net.ipv4.conf.veth1.forwarding=1 > /dev/null ++ ip netns exec "$ns0" sysctl net.ipv4.conf.veth0.forwarding=1 > /dev/null ++ ip netns exec "$ns0" sysctl net.ipv4.conf.veth1.forwarding=1 > /dev/null + +- ip netns exec ns2 ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1 ++ ip netns exec "$ns2" ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1 + if [ $? -ne 0 ] ; then +- echo "ERROR: cannot ping ns1 from ns2 $natflags" ++ echo "ERROR: cannot ping $ns1 from "$ns2" $natflags" + lret=1 + fi + + expect="packets 1 bytes 84" + for dir in "in" "out" ; do +- cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns1" nft list counter inet filter ns2${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns1 ns2$dir "$expect" ++ bad_counter "$ns1" ns2$dir "$expect" "test_masquerade 1" + lret=1 + fi + +- cnt=$(ip netns exec ns2 nft list counter inet filter ns1${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns2" nft list counter inet filter ns1${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns2 ns1$dir "$expect" ++ bad_counter "$ns2" ns1$dir "$expect" "test_masquerade 2" + lret=1 + fi + done +@@ -494,7 +509,7 @@ test_masquerade() + reset_counters + + # add masquerading rule +-ip netns exec ns0 nft -f - < /dev/null # ping ns2->ns1 ++ ip netns exec "$ns2" ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1 + if [ $? -ne 0 ] ; then +- echo "ERROR: cannot ping ns1 from ns2 with active $family masquerade $natflags" ++ echo "ERROR: cannot ping $ns1 from $ns2 with active $family masquerade $natflags" + lret=1 + fi + + # ns1 should have seen packets from ns0, due to masquerade + expect="packets 1 bytes 84" + for dir in "in" "out" ; do +- cnt=$(ip netns exec ns1 nft list counter inet filter ns0${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns1" nft list counter inet filter ns0${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns1 ns0$dir "$expect" ++ bad_counter "$ns1" ns0$dir "$expect" "test_masquerade 3" + lret=1 + fi + +- cnt=$(ip netns exec ns2 nft list counter inet filter ns1${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns2" nft list counter inet filter ns1${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns2 ns1$dir "$expect" ++ bad_counter "$ns2" ns1$dir "$expect" "test_masquerade 4" + lret=1 + fi + done +@@ -532,32 +547,32 @@ EOF + # ns1 should not have seen packets from ns2, due to masquerade + expect="packets 0 bytes 0" + for dir in "in" "out" ; do +- cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns1" nft list counter inet filter ns2${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns1 ns0$dir "$expect" ++ bad_counter "$ns1" ns0$dir "$expect" "test_masquerade 5" + lret=1 + fi + +- cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns0" nft list counter inet filter ns1${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns2 ns1$dir "$expect" ++ bad_counter "$ns0" ns1$dir "$expect" "test_masquerade 6" + lret=1 + fi + done + +- ip netns exec ns2 ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1 ++ ip netns exec "$ns2" ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1 + if [ $? -ne 0 ] ; then +- echo "ERROR: cannot ping ns1 from ns2 with active ip masquerade $natflags (attempt 2)" ++ echo "ERROR: cannot ping $ns1 from $ns2 with active ip masquerade $natflags (attempt 2)" + lret=1 + fi + +- ip netns exec ns0 nft flush chain $family nat postrouting ++ ip netns exec "$ns0" nft flush chain $family nat postrouting + if [ $? -ne 0 ]; then + echo "ERROR: Could not flush $family nat postrouting" 1>&2 + lret=1 + fi + +- test $lret -eq 0 && echo "PASS: $family IP masquerade $natflags for ns2" ++ test $lret -eq 0 && echo "PASS: $family IP masquerade $natflags for $ns2" + + return $lret + } +@@ -567,25 +582,25 @@ test_redirect6() + local family=$1 + local lret=0 + +- ip netns exec ns0 sysctl net.ipv6.conf.all.forwarding=1 > /dev/null ++ ip netns exec "$ns0" sysctl net.ipv6.conf.all.forwarding=1 > /dev/null + +- ip netns exec ns2 ping -q -c 1 dead:1::99 > /dev/null # ping ns2->ns1 ++ ip netns exec "$ns2" ping -q -c 1 dead:1::99 > /dev/null # ping ns2->ns1 + if [ $? -ne 0 ] ; then +- echo "ERROR: cannnot ping ns1 from ns2 via ipv6" ++ echo "ERROR: cannnot ping $ns1 from $ns2 via ipv6" + lret=1 + fi + + expect="packets 1 bytes 104" + for dir in "in6" "out6" ; do +- cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns1" nft list counter inet filter ns2${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns1 ns2$dir "$expect" ++ bad_counter "$ns1" ns2$dir "$expect" "test_redirect6 1" + lret=1 + fi + +- cnt=$(ip netns exec ns2 nft list counter inet filter ns1${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns2" nft list counter inet filter ns1${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns2 ns1$dir "$expect" ++ bad_counter "$ns2" ns1$dir "$expect" "test_redirect6 2" + lret=1 + fi + done +@@ -593,7 +608,7 @@ test_redirect6() + reset_counters + + # add redirect rule +-ip netns exec ns0 nft -f - < /dev/null # ping ns2->ns1 ++ ip netns exec "$ns2" ping -q -c 1 dead:1::99 > /dev/null # ping ns2->ns1 + if [ $? -ne 0 ] ; then +- echo "ERROR: cannot ping ns1 from ns2 via ipv6 with active $family redirect" ++ echo "ERROR: cannot ping $ns1 from $ns2 via ipv6 with active $family redirect" + lret=1 + fi + + # ns1 should have seen no packets from ns2, due to redirection + expect="packets 0 bytes 0" + for dir in "in6" "out6" ; do +- cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns1" nft list counter inet filter ns2${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns1 ns0$dir "$expect" ++ bad_counter "$ns1" ns0$dir "$expect" "test_redirect6 3" + lret=1 + fi + done +@@ -625,20 +640,20 @@ EOF + # ns0 should have seen packets from ns2, due to masquerade + expect="packets 1 bytes 104" + for dir in "in6" "out6" ; do +- cnt=$(ip netns exec ns0 nft list counter inet filter ns2${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns0" nft list counter inet filter ns2${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns1 ns0$dir "$expect" ++ bad_counter "$ns1" ns0$dir "$expect" "test_redirect6 4" + lret=1 + fi + done + +- ip netns exec ns0 nft delete table $family nat ++ ip netns exec "$ns0" nft delete table $family nat + if [ $? -ne 0 ]; then + echo "ERROR: Could not delete $family nat table" 1>&2 + lret=1 + fi + +- test $lret -eq 0 && echo "PASS: $family IPv6 redirection for ns2" ++ test $lret -eq 0 && echo "PASS: $family IPv6 redirection for $ns2" + + return $lret + } +@@ -648,26 +663,26 @@ test_redirect() + local family=$1 + local lret=0 + +- ip netns exec ns0 sysctl net.ipv4.conf.veth0.forwarding=1 > /dev/null +- ip netns exec ns0 sysctl net.ipv4.conf.veth1.forwarding=1 > /dev/null ++ ip netns exec "$ns0" sysctl net.ipv4.conf.veth0.forwarding=1 > /dev/null ++ ip netns exec "$ns0" sysctl net.ipv4.conf.veth1.forwarding=1 > /dev/null + +- ip netns exec ns2 ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1 ++ ip netns exec "$ns2" ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1 + if [ $? -ne 0 ] ; then +- echo "ERROR: cannot ping ns1 from ns2" ++ echo "ERROR: cannot ping $ns1 from $ns2" + lret=1 + fi + + expect="packets 1 bytes 84" + for dir in "in" "out" ; do +- cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns1" nft list counter inet filter ns2${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns1 ns2$dir "$expect" ++ bad_counter "$ns1" $ns2$dir "$expect" "test_redirect 1" + lret=1 + fi + +- cnt=$(ip netns exec ns2 nft list counter inet filter ns1${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns2" nft list counter inet filter ns1${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns2 ns1$dir "$expect" ++ bad_counter "$ns2" ns1$dir "$expect" "test_redirect 2" + lret=1 + fi + done +@@ -675,7 +690,7 @@ test_redirect() + reset_counters + + # add redirect rule +-ip netns exec ns0 nft -f - < /dev/null # ping ns2->ns1 ++ ip netns exec "$ns2" ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1 + if [ $? -ne 0 ] ; then +- echo "ERROR: cannot ping ns1 from ns2 with active $family ip redirect" ++ echo "ERROR: cannot ping $ns1 from $ns2 with active $family ip redirect" + lret=1 + fi + +@@ -698,9 +713,9 @@ EOF + expect="packets 0 bytes 0" + for dir in "in" "out" ; do + +- cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns1" nft list counter inet filter ns2${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns1 ns0$dir "$expect" ++ bad_counter "$ns1" ns0$dir "$expect" "test_redirect 3" + lret=1 + fi + done +@@ -708,28 +723,28 @@ EOF + # ns0 should have seen packets from ns2, due to masquerade + expect="packets 1 bytes 84" + for dir in "in" "out" ; do +- cnt=$(ip netns exec ns0 nft list counter inet filter ns2${dir} | grep -q "$expect") ++ cnt=$(ip netns exec "$ns0" nft list counter inet filter ns2${dir} | grep -q "$expect") + if [ $? -ne 0 ]; then +- bad_counter ns1 ns0$dir "$expect" ++ bad_counter "$ns0" ns0$dir "$expect" "test_redirect 4" + lret=1 + fi + done + +- ip netns exec ns0 nft delete table $family nat ++ ip netns exec "$ns0" nft delete table $family nat + if [ $? -ne 0 ]; then + echo "ERROR: Could not delete $family nat table" 1>&2 + lret=1 + fi + +- test $lret -eq 0 && echo "PASS: $family IP redirection for ns2" ++ test $lret -eq 0 && echo "PASS: $family IP redirection for $ns2" + + return $lret + } + + +-# ip netns exec ns0 ping -c 1 -q 10.0.$i.99 ++# ip netns exec "$ns0" ping -c 1 -q 10.0.$i.99 + for i in 0 1 2; do +-ip netns exec ns$i nft -f - < /dev/null ++ ip netns exec "$ns0" ping -c 1 -q 10.0.$i.99 > /dev/null + if [ $? -ne 0 ];then + echo "ERROR: Could not reach other namespace(s)" 1>&2 + ret=1 + fi + +- ip netns exec ns0 ping -c 1 -q dead:$i::99 > /dev/null ++ ip netns exec "$ns0" ping -c 1 -q dead:$i::99 > /dev/null + if [ $? -ne 0 ];then + echo "ERROR: Could not reach other namespace(s) via ipv6" 1>&2 + ret=1 + fi +- check_counters ns$i ++ check_counters ns$i-$sfx + if [ $? -ne 0 ]; then + ret=1 + fi +@@ -820,7 +835,7 @@ for i in 1 2; do + done + + if [ $ret -eq 0 ];then +- echo "PASS: netns routing/connectivity: ns0 can reach ns1 and ns2" ++ echo "PASS: netns routing/connectivity: $ns0 can reach $ns1 and $ns2" + fi + + reset_counters +@@ -846,4 +861,9 @@ reset_counters + $test_inet_nat && test_redirect inet + $test_inet_nat && test_redirect6 inet + ++if [ $ret -ne 0 ];then ++ echo -n "FAIL: " ++ nft --version ++fi ++ + exit $ret +diff --git a/tools/testing/selftests/safesetid/Makefile b/tools/testing/selftests/safesetid/Makefile +index 98da7a504737..fa02c4d5ec13 100644 +--- a/tools/testing/selftests/safesetid/Makefile ++++ b/tools/testing/selftests/safesetid/Makefile +@@ -1,8 +1,9 @@ + # SPDX-License-Identifier: GPL-2.0 + # Makefile for mount selftests. +-CFLAGS = -Wall -lcap -O2 ++CFLAGS = -Wall -O2 ++LDLIBS = -lcap + +-TEST_PROGS := run_tests.sh ++TEST_PROGS := safesetid-test.sh + TEST_GEN_FILES := safesetid-test + + include ../lib.mk +diff --git a/tools/testing/selftests/safesetid/safesetid-test.c b/tools/testing/selftests/safesetid/safesetid-test.c +index 8f40c6ecdad1..0c4d50644c13 100644 +--- a/tools/testing/selftests/safesetid/safesetid-test.c ++++ b/tools/testing/selftests/safesetid/safesetid-test.c +@@ -213,7 +213,8 @@ static void test_setuid(uid_t child_uid, bool expect_success) + } + + if (cpid == 0) { /* Code executed by child */ +- setuid(child_uid); ++ if (setuid(child_uid) < 0) ++ exit(EXIT_FAILURE); + if (getuid() == child_uid) + exit(EXIT_SUCCESS); + else +@@ -291,8 +292,10 @@ int main(int argc, char **argv) + + // First test to make sure we can write userns mappings from a user + // that doesn't have any restrictions (as long as it has CAP_SETUID); +- setuid(NO_POLICY_USER); +- setgid(NO_POLICY_USER); ++ if (setuid(NO_POLICY_USER) < 0) ++ die("Error with set uid(%d)\n", NO_POLICY_USER); ++ if (setgid(NO_POLICY_USER) < 0) ++ die("Error with set gid(%d)\n", NO_POLICY_USER); + + // Take away all but setid caps + drop_caps(true); +@@ -306,8 +309,10 @@ int main(int argc, char **argv) + die("test_userns failed when it should work\n"); + } + +- setuid(RESTRICTED_PARENT); +- setgid(RESTRICTED_PARENT); ++ if (setuid(RESTRICTED_PARENT) < 0) ++ die("Error with set uid(%d)\n", RESTRICTED_PARENT); ++ if (setgid(RESTRICTED_PARENT) < 0) ++ die("Error with set gid(%d)\n", RESTRICTED_PARENT); + + test_setuid(ROOT_USER, false); + test_setuid(ALLOWED_CHILD1, true);