[gentoo-commits] proj/linux-patches:5.4 commit in: /

[Mike Pagano]

commit:     e611a1958ebdf6e895280efce1cfa08b17c5b4d9
Author:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
AuthorDate: Sun Jan 12 15:01:02 2020 +0000
Commit:     Mike Pagano <mpagano <AT> gentoo <DOT> 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 <mpagano <AT> 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 = <&ethphy0>;
+-	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 <linux/jump_label.h>
+ #include <linux/irqflags.h>
+ #ifdef CONFIG_PPC64
+ #include <asm/paca.h>
+@@ -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 <linux/blkdev.h>
+ #include <linux/gfp.h>
+ #include <linux/blk-mq.h>
++#include <linux/lockdep.h>
+ 
+ #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 <asm/early_ioremap.h>
+ 
++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,
+-				       &current_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,
+-				       &current_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 <linux/of_gpio.h>
+  *
+@@ -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 <linux/iova.h>
+ #include <linux/irq.h>
+ #include <linux/mm.h>
++#include <linux/mutex.h>
+ #include <linux/pci.h>
+ #include <linux/scatterlist.h>
+ #include <linux/vmalloc.h>
+@@ -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 <b.galvani@×××××.com>");
+ 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, &regs[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 : "<none>",
+ 		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 <linux/trace_seq.h>
+ #include <linux/spinlock.h>
+ #include <linux/irq_work.h>
++#include <linux/security.h>
+ #include <linux/uaccess.h>
+ #include <linux/hardirq.h>
+ #include <linux/kthread.h>	/* 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 - <<EOF
++ip netns exec "$ns0" nft -f /dev/stdin <<EOF
+ table $family nat {
+ 	chain output {
+ 		type nat hook output priority 0; policy accept;
+@@ -180,7 +195,7 @@ EOF
+ 	fi
+ 
+ 	# ping netns1, expect rewrite to netns2
+-	ip netns exec ns0 ping -q -c 1 dead:1::99 > /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 - <<EOF 2>/dev/null
++ip netns exec "$ns0" nft -f /dev/stdin <<EOF 2>/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 - <<EOF
++ip netns exec "$ns0" nft -f /dev/stdin <<EOF
+ table $family nat {
+ 	chain postrouting {
+ 		type nat hook postrouting priority 0; policy accept;
+@@ -406,24 +421,24 @@ EOF
+ 		return $ksft_skip
+ 	fi
+ 
+-	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 $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 - <<EOF
++ip netns exec "$ns0" nft -f /dev/stdin <<EOF
+ table $family nat {
+ 	chain postrouting {
+ 		type nat hook postrouting priority 0; policy accept;
+@@ -507,24 +522,24 @@ EOF
+ 		return $ksft_skip
+ 	fi
+ 
+-	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 $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 - <<EOF
++ip netns exec "$ns0" nft -f /dev/stdin <<EOF
+ table $family nat {
+ 	chain prerouting {
+ 		type nat hook prerouting priority 0; policy accept;
+@@ -606,18 +621,18 @@ EOF
+ 		return $ksft_skip
+ 	fi
+ 
+-	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 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 - <<EOF
++ip netns exec "$ns0" nft -f /dev/stdin <<EOF
+ table $family nat {
+ 	chain prerouting {
+ 		type nat hook prerouting priority 0; policy accept;
+@@ -688,9 +703,9 @@ EOF
+ 		return $ksft_skip
+ 	fi
+ 
+-	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 $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 - <<EOF
++ip netns exec ns$i-$sfx nft -f /dev/stdin <<EOF
+ table inet filter {
+ 	counter ns0in {}
+ 	counter ns1in {}
+@@ -796,18 +811,18 @@ done
+ sleep 3
+ # test basic connectivity
+ for i in 1 2; do
+-  ip netns exec ns0 ping -c 1 -q 10.0.$i.99 > /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);