commit: 10b10cc36e5daccf1742d7a1d0b357598a1704fd Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Sat Apr 10 13:27:18 2021 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Sat Apr 10 13:27:18 2021 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=10b10cc3
Linux patch 5.11.13 Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> 0000_README | 4 + 1012_linux-5.11.13.patch | 1345 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1349 insertions(+) diff --git a/0000_README b/0000_README index fe996e4..ddf5a5f 100644 --- a/0000_README +++ b/0000_README @@ -91,6 +91,10 @@ Patch: 1011_linux-5.11.12.patch From: http://www.kernel.org Desc: Linux 5.11.12 +Patch: 1012_linux-5.11.13.patch +From: http://www.kernel.org +Desc: Linux 5.11.13 + 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/1012_linux-5.11.13.patch b/1012_linux-5.11.13.patch new file mode 100644 index 0000000..860f1d7 --- /dev/null +++ b/1012_linux-5.11.13.patch @@ -0,0 +1,1345 @@ +diff --git a/Documentation/arm64/silicon-errata.rst b/Documentation/arm64/silicon-errata.rst +index 7195102472929..d410a47ffa57a 100644 +--- a/Documentation/arm64/silicon-errata.rst ++++ b/Documentation/arm64/silicon-errata.rst +@@ -130,6 +130,9 @@ stable kernels. + | Marvell | ARM-MMU-500 | #582743 | N/A | + +----------------+-----------------+-----------------+-----------------------------+ + +----------------+-----------------+-----------------+-----------------------------+ ++| NVIDIA | Carmel Core | N/A | NVIDIA_CARMEL_CNP_ERRATUM | +++----------------+-----------------+-----------------+-----------------------------+ +++----------------+-----------------+-----------------+-----------------------------+ + | Freescale/NXP | LS2080A/LS1043A | A-008585 | FSL_ERRATUM_A008585 | + +----------------+-----------------+-----------------+-----------------------------+ + +----------------+-----------------+-----------------+-----------------------------+ +diff --git a/Makefile b/Makefile +index 1e31504aab61b..1be83283e0321 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 11 +-SUBLEVEL = 12 ++SUBLEVEL = 13 + EXTRAVERSION = + NAME = 💕 Valentine's Day Edition 💕 + +@@ -1082,6 +1082,17 @@ ifdef CONFIG_STACK_VALIDATION + endif + endif + ++PHONY += resolve_btfids_clean ++ ++resolve_btfids_O = $(abspath $(objtree))/tools/bpf/resolve_btfids ++ ++# tools/bpf/resolve_btfids directory might not exist ++# in output directory, skip its clean in that case ++resolve_btfids_clean: ++ifneq ($(wildcard $(resolve_btfids_O)),) ++ $(Q)$(MAKE) -sC $(srctree)/tools/bpf/resolve_btfids O=$(resolve_btfids_O) clean ++endif ++ + ifdef CONFIG_BPF + ifdef CONFIG_DEBUG_INFO_BTF + ifeq ($(has_libelf),1) +@@ -1499,7 +1510,7 @@ vmlinuxclean: + $(Q)$(CONFIG_SHELL) $(srctree)/scripts/link-vmlinux.sh clean + $(Q)$(if $(ARCH_POSTLINK), $(MAKE) -f $(ARCH_POSTLINK) clean) + +-clean: archclean vmlinuxclean ++clean: archclean vmlinuxclean resolve_btfids_clean + + # mrproper - Delete all generated files, including .config + # +diff --git a/arch/arm/boot/dts/am33xx.dtsi b/arch/arm/boot/dts/am33xx.dtsi +index 5b213a1e68bb2..5e33d0e88f5b1 100644 +--- a/arch/arm/boot/dts/am33xx.dtsi ++++ b/arch/arm/boot/dts/am33xx.dtsi +@@ -40,6 +40,9 @@ + ethernet1 = &cpsw_emac1; + spi0 = &spi0; + spi1 = &spi1; ++ mmc0 = &mmc1; ++ mmc1 = &mmc2; ++ mmc2 = &mmc3; + }; + + cpus { +diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig +index e42da99db91fc..2517dd8c5a4d1 100644 +--- a/arch/arm64/Kconfig ++++ b/arch/arm64/Kconfig +@@ -805,6 +805,16 @@ config QCOM_FALKOR_ERRATUM_E1041 + + If unsure, say Y. + ++config NVIDIA_CARMEL_CNP_ERRATUM ++ bool "NVIDIA Carmel CNP: CNP on Carmel semantically different than ARM cores" ++ default y ++ help ++ If CNP is enabled on Carmel cores, non-sharable TLBIs on a core will not ++ invalidate shared TLB entries installed by a different core, as it would ++ on standard ARM cores. ++ ++ If unsure, say Y. ++ + config SOCIONEXT_SYNQUACER_PREITS + bool "Socionext Synquacer: Workaround for GICv3 pre-ITS" + default y +diff --git a/arch/arm64/include/asm/cpucaps.h b/arch/arm64/include/asm/cpucaps.h +index b77d997b173bc..c40f2490cd7b7 100644 +--- a/arch/arm64/include/asm/cpucaps.h ++++ b/arch/arm64/include/asm/cpucaps.h +@@ -66,7 +66,8 @@ + #define ARM64_WORKAROUND_1508412 58 + #define ARM64_HAS_LDAPR 59 + #define ARM64_KVM_PROTECTED_MODE 60 ++#define ARM64_WORKAROUND_NVIDIA_CARMEL_CNP 61 + +-#define ARM64_NCAPS 61 ++#define ARM64_NCAPS 62 + + #endif /* __ASM_CPUCAPS_H */ +diff --git a/arch/arm64/kernel/cpu_errata.c b/arch/arm64/kernel/cpu_errata.c +index a63428301f423..3fc281e4e6550 100644 +--- a/arch/arm64/kernel/cpu_errata.c ++++ b/arch/arm64/kernel/cpu_errata.c +@@ -527,6 +527,14 @@ const struct arm64_cpu_capabilities arm64_errata[] = { + 0, 0, + 1, 0), + }, ++#endif ++#ifdef CONFIG_NVIDIA_CARMEL_CNP_ERRATUM ++ { ++ /* NVIDIA Carmel */ ++ .desc = "NVIDIA Carmel CNP erratum", ++ .capability = ARM64_WORKAROUND_NVIDIA_CARMEL_CNP, ++ ERRATA_MIDR_ALL_VERSIONS(MIDR_NVIDIA_CARMEL), ++ }, + #endif + { + } +diff --git a/arch/arm64/kernel/cpufeature.c b/arch/arm64/kernel/cpufeature.c +index 33b6f56dcb21b..b1f7bfadab9f7 100644 +--- a/arch/arm64/kernel/cpufeature.c ++++ b/arch/arm64/kernel/cpufeature.c +@@ -1270,7 +1270,10 @@ has_useable_cnp(const struct arm64_cpu_capabilities *entry, int scope) + * may share TLB entries with a CPU stuck in the crashed + * kernel. + */ +- if (is_kdump_kernel()) ++ if (is_kdump_kernel()) ++ return false; ++ ++ if (cpus_have_const_cap(ARM64_WORKAROUND_NVIDIA_CARMEL_CNP)) + return false; + + return has_cpuid_feature(entry, scope); +diff --git a/arch/ia64/kernel/err_inject.c b/arch/ia64/kernel/err_inject.c +index 8b5b8e6bc9d9a..dd5bfed52031d 100644 +--- a/arch/ia64/kernel/err_inject.c ++++ b/arch/ia64/kernel/err_inject.c +@@ -59,7 +59,7 @@ show_##name(struct device *dev, struct device_attribute *attr, \ + char *buf) \ + { \ + u32 cpu=dev->id; \ +- return sprintf(buf, "%lx\n", name[cpu]); \ ++ return sprintf(buf, "%llx\n", name[cpu]); \ + } + + #define store(name) \ +@@ -86,9 +86,9 @@ store_call_start(struct device *dev, struct device_attribute *attr, + + #ifdef ERR_INJ_DEBUG + printk(KERN_DEBUG "pal_mc_err_inject for cpu%d:\n", cpu); +- printk(KERN_DEBUG "err_type_info=%lx,\n", err_type_info[cpu]); +- printk(KERN_DEBUG "err_struct_info=%lx,\n", err_struct_info[cpu]); +- printk(KERN_DEBUG "err_data_buffer=%lx, %lx, %lx.\n", ++ printk(KERN_DEBUG "err_type_info=%llx,\n", err_type_info[cpu]); ++ printk(KERN_DEBUG "err_struct_info=%llx,\n", err_struct_info[cpu]); ++ printk(KERN_DEBUG "err_data_buffer=%llx, %llx, %llx.\n", + err_data_buffer[cpu].data1, + err_data_buffer[cpu].data2, + err_data_buffer[cpu].data3); +@@ -117,8 +117,8 @@ store_call_start(struct device *dev, struct device_attribute *attr, + + #ifdef ERR_INJ_DEBUG + printk(KERN_DEBUG "Returns: status=%d,\n", (int)status[cpu]); +- printk(KERN_DEBUG "capabilities=%lx,\n", capabilities[cpu]); +- printk(KERN_DEBUG "resources=%lx\n", resources[cpu]); ++ printk(KERN_DEBUG "capabilities=%llx,\n", capabilities[cpu]); ++ printk(KERN_DEBUG "resources=%llx\n", resources[cpu]); + #endif + return size; + } +@@ -131,7 +131,7 @@ show_virtual_to_phys(struct device *dev, struct device_attribute *attr, + char *buf) + { + unsigned int cpu=dev->id; +- return sprintf(buf, "%lx\n", phys_addr[cpu]); ++ return sprintf(buf, "%llx\n", phys_addr[cpu]); + } + + static ssize_t +@@ -145,7 +145,7 @@ store_virtual_to_phys(struct device *dev, struct device_attribute *attr, + ret = get_user_pages_fast(virt_addr, 1, FOLL_WRITE, NULL); + if (ret<=0) { + #ifdef ERR_INJ_DEBUG +- printk("Virtual address %lx is not existing.\n",virt_addr); ++ printk("Virtual address %llx is not existing.\n", virt_addr); + #endif + return -EINVAL; + } +@@ -163,7 +163,7 @@ show_err_data_buffer(struct device *dev, + { + unsigned int cpu=dev->id; + +- return sprintf(buf, "%lx, %lx, %lx\n", ++ return sprintf(buf, "%llx, %llx, %llx\n", + err_data_buffer[cpu].data1, + err_data_buffer[cpu].data2, + err_data_buffer[cpu].data3); +@@ -178,13 +178,13 @@ store_err_data_buffer(struct device *dev, + int ret; + + #ifdef ERR_INJ_DEBUG +- printk("write err_data_buffer=[%lx,%lx,%lx] on cpu%d\n", ++ printk("write err_data_buffer=[%llx,%llx,%llx] on cpu%d\n", + err_data_buffer[cpu].data1, + err_data_buffer[cpu].data2, + err_data_buffer[cpu].data3, + cpu); + #endif +- ret=sscanf(buf, "%lx, %lx, %lx", ++ ret = sscanf(buf, "%llx, %llx, %llx", + &err_data_buffer[cpu].data1, + &err_data_buffer[cpu].data2, + &err_data_buffer[cpu].data3); +diff --git a/arch/ia64/kernel/mca.c b/arch/ia64/kernel/mca.c +index 2703f7795672d..bd0a51dc345af 100644 +--- a/arch/ia64/kernel/mca.c ++++ b/arch/ia64/kernel/mca.c +@@ -1822,7 +1822,7 @@ ia64_mca_cpu_init(void *cpu_data) + data = mca_bootmem(); + first_time = 0; + } else +- data = (void *)__get_free_pages(GFP_KERNEL, ++ data = (void *)__get_free_pages(GFP_ATOMIC, + get_order(sz)); + if (!data) + panic("Could not allocate MCA memory for cpu %d\n", +diff --git a/arch/x86/Makefile b/arch/x86/Makefile +index 30920d70b48b3..828f24d547b2f 100644 +--- a/arch/x86/Makefile ++++ b/arch/x86/Makefile +@@ -27,7 +27,7 @@ endif + REALMODE_CFLAGS := -m16 -g -Os -DDISABLE_BRANCH_PROFILING \ + -Wall -Wstrict-prototypes -march=i386 -mregparm=3 \ + -fno-strict-aliasing -fomit-frame-pointer -fno-pic \ +- -mno-mmx -mno-sse ++ -mno-mmx -mno-sse $(call cc-option,-fcf-protection=none) + + REALMODE_CFLAGS += -ffreestanding + REALMODE_CFLAGS += -fno-stack-protector +diff --git a/arch/x86/net/bpf_jit_comp.c b/arch/x86/net/bpf_jit_comp.c +index 023ac12f54a29..a11796bbb9cee 100644 +--- a/arch/x86/net/bpf_jit_comp.c ++++ b/arch/x86/net/bpf_jit_comp.c +@@ -1476,7 +1476,16 @@ emit_jmp: + } + + if (image) { +- if (unlikely(proglen + ilen > oldproglen)) { ++ /* ++ * When populating the image, assert that: ++ * ++ * i) We do not write beyond the allocated space, and ++ * ii) addrs[i] did not change from the prior run, in order ++ * to validate assumptions made for computing branch ++ * displacements. ++ */ ++ if (unlikely(proglen + ilen > oldproglen || ++ proglen + ilen != addrs[i])) { + pr_err("bpf_jit: fatal error\n"); + return -EFAULT; + } +@@ -2038,7 +2047,7 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog) + extra_pass = true; + goto skip_init_addrs; + } +- addrs = kmalloc_array(prog->len + 1, sizeof(*addrs), GFP_KERNEL); ++ addrs = kvmalloc_array(prog->len + 1, sizeof(*addrs), GFP_KERNEL); + if (!addrs) { + prog = orig_prog; + goto out_addrs; +@@ -2128,7 +2137,7 @@ out_image: + if (image) + bpf_prog_fill_jited_linfo(prog, addrs + 1); + out_addrs: +- kfree(addrs); ++ kvfree(addrs); + kfree(jit_data); + prog->aux->jit_data = NULL; + } +diff --git a/arch/x86/net/bpf_jit_comp32.c b/arch/x86/net/bpf_jit_comp32.c +index 96fde03aa9877..2cf4d217840d8 100644 +--- a/arch/x86/net/bpf_jit_comp32.c ++++ b/arch/x86/net/bpf_jit_comp32.c +@@ -2278,7 +2278,16 @@ notyet: + } + + if (image) { +- if (unlikely(proglen + ilen > oldproglen)) { ++ /* ++ * When populating the image, assert that: ++ * ++ * i) We do not write beyond the allocated space, and ++ * ii) addrs[i] did not change from the prior run, in order ++ * to validate assumptions made for computing branch ++ * displacements. ++ */ ++ if (unlikely(proglen + ilen > oldproglen || ++ proglen + ilen != addrs[i])) { + pr_err("bpf_jit: fatal error\n"); + return -EFAULT; + } +diff --git a/drivers/bus/ti-sysc.c b/drivers/bus/ti-sysc.c +index a27d751cf219d..3d74f237f005b 100644 +--- a/drivers/bus/ti-sysc.c ++++ b/drivers/bus/ti-sysc.c +@@ -3053,7 +3053,9 @@ static int sysc_remove(struct platform_device *pdev) + + pm_runtime_put_sync(&pdev->dev); + pm_runtime_disable(&pdev->dev); +- reset_control_assert(ddata->rsts); ++ ++ if (!reset_control_status(ddata->rsts)) ++ reset_control_assert(ddata->rsts); + + unprepare: + sysc_unprepare(ddata); +diff --git a/drivers/gpu/drm/msm/adreno/a5xx_power.c b/drivers/gpu/drm/msm/adreno/a5xx_power.c +index f176a6f3eff66..e58670a61df4b 100644 +--- a/drivers/gpu/drm/msm/adreno/a5xx_power.c ++++ b/drivers/gpu/drm/msm/adreno/a5xx_power.c +@@ -304,7 +304,7 @@ int a5xx_power_init(struct msm_gpu *gpu) + /* Set up the limits management */ + if (adreno_is_a530(adreno_gpu)) + a530_lm_setup(gpu); +- else ++ else if (adreno_is_a540(adreno_gpu)) + a540_lm_setup(gpu); + + /* Set up SP/TP power collpase */ +diff --git a/drivers/gpu/drm/msm/adreno/a6xx_gpu.c b/drivers/gpu/drm/msm/adreno/a6xx_gpu.c +index 0366419d8bfed..e7a8442b59afd 100644 +--- a/drivers/gpu/drm/msm/adreno/a6xx_gpu.c ++++ b/drivers/gpu/drm/msm/adreno/a6xx_gpu.c +@@ -521,28 +521,73 @@ static int a6xx_cp_init(struct msm_gpu *gpu) + return a6xx_idle(gpu, ring) ? 0 : -EINVAL; + } + +-static void a6xx_ucode_check_version(struct a6xx_gpu *a6xx_gpu, ++/* ++ * Check that the microcode version is new enough to include several key ++ * security fixes. Return true if the ucode is safe. ++ */ ++static bool a6xx_ucode_check_version(struct a6xx_gpu *a6xx_gpu, + struct drm_gem_object *obj) + { ++ struct adreno_gpu *adreno_gpu = &a6xx_gpu->base; ++ struct msm_gpu *gpu = &adreno_gpu->base; + u32 *buf = msm_gem_get_vaddr(obj); ++ bool ret = false; + + if (IS_ERR(buf)) +- return; ++ return false; + + /* +- * If the lowest nibble is 0xa that is an indication that this microcode +- * has been patched. The actual version is in dword [3] but we only care +- * about the patchlevel which is the lowest nibble of dword [3] +- * +- * Otherwise check that the firmware is greater than or equal to 1.90 +- * which was the first version that had this fix built in ++ * Targets up to a640 (a618, a630 and a640) need to check for a ++ * microcode version that is patched to support the whereami opcode or ++ * one that is new enough to include it by default. + */ +- if (((buf[0] & 0xf) == 0xa) && (buf[2] & 0xf) >= 1) +- a6xx_gpu->has_whereami = true; +- else if ((buf[0] & 0xfff) > 0x190) +- a6xx_gpu->has_whereami = true; ++ if (adreno_is_a618(adreno_gpu) || adreno_is_a630(adreno_gpu) || ++ adreno_is_a640(adreno_gpu)) { ++ /* ++ * If the lowest nibble is 0xa that is an indication that this ++ * microcode has been patched. The actual version is in dword ++ * [3] but we only care about the patchlevel which is the lowest ++ * nibble of dword [3] ++ * ++ * Otherwise check that the firmware is greater than or equal ++ * to 1.90 which was the first version that had this fix built ++ * in ++ */ ++ if ((((buf[0] & 0xf) == 0xa) && (buf[2] & 0xf) >= 1) || ++ (buf[0] & 0xfff) >= 0x190) { ++ a6xx_gpu->has_whereami = true; ++ ret = true; ++ goto out; ++ } + ++ DRM_DEV_ERROR(&gpu->pdev->dev, ++ "a630 SQE ucode is too old. Have version %x need at least %x\n", ++ buf[0] & 0xfff, 0x190); ++ } else { ++ /* ++ * a650 tier targets don't need whereami but still need to be ++ * equal to or newer than 1.95 for other security fixes ++ */ ++ if (adreno_is_a650(adreno_gpu)) { ++ if ((buf[0] & 0xfff) >= 0x195) { ++ ret = true; ++ goto out; ++ } ++ ++ DRM_DEV_ERROR(&gpu->pdev->dev, ++ "a650 SQE ucode is too old. Have version %x need at least %x\n", ++ buf[0] & 0xfff, 0x195); ++ } ++ ++ /* ++ * When a660 is added those targets should return true here ++ * since those have all the critical security fixes built in ++ * from the start ++ */ ++ } ++out: + msm_gem_put_vaddr(obj); ++ return ret; + } + + static int a6xx_ucode_init(struct msm_gpu *gpu) +@@ -565,7 +610,13 @@ static int a6xx_ucode_init(struct msm_gpu *gpu) + } + + msm_gem_object_set_name(a6xx_gpu->sqe_bo, "sqefw"); +- a6xx_ucode_check_version(a6xx_gpu, a6xx_gpu->sqe_bo); ++ if (!a6xx_ucode_check_version(a6xx_gpu, a6xx_gpu->sqe_bo)) { ++ msm_gem_unpin_iova(a6xx_gpu->sqe_bo, gpu->aspace); ++ drm_gem_object_put(a6xx_gpu->sqe_bo); ++ ++ a6xx_gpu->sqe_bo = NULL; ++ return -EPERM; ++ } + } + + gpu_write64(gpu, REG_A6XX_CP_SQE_INSTR_BASE_LO, +diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c +index 374b0e8471e60..0f1b04ef61f2c 100644 +--- a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c ++++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c +@@ -43,6 +43,8 @@ + #define DPU_DEBUGFS_DIR "msm_dpu" + #define DPU_DEBUGFS_HWMASKNAME "hw_log_mask" + ++#define MIN_IB_BW 400000000ULL /* Min ib vote 400MB */ ++ + static int dpu_kms_hw_init(struct msm_kms *kms); + static void _dpu_kms_mmu_destroy(struct dpu_kms *dpu_kms); + +@@ -931,6 +933,9 @@ static int dpu_kms_hw_init(struct msm_kms *kms) + DPU_DEBUG("REG_DMA is not defined"); + } + ++ if (of_device_is_compatible(dev->dev->of_node, "qcom,sc7180-mdss")) ++ dpu_kms_parse_data_bus_icc_path(dpu_kms); ++ + pm_runtime_get_sync(&dpu_kms->pdev->dev); + + dpu_kms->core_rev = readl_relaxed(dpu_kms->mmio + 0x0); +@@ -1032,9 +1037,6 @@ static int dpu_kms_hw_init(struct msm_kms *kms) + + dpu_vbif_init_memtypes(dpu_kms); + +- if (of_device_is_compatible(dev->dev->of_node, "qcom,sc7180-mdss")) +- dpu_kms_parse_data_bus_icc_path(dpu_kms); +- + pm_runtime_put_sync(&dpu_kms->pdev->dev); + + return 0; +@@ -1191,10 +1193,10 @@ static int __maybe_unused dpu_runtime_resume(struct device *dev) + + ddev = dpu_kms->dev; + ++ WARN_ON(!(dpu_kms->num_paths)); + /* Min vote of BW is required before turning on AXI clk */ + for (i = 0; i < dpu_kms->num_paths; i++) +- icc_set_bw(dpu_kms->path[i], 0, +- dpu_kms->catalog->perf.min_dram_ib); ++ icc_set_bw(dpu_kms->path[i], 0, Bps_to_icc(MIN_IB_BW)); + + rc = msm_dss_enable_clk(mp->clk_config, mp->num_clk, true); + if (rc) { +diff --git a/drivers/gpu/drm/msm/dsi/pll/dsi_pll_7nm.c b/drivers/gpu/drm/msm/dsi/pll/dsi_pll_7nm.c +index c1f6708367ae9..c1c41846b6b2b 100644 +--- a/drivers/gpu/drm/msm/dsi/pll/dsi_pll_7nm.c ++++ b/drivers/gpu/drm/msm/dsi/pll/dsi_pll_7nm.c +@@ -325,7 +325,7 @@ static void dsi_pll_commit(struct dsi_pll_7nm *pll) + pll_write(base + REG_DSI_7nm_PHY_PLL_FRAC_DIV_START_LOW_1, reg->frac_div_start_low); + pll_write(base + REG_DSI_7nm_PHY_PLL_FRAC_DIV_START_MID_1, reg->frac_div_start_mid); + pll_write(base + REG_DSI_7nm_PHY_PLL_FRAC_DIV_START_HIGH_1, reg->frac_div_start_high); +- pll_write(base + REG_DSI_7nm_PHY_PLL_PLL_LOCKDET_RATE_1, 0x40); ++ pll_write(base + REG_DSI_7nm_PHY_PLL_PLL_LOCKDET_RATE_1, reg->pll_lockdet_rate); + pll_write(base + REG_DSI_7nm_PHY_PLL_PLL_LOCK_DELAY, 0x06); + pll_write(base + REG_DSI_7nm_PHY_PLL_CMODE_1, 0x10); /* TODO: 0x00 for CPHY */ + pll_write(base + REG_DSI_7nm_PHY_PLL_CLOCK_INVERTERS, reg->pll_clock_inverters); +diff --git a/drivers/gpu/drm/msm/msm_fence.c b/drivers/gpu/drm/msm/msm_fence.c +index ad2703698b052..cd59a59180385 100644 +--- a/drivers/gpu/drm/msm/msm_fence.c ++++ b/drivers/gpu/drm/msm/msm_fence.c +@@ -45,7 +45,7 @@ int msm_wait_fence(struct msm_fence_context *fctx, uint32_t fence, + int ret; + + if (fence > fctx->last_fence) { +- DRM_ERROR("%s: waiting on invalid fence: %u (of %u)\n", ++ DRM_ERROR_RATELIMITED("%s: waiting on invalid fence: %u (of %u)\n", + fctx->name, fence, fctx->last_fence); + return -EINVAL; + } +diff --git a/drivers/isdn/hardware/mISDN/mISDNipac.c b/drivers/isdn/hardware/mISDN/mISDNipac.c +index ec475087fbf93..39f841b424883 100644 +--- a/drivers/isdn/hardware/mISDN/mISDNipac.c ++++ b/drivers/isdn/hardware/mISDN/mISDNipac.c +@@ -694,7 +694,7 @@ isac_release(struct isac_hw *isac) + { + if (isac->type & IPAC_TYPE_ISACX) + WriteISAC(isac, ISACX_MASK, 0xff); +- else ++ else if (isac->type != 0) + WriteISAC(isac, ISAC_MASK, 0xff); + if (isac->dch.timer.function != NULL) { + del_timer(&isac->dch.timer); +diff --git a/drivers/net/arcnet/com20020-pci.c b/drivers/net/arcnet/com20020-pci.c +index 8bdc44b7e09a1..3c8f665c15580 100644 +--- a/drivers/net/arcnet/com20020-pci.c ++++ b/drivers/net/arcnet/com20020-pci.c +@@ -127,6 +127,8 @@ static int com20020pci_probe(struct pci_dev *pdev, + int i, ioaddr, ret; + struct resource *r; + ++ ret = 0; ++ + if (pci_enable_device(pdev)) + return -EIO; + +@@ -139,6 +141,8 @@ static int com20020pci_probe(struct pci_dev *pdev, + priv->ci = ci; + mm = &ci->misc_map; + ++ pci_set_drvdata(pdev, priv); ++ + INIT_LIST_HEAD(&priv->list_dev); + + if (mm->size) { +@@ -161,7 +165,7 @@ static int com20020pci_probe(struct pci_dev *pdev, + dev = alloc_arcdev(device); + if (!dev) { + ret = -ENOMEM; +- goto out_port; ++ break; + } + dev->dev_port = i; + +@@ -178,7 +182,7 @@ static int com20020pci_probe(struct pci_dev *pdev, + pr_err("IO region %xh-%xh already allocated\n", + ioaddr, ioaddr + cm->size - 1); + ret = -EBUSY; +- goto out_port; ++ goto err_free_arcdev; + } + + /* Dummy access after Reset +@@ -216,18 +220,18 @@ static int com20020pci_probe(struct pci_dev *pdev, + if (arcnet_inb(ioaddr, COM20020_REG_R_STATUS) == 0xFF) { + pr_err("IO address %Xh is empty!\n", ioaddr); + ret = -EIO; +- goto out_port; ++ goto err_free_arcdev; + } + if (com20020_check(dev)) { + ret = -EIO; +- goto out_port; ++ goto err_free_arcdev; + } + + card = devm_kzalloc(&pdev->dev, sizeof(struct com20020_dev), + GFP_KERNEL); + if (!card) { + ret = -ENOMEM; +- goto out_port; ++ goto err_free_arcdev; + } + + card->index = i; +@@ -253,29 +257,29 @@ static int com20020pci_probe(struct pci_dev *pdev, + + ret = devm_led_classdev_register(&pdev->dev, &card->tx_led); + if (ret) +- goto out_port; ++ goto err_free_arcdev; + + ret = devm_led_classdev_register(&pdev->dev, &card->recon_led); + if (ret) +- goto out_port; ++ goto err_free_arcdev; + + dev_set_drvdata(&dev->dev, card); + + ret = com20020_found(dev, IRQF_SHARED); + if (ret) +- goto out_port; ++ goto err_free_arcdev; + + devm_arcnet_led_init(dev, dev->dev_id, i); + + list_add(&card->list, &priv->list_dev); +- } ++ continue; + +- pci_set_drvdata(pdev, priv); +- +- return 0; +- +-out_port: +- com20020pci_remove(pdev); ++err_free_arcdev: ++ free_arcdev(dev); ++ break; ++ } ++ if (ret) ++ com20020pci_remove(pdev); + return ret; + } + +diff --git a/drivers/net/can/usb/Kconfig b/drivers/net/can/usb/Kconfig +index c1e5d5b570b65..538f4d9adb914 100644 +--- a/drivers/net/can/usb/Kconfig ++++ b/drivers/net/can/usb/Kconfig +@@ -73,6 +73,7 @@ config CAN_KVASER_USB + - Kvaser Memorator Pro 5xHS + - Kvaser USBcan Light 4xHS + - Kvaser USBcan Pro 2xHS v2 ++ - Kvaser USBcan Pro 4xHS + - Kvaser USBcan Pro 5xHS + - Kvaser U100 + - Kvaser U100P +diff --git a/drivers/net/can/usb/kvaser_usb/kvaser_usb_core.c b/drivers/net/can/usb/kvaser_usb/kvaser_usb_core.c +index e2d58846c40ca..073c4a39e7182 100644 +--- a/drivers/net/can/usb/kvaser_usb/kvaser_usb_core.c ++++ b/drivers/net/can/usb/kvaser_usb/kvaser_usb_core.c +@@ -86,8 +86,9 @@ + #define USB_U100_PRODUCT_ID 273 + #define USB_U100P_PRODUCT_ID 274 + #define USB_U100S_PRODUCT_ID 275 ++#define USB_USBCAN_PRO_4HS_PRODUCT_ID 276 + #define USB_HYDRA_PRODUCT_ID_END \ +- USB_U100S_PRODUCT_ID ++ USB_USBCAN_PRO_4HS_PRODUCT_ID + + static inline bool kvaser_is_leaf(const struct usb_device_id *id) + { +@@ -193,6 +194,7 @@ static const struct usb_device_id kvaser_usb_table[] = { + { USB_DEVICE(KVASER_VENDOR_ID, USB_U100_PRODUCT_ID) }, + { USB_DEVICE(KVASER_VENDOR_ID, USB_U100P_PRODUCT_ID) }, + { USB_DEVICE(KVASER_VENDOR_ID, USB_U100S_PRODUCT_ID) }, ++ { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_PRO_4HS_PRODUCT_ID) }, + { } + }; + MODULE_DEVICE_TABLE(usb, kvaser_usb_table); +diff --git a/drivers/net/ethernet/marvell/pxa168_eth.c b/drivers/net/ethernet/marvell/pxa168_eth.c +index d1e4d42e497d8..3712e1786091f 100644 +--- a/drivers/net/ethernet/marvell/pxa168_eth.c ++++ b/drivers/net/ethernet/marvell/pxa168_eth.c +@@ -1544,8 +1544,8 @@ static int pxa168_eth_remove(struct platform_device *pdev) + clk_disable_unprepare(pep->clk); + mdiobus_unregister(pep->smi_bus); + mdiobus_free(pep->smi_bus); +- unregister_netdev(dev); + cancel_work_sync(&pep->tx_timeout_task); ++ unregister_netdev(dev); + free_netdev(dev); + return 0; + } +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c +index aaa5a56b44c7c..b6324d11a0086 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c +@@ -2317,8 +2317,9 @@ static u8 mlx5e_build_icosq_log_wq_sz(struct mlx5e_params *params, + { + switch (params->rq_wq_type) { + case MLX5_WQ_TYPE_LINKED_LIST_STRIDING_RQ: +- return order_base_2(MLX5E_UMR_WQEBBS) + +- mlx5e_get_rq_log_wq_sz(rqp->rqc); ++ return max_t(u8, MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE, ++ order_base_2(MLX5E_UMR_WQEBBS) + ++ mlx5e_get_rq_log_wq_sz(rqp->rqc)); + default: /* MLX5_WQ_TYPE_CYCLIC */ + return MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE; + } +diff --git a/drivers/net/ipa/ipa_cmd.c b/drivers/net/ipa/ipa_cmd.c +index eb65a11e33eaf..1ce013a2d6ed0 100644 +--- a/drivers/net/ipa/ipa_cmd.c ++++ b/drivers/net/ipa/ipa_cmd.c +@@ -175,21 +175,23 @@ bool ipa_cmd_table_valid(struct ipa *ipa, const struct ipa_mem *mem, + : field_max(IP_FLTRT_FLAGS_NHASH_ADDR_FMASK); + if (mem->offset > offset_max || + ipa->mem_offset > offset_max - mem->offset) { +- dev_err(dev, "IPv%c %s%s table region offset too large " +- "(0x%04x + 0x%04x > 0x%04x)\n", +- ipv6 ? '6' : '4', hashed ? "hashed " : "", +- route ? "route" : "filter", +- ipa->mem_offset, mem->offset, offset_max); ++ dev_err(dev, "IPv%c %s%s table region offset too large\n", ++ ipv6 ? '6' : '4', hashed ? "hashed " : "", ++ route ? "route" : "filter"); ++ dev_err(dev, " (0x%04x + 0x%04x > 0x%04x)\n", ++ ipa->mem_offset, mem->offset, offset_max); ++ + return false; + } + + if (mem->offset > ipa->mem_size || + mem->size > ipa->mem_size - mem->offset) { +- dev_err(dev, "IPv%c %s%s table region out of range " +- "(0x%04x + 0x%04x > 0x%04x)\n", +- ipv6 ? '6' : '4', hashed ? "hashed " : "", +- route ? "route" : "filter", +- mem->offset, mem->size, ipa->mem_size); ++ dev_err(dev, "IPv%c %s%s table region out of range\n", ++ ipv6 ? '6' : '4', hashed ? "hashed " : "", ++ route ? "route" : "filter"); ++ dev_err(dev, " (0x%04x + 0x%04x > 0x%04x)\n", ++ mem->offset, mem->size, ipa->mem_size); ++ + return false; + } + +@@ -205,22 +207,36 @@ static bool ipa_cmd_header_valid(struct ipa *ipa) + u32 size_max; + u32 size; + ++ /* In ipa_cmd_hdr_init_local_add() we record the offset and size ++ * of the header table memory area. Make sure the offset and size ++ * fit in the fields that need to hold them, and that the entire ++ * range is within the overall IPA memory range. ++ */ + offset_max = field_max(HDR_INIT_LOCAL_FLAGS_HDR_ADDR_FMASK); + if (mem->offset > offset_max || + ipa->mem_offset > offset_max - mem->offset) { +- dev_err(dev, "header table region offset too large " +- "(0x%04x + 0x%04x > 0x%04x)\n", +- ipa->mem_offset + mem->offset, offset_max); ++ dev_err(dev, "header table region offset too large\n"); ++ dev_err(dev, " (0x%04x + 0x%04x > 0x%04x)\n", ++ ipa->mem_offset, mem->offset, offset_max); ++ + return false; + } + + size_max = field_max(HDR_INIT_LOCAL_FLAGS_TABLE_SIZE_FMASK); + size = ipa->mem[IPA_MEM_MODEM_HEADER].size; + size += ipa->mem[IPA_MEM_AP_HEADER].size; +- if (mem->offset > ipa->mem_size || size > ipa->mem_size - mem->offset) { +- dev_err(dev, "header table region out of range " +- "(0x%04x + 0x%04x > 0x%04x)\n", +- mem->offset, size, ipa->mem_size); ++ ++ if (size > size_max) { ++ dev_err(dev, "header table region size too large\n"); ++ dev_err(dev, " (0x%04x > 0x%08x)\n", size, size_max); ++ ++ return false; ++ } ++ if (size > ipa->mem_size || mem->offset > ipa->mem_size - size) { ++ dev_err(dev, "header table region out of range\n"); ++ dev_err(dev, " (0x%04x + 0x%04x > 0x%04x)\n", ++ mem->offset, size, ipa->mem_size); ++ + return false; + } + +diff --git a/drivers/platform/x86/intel-hid.c b/drivers/platform/x86/intel-hid.c +index 2f5b8d09143e3..57cc92891a570 100644 +--- a/drivers/platform/x86/intel-hid.c ++++ b/drivers/platform/x86/intel-hid.c +@@ -90,6 +90,13 @@ static const struct dmi_system_id button_array_table[] = { + DMI_MATCH(DMI_PRODUCT_NAME, "HP Spectre x2 Detachable"), + }, + }, ++ { ++ .ident = "Lenovo ThinkPad X1 Tablet Gen 2", ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), ++ DMI_MATCH(DMI_PRODUCT_FAMILY, "ThinkPad X1 Tablet Gen 2"), ++ }, ++ }, + { } + }; + +diff --git a/drivers/platform/x86/intel_pmc_core.c b/drivers/platform/x86/intel_pmc_core.c +index ee2f757515b0a..b5888aeb4bcff 100644 +--- a/drivers/platform/x86/intel_pmc_core.c ++++ b/drivers/platform/x86/intel_pmc_core.c +@@ -863,34 +863,45 @@ out_unlock: + } + DEFINE_SHOW_ATTRIBUTE(pmc_core_pll); + +-static ssize_t pmc_core_ltr_ignore_write(struct file *file, +- const char __user *userbuf, +- size_t count, loff_t *ppos) ++static int pmc_core_send_ltr_ignore(u32 value) + { + struct pmc_dev *pmcdev = &pmc; + const struct pmc_reg_map *map = pmcdev->map; +- u32 val, buf_size, fd; +- int err; +- +- buf_size = count < 64 ? count : 64; +- +- err = kstrtou32_from_user(userbuf, buf_size, 10, &val); +- if (err) +- return err; ++ u32 reg; ++ int err = 0; + + mutex_lock(&pmcdev->lock); + +- if (val > map->ltr_ignore_max) { ++ if (value > map->ltr_ignore_max) { + err = -EINVAL; + goto out_unlock; + } + +- fd = pmc_core_reg_read(pmcdev, map->ltr_ignore_offset); +- fd |= (1U << val); +- pmc_core_reg_write(pmcdev, map->ltr_ignore_offset, fd); ++ reg = pmc_core_reg_read(pmcdev, map->ltr_ignore_offset); ++ reg |= BIT(value); ++ pmc_core_reg_write(pmcdev, map->ltr_ignore_offset, reg); + + out_unlock: + mutex_unlock(&pmcdev->lock); ++ ++ return err; ++} ++ ++static ssize_t pmc_core_ltr_ignore_write(struct file *file, ++ const char __user *userbuf, ++ size_t count, loff_t *ppos) ++{ ++ u32 buf_size, value; ++ int err; ++ ++ buf_size = min_t(u32, count, 64); ++ ++ err = kstrtou32_from_user(userbuf, buf_size, 10, &value); ++ if (err) ++ return err; ++ ++ err = pmc_core_send_ltr_ignore(value); ++ + return err == 0 ? count : err; + } + +@@ -1244,6 +1255,15 @@ static int pmc_core_probe(struct platform_device *pdev) + pmcdev->pmc_xram_read_bit = pmc_core_check_read_lock_bit(); + dmi_check_system(pmc_core_dmi_table); + ++ /* ++ * On TGL, due to a hardware limitation, the GBE LTR blocks PC10 when ++ * a cable is attached. Tell the PMC to ignore it. ++ */ ++ if (pmcdev->map == &tgl_reg_map) { ++ dev_dbg(&pdev->dev, "ignoring GBE LTR\n"); ++ pmc_core_send_ltr_ignore(3); ++ } ++ + pmc_core_dbgfs_register(pmcdev); + + device_initialized = true; +diff --git a/drivers/platform/x86/intel_pmt_class.c b/drivers/platform/x86/intel_pmt_class.c +index c8939fba45090..ee2b3bbeb83da 100644 +--- a/drivers/platform/x86/intel_pmt_class.c ++++ b/drivers/platform/x86/intel_pmt_class.c +@@ -173,7 +173,7 @@ static int intel_pmt_dev_register(struct intel_pmt_entry *entry, + struct intel_pmt_namespace *ns, + struct device *parent) + { +- struct resource res; ++ struct resource res = {0}; + struct device *dev; + int ret; + +diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c +index f3e8eca8d86d6..9f8da7155a897 100644 +--- a/drivers/platform/x86/thinkpad_acpi.c ++++ b/drivers/platform/x86/thinkpad_acpi.c +@@ -4080,13 +4080,19 @@ static bool hotkey_notify_6xxx(const u32 hkey, + + case TP_HKEY_EV_KEY_NUMLOCK: + case TP_HKEY_EV_KEY_FN: +- case TP_HKEY_EV_KEY_FN_ESC: + /* key press events, we just ignore them as long as the EC + * is still reporting them in the normal keyboard stream */ + *send_acpi_ev = false; + *ignore_acpi_ev = true; + return true; + ++ case TP_HKEY_EV_KEY_FN_ESC: ++ /* Get the media key status to foce the status LED to update */ ++ acpi_evalf(hkey_handle, NULL, "GMKS", "v"); ++ *send_acpi_ev = false; ++ *ignore_acpi_ev = true; ++ return true; ++ + case TP_HKEY_EV_TABLET_CHANGED: + tpacpi_input_send_tabletsw(); + hotkey_tablet_mode_notify_change(); +diff --git a/drivers/ptp/ptp_qoriq.c b/drivers/ptp/ptp_qoriq.c +index beb5f74944cdf..08f4cf0ad9e3c 100644 +--- a/drivers/ptp/ptp_qoriq.c ++++ b/drivers/ptp/ptp_qoriq.c +@@ -189,15 +189,16 @@ int ptp_qoriq_adjfine(struct ptp_clock_info *ptp, long scaled_ppm) + tmr_add = ptp_qoriq->tmr_add; + adj = tmr_add; + +- /* calculate diff as adj*(scaled_ppm/65536)/1000000 +- * and round() to the nearest integer ++ /* ++ * Calculate diff and round() to the nearest integer ++ * ++ * diff = adj * (ppb / 1000000000) ++ * = adj * scaled_ppm / 65536000000 + */ +- adj *= scaled_ppm; +- diff = div_u64(adj, 8000000); +- diff = (diff >> 13) + ((diff >> 12) & 1); ++ diff = mul_u64_u64_div_u64(adj, scaled_ppm, 32768000000); ++ diff = DIV64_U64_ROUND_UP(diff, 2); + + tmr_add = neg_adj ? tmr_add - diff : tmr_add + diff; +- + ptp_qoriq->write(®s->ctrl_regs->tmr_add, tmr_add); + + return 0; +diff --git a/drivers/target/target_core_pscsi.c b/drivers/target/target_core_pscsi.c +index 7994f27e45271..0689d550c37ab 100644 +--- a/drivers/target/target_core_pscsi.c ++++ b/drivers/target/target_core_pscsi.c +@@ -939,6 +939,14 @@ new_bio: + + return 0; + fail: ++ if (bio) ++ bio_put(bio); ++ while (req->bio) { ++ bio = req->bio; ++ req->bio = bio->bi_next; ++ bio_put(bio); ++ } ++ req->biotail = NULL; + return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; + } + +diff --git a/fs/block_dev.c b/fs/block_dev.c +index c33151020bcd7..85500e2400cf6 100644 +--- a/fs/block_dev.c ++++ b/fs/block_dev.c +@@ -1240,13 +1240,13 @@ int bdev_disk_changed(struct block_device *bdev, bool invalidate) + + lockdep_assert_held(&bdev->bd_mutex); + +- clear_bit(GD_NEED_PART_SCAN, &bdev->bd_disk->state); +- + rescan: + ret = blk_drop_partitions(bdev); + if (ret) + return ret; + ++ clear_bit(GD_NEED_PART_SCAN, &disk->state); ++ + /* + * Historically we only set the capacity to zero for devices that + * support partitions (independ of actually having partitions created). +diff --git a/fs/cifs/file.c b/fs/cifs/file.c +index 6d001905c8e51..eef4f22b5e783 100644 +--- a/fs/cifs/file.c ++++ b/fs/cifs/file.c +@@ -165,6 +165,7 @@ int cifs_posix_open(char *full_path, struct inode **pinode, + goto posix_open_ret; + } + } else { ++ cifs_revalidate_mapping(*pinode); + cifs_fattr_to_inode(*pinode, &fattr); + } + +diff --git a/fs/cifs/smb2misc.c b/fs/cifs/smb2misc.c +index d9073b569e174..53fb751bf2108 100644 +--- a/fs/cifs/smb2misc.c ++++ b/fs/cifs/smb2misc.c +@@ -754,8 +754,8 @@ smb2_is_valid_oplock_break(char *buffer, struct TCP_Server_Info *server) + } + } + spin_unlock(&cifs_tcp_ses_lock); +- cifs_dbg(FYI, "Can not process oplock break for non-existent connection\n"); +- return false; ++ cifs_dbg(FYI, "No file id matched, oplock break ignored\n"); ++ return true; + } + + void +diff --git a/fs/io_uring.c b/fs/io_uring.c +index 8b4213de9e085..b1b3154c8d502 100644 +--- a/fs/io_uring.c ++++ b/fs/io_uring.c +@@ -1594,7 +1594,7 @@ static void io_queue_async_work(struct io_kiocb *req) + io_queue_linked_timeout(link); + } + +-static void io_kill_timeout(struct io_kiocb *req) ++static void io_kill_timeout(struct io_kiocb *req, int status) + { + struct io_timeout_data *io = req->async_data; + int ret; +@@ -1604,7 +1604,7 @@ static void io_kill_timeout(struct io_kiocb *req) + atomic_set(&req->ctx->cq_timeouts, + atomic_read(&req->ctx->cq_timeouts) + 1); + list_del_init(&req->timeout.list); +- io_cqring_fill_event(req, 0); ++ io_cqring_fill_event(req, status); + io_put_req_deferred(req, 1); + } + } +@@ -1621,7 +1621,7 @@ static bool io_kill_timeouts(struct io_ring_ctx *ctx, struct task_struct *tsk, + spin_lock_irq(&ctx->completion_lock); + list_for_each_entry_safe(req, tmp, &ctx->timeout_list, timeout.list) { + if (io_match_task(req, tsk, files)) { +- io_kill_timeout(req); ++ io_kill_timeout(req, -ECANCELED); + canceled++; + } + } +@@ -1673,7 +1673,7 @@ static void io_flush_timeouts(struct io_ring_ctx *ctx) + break; + + list_del_init(&req->timeout.list); +- io_kill_timeout(req); ++ io_kill_timeout(req, 0); + } while (!list_empty(&ctx->timeout_list)); + + ctx->cq_last_tm_flush = seq; +diff --git a/init/Kconfig b/init/Kconfig +index b7d3c6a12196f..a3d27421de8f8 100644 +--- a/init/Kconfig ++++ b/init/Kconfig +@@ -113,8 +113,7 @@ config INIT_ENV_ARG_LIMIT + + config COMPILE_TEST + bool "Compile also drivers which will not load" +- depends on !UML && !S390 +- default n ++ depends on HAS_IOMEM + help + Some drivers can be compiled on a different platform than they are + intended to be run on. Despite they cannot be loaded there (or even +diff --git a/lib/math/div64.c b/lib/math/div64.c +index 064d68a5391a0..46866394fc843 100644 +--- a/lib/math/div64.c ++++ b/lib/math/div64.c +@@ -232,4 +232,5 @@ u64 mul_u64_u64_div_u64(u64 a, u64 b, u64 c) + + return res + div64_u64(a * b, c); + } ++EXPORT_SYMBOL(mul_u64_u64_div_u64); + #endif +diff --git a/net/mac80211/aead_api.c b/net/mac80211/aead_api.c +index d7b3d905d5353..b00d6f5b33f40 100644 +--- a/net/mac80211/aead_api.c ++++ b/net/mac80211/aead_api.c +@@ -23,6 +23,7 @@ int aead_encrypt(struct crypto_aead *tfm, u8 *b_0, u8 *aad, size_t aad_len, + struct aead_request *aead_req; + int reqsize = sizeof(*aead_req) + crypto_aead_reqsize(tfm); + u8 *__aad; ++ int ret; + + aead_req = kzalloc(reqsize + aad_len, GFP_ATOMIC); + if (!aead_req) +@@ -40,10 +41,10 @@ int aead_encrypt(struct crypto_aead *tfm, u8 *b_0, u8 *aad, size_t aad_len, + aead_request_set_crypt(aead_req, sg, sg, data_len, b_0); + aead_request_set_ad(aead_req, sg[0].length); + +- crypto_aead_encrypt(aead_req); ++ ret = crypto_aead_encrypt(aead_req); + kfree_sensitive(aead_req); + +- return 0; ++ return ret; + } + + int aead_decrypt(struct crypto_aead *tfm, u8 *b_0, u8 *aad, size_t aad_len, +diff --git a/net/mac80211/aes_gmac.c b/net/mac80211/aes_gmac.c +index 6f3b3a0cc10a4..512cab073f2e8 100644 +--- a/net/mac80211/aes_gmac.c ++++ b/net/mac80211/aes_gmac.c +@@ -22,6 +22,7 @@ int ieee80211_aes_gmac(struct crypto_aead *tfm, const u8 *aad, u8 *nonce, + struct aead_request *aead_req; + int reqsize = sizeof(*aead_req) + crypto_aead_reqsize(tfm); + const __le16 *fc; ++ int ret; + + if (data_len < GMAC_MIC_LEN) + return -EINVAL; +@@ -59,10 +60,10 @@ int ieee80211_aes_gmac(struct crypto_aead *tfm, const u8 *aad, u8 *nonce, + aead_request_set_crypt(aead_req, sg, sg, 0, iv); + aead_request_set_ad(aead_req, GMAC_AAD_LEN + data_len); + +- crypto_aead_encrypt(aead_req); ++ ret = crypto_aead_encrypt(aead_req); + kfree_sensitive(aead_req); + +- return 0; ++ return ret; + } + + struct crypto_aead *ieee80211_aes_gmac_key_setup(const u8 key[], +diff --git a/net/mac80211/main.c b/net/mac80211/main.c +index dee88ec566ad1..d1023188ef373 100644 +--- a/net/mac80211/main.c ++++ b/net/mac80211/main.c +@@ -970,8 +970,19 @@ int ieee80211_register_hw(struct ieee80211_hw *hw) + continue; + + if (!dflt_chandef.chan) { ++ /* ++ * Assign the first enabled channel to dflt_chandef ++ * from the list of channels ++ */ ++ for (i = 0; i < sband->n_channels; i++) ++ if (!(sband->channels[i].flags & ++ IEEE80211_CHAN_DISABLED)) ++ break; ++ /* if none found then use the first anyway */ ++ if (i == sband->n_channels) ++ i = 0; + cfg80211_chandef_create(&dflt_chandef, +- &sband->channels[0], ++ &sband->channels[i], + NL80211_CHAN_NO_HT); + /* init channel we're on */ + if (!local->use_chanctx && !local->_oper_chandef.chan) { +diff --git a/net/netfilter/nf_conntrack_proto_gre.c b/net/netfilter/nf_conntrack_proto_gre.c +index 5b05487a60d21..db11e403d8187 100644 +--- a/net/netfilter/nf_conntrack_proto_gre.c ++++ b/net/netfilter/nf_conntrack_proto_gre.c +@@ -218,9 +218,6 @@ int nf_conntrack_gre_packet(struct nf_conn *ct, + enum ip_conntrack_info ctinfo, + const struct nf_hook_state *state) + { +- if (state->pf != NFPROTO_IPV4) +- return -NF_ACCEPT; +- + if (!nf_ct_is_confirmed(ct)) { + unsigned int *timeouts = nf_ct_timeout_lookup(ct); + +diff --git a/net/netfilter/nf_tables_api.c b/net/netfilter/nf_tables_api.c +index 24a7a6b17268c..93d4bb39afb3c 100644 +--- a/net/netfilter/nf_tables_api.c ++++ b/net/netfilter/nf_tables_api.c +@@ -6749,6 +6749,9 @@ static int nft_register_flowtable_net_hooks(struct net *net, + + list_for_each_entry(hook, hook_list, list) { + list_for_each_entry(ft, &table->flowtables, list) { ++ if (!nft_is_active_next(net, ft)) ++ continue; ++ + list_for_each_entry(hook2, &ft->hook_list, list) { + if (hook->ops.dev == hook2->ops.dev && + hook->ops.pf == hook2->ops.pf) { +diff --git a/tools/bpf/resolve_btfids/.gitignore b/tools/bpf/resolve_btfids/.gitignore +index a026df7dc2809..16913fffc9859 100644 +--- a/tools/bpf/resolve_btfids/.gitignore ++++ b/tools/bpf/resolve_btfids/.gitignore +@@ -1,4 +1,3 @@ +-/FEATURE-DUMP.libbpf +-/bpf_helper_defs.h + /fixdep + /resolve_btfids ++/libbpf/ +diff --git a/tools/bpf/resolve_btfids/Makefile b/tools/bpf/resolve_btfids/Makefile +index bf656432ad736..bb9fa8de7e625 100644 +--- a/tools/bpf/resolve_btfids/Makefile ++++ b/tools/bpf/resolve_btfids/Makefile +@@ -2,11 +2,7 @@ + include ../../scripts/Makefile.include + include ../../scripts/Makefile.arch + +-ifeq ($(srctree),) +-srctree := $(patsubst %/,%,$(dir $(CURDIR))) +-srctree := $(patsubst %/,%,$(dir $(srctree))) +-srctree := $(patsubst %/,%,$(dir $(srctree))) +-endif ++srctree := $(abspath $(CURDIR)/../../../) + + ifeq ($(V),1) + Q = +@@ -22,28 +18,29 @@ AR = $(HOSTAR) + CC = $(HOSTCC) + LD = $(HOSTLD) + ARCH = $(HOSTARCH) ++RM ?= rm + + OUTPUT ?= $(srctree)/tools/bpf/resolve_btfids/ + + LIBBPF_SRC := $(srctree)/tools/lib/bpf/ + SUBCMD_SRC := $(srctree)/tools/lib/subcmd/ + +-BPFOBJ := $(OUTPUT)/libbpf.a +-SUBCMDOBJ := $(OUTPUT)/libsubcmd.a ++BPFOBJ := $(OUTPUT)/libbpf/libbpf.a ++SUBCMDOBJ := $(OUTPUT)/libsubcmd/libsubcmd.a + + BINARY := $(OUTPUT)/resolve_btfids + BINARY_IN := $(BINARY)-in.o + + all: $(BINARY) + +-$(OUTPUT): ++$(OUTPUT) $(OUTPUT)/libbpf $(OUTPUT)/libsubcmd: + $(call msg,MKDIR,,$@) +- $(Q)mkdir -p $(OUTPUT) ++ $(Q)mkdir -p $(@) + +-$(SUBCMDOBJ): fixdep FORCE +- $(Q)$(MAKE) -C $(SUBCMD_SRC) OUTPUT=$(OUTPUT) ++$(SUBCMDOBJ): fixdep FORCE | $(OUTPUT)/libsubcmd ++ $(Q)$(MAKE) -C $(SUBCMD_SRC) OUTPUT=$(abspath $(dir $@))/ $(abspath $@) + +-$(BPFOBJ): $(wildcard $(LIBBPF_SRC)/*.[ch] $(LIBBPF_SRC)/Makefile) | $(OUTPUT) ++$(BPFOBJ): $(wildcard $(LIBBPF_SRC)/*.[ch] $(LIBBPF_SRC)/Makefile) | $(OUTPUT)/libbpf + $(Q)$(MAKE) $(submake_extras) -C $(LIBBPF_SRC) OUTPUT=$(abspath $(dir $@))/ $(abspath $@) + + CFLAGS := -g \ +@@ -57,24 +54,27 @@ LIBS = -lelf -lz + export srctree OUTPUT CFLAGS Q + include $(srctree)/tools/build/Makefile.include + +-$(BINARY_IN): fixdep FORCE ++$(BINARY_IN): fixdep FORCE | $(OUTPUT) + $(Q)$(MAKE) $(build)=resolve_btfids + + $(BINARY): $(BPFOBJ) $(SUBCMDOBJ) $(BINARY_IN) + $(call msg,LINK,$@) + $(Q)$(CC) $(BINARY_IN) $(LDFLAGS) -o $@ $(BPFOBJ) $(SUBCMDOBJ) $(LIBS) + +-libsubcmd-clean: +- $(Q)$(MAKE) -C $(SUBCMD_SRC) OUTPUT=$(OUTPUT) clean +- +-libbpf-clean: +- $(Q)$(MAKE) -C $(LIBBPF_SRC) OUTPUT=$(OUTPUT) clean ++clean_objects := $(wildcard $(OUTPUT)/*.o \ ++ $(OUTPUT)/.*.o.cmd \ ++ $(OUTPUT)/.*.o.d \ ++ $(OUTPUT)/libbpf \ ++ $(OUTPUT)/libsubcmd \ ++ $(OUTPUT)/resolve_btfids) + +-clean: libsubcmd-clean libbpf-clean fixdep-clean ++ifneq ($(clean_objects),) ++clean: fixdep-clean + $(call msg,CLEAN,$(BINARY)) +- $(Q)$(RM) -f $(BINARY); \ +- $(RM) -rf $(if $(OUTPUT),$(OUTPUT),.)/feature; \ +- find $(if $(OUTPUT),$(OUTPUT),.) -name \*.o -or -name \*.o.cmd -or -name \*.o.d | xargs $(RM) ++ $(Q)$(RM) -rf $(clean_objects) ++else ++clean: ++endif + + tags: + $(call msg,GEN,,tags) +diff --git a/tools/testing/kunit/kunit_config.py b/tools/testing/kunit/kunit_config.py +index bdd60230764b0..27fe086d2d0d1 100644 +--- a/tools/testing/kunit/kunit_config.py ++++ b/tools/testing/kunit/kunit_config.py +@@ -13,7 +13,7 @@ from typing import List, Set + CONFIG_IS_NOT_SET_PATTERN = r'^# CONFIG_(\w+) is not set$' + CONFIG_PATTERN = r'^CONFIG_(\w+)=(\S+|".*")$' + +-KconfigEntryBase = collections.namedtuple('KconfigEntry', ['name', 'value']) ++KconfigEntryBase = collections.namedtuple('KconfigEntryBase', ['name', 'value']) + + class KconfigEntry(KconfigEntryBase): + +diff --git a/tools/testing/selftests/arm64/fp/sve-test.S b/tools/testing/selftests/arm64/fp/sve-test.S +index 9210691aa9985..e3e08d9c7020e 100644 +--- a/tools/testing/selftests/arm64/fp/sve-test.S ++++ b/tools/testing/selftests/arm64/fp/sve-test.S +@@ -284,16 +284,28 @@ endfunction + // Set up test pattern in the FFR + // x0: pid + // x2: generation ++// ++// We need to generate a canonical FFR value, which consists of a number of ++// low "1" bits, followed by a number of zeros. This gives us 17 unique values ++// per 16 bits of FFR, so we create a 4 bit signature out of the PID and ++// generation, and use that as the initial number of ones in the pattern. ++// We fill the upper lanes of FFR with zeros. + // Beware: corrupts P0. + function setup_ffr + mov x4, x30 + +- bl pattern ++ and w0, w0, #0x3 ++ bfi w0, w2, #2, #2 ++ mov w1, #1 ++ lsl w1, w1, w0 ++ sub w1, w1, #1 ++ + ldr x0, =ffrref +- ldr x1, =scratch +- rdvl x2, #1 +- lsr x2, x2, #3 +- bl memcpy ++ strh w1, [x0], 2 ++ rdvl x1, #1 ++ lsr x1, x1, #3 ++ sub x1, x1, #2 ++ bl memclr + + mov x0, #0 + ldr x1, =ffrref +diff --git a/tools/testing/selftests/vm/Makefile b/tools/testing/selftests/vm/Makefile +index d42115e4284d7..8b0cd421ebd38 100644 +--- a/tools/testing/selftests/vm/Makefile ++++ b/tools/testing/selftests/vm/Makefile +@@ -101,7 +101,7 @@ endef + ifeq ($(CAN_BUILD_I386),1) + $(BINARIES_32): CFLAGS += -m32 + $(BINARIES_32): LDLIBS += -lrt -ldl -lm +-$(BINARIES_32): %_32: %.c ++$(BINARIES_32): $(OUTPUT)/%_32: %.c + $(CC) $(CFLAGS) $(EXTRA_CFLAGS) $(notdir $^) $(LDLIBS) -o $@ + $(foreach t,$(TARGETS),$(eval $(call gen-target-rule-32,$(t)))) + endif +@@ -109,7 +109,7 @@ endif + ifeq ($(CAN_BUILD_X86_64),1) + $(BINARIES_64): CFLAGS += -m64 + $(BINARIES_64): LDLIBS += -lrt -ldl +-$(BINARIES_64): %_64: %.c ++$(BINARIES_64): $(OUTPUT)/%_64: %.c + $(CC) $(CFLAGS) $(EXTRA_CFLAGS) $(notdir $^) $(LDLIBS) -o $@ + $(foreach t,$(TARGETS),$(eval $(call gen-target-rule-64,$(t)))) + endif
