From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from lists.gentoo.org (pigeon.gentoo.org [208.92.234.80]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id C00D81382C5 for ; Wed, 27 May 2020 16:32:31 +0000 (UTC) Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id EA400E09C0; Wed, 27 May 2020 16:32:30 +0000 (UTC) Received: from smtp.gentoo.org (smtp.gentoo.org [140.211.166.183]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by pigeon.gentoo.org (Postfix) with ESMTPS id A9296E09C0 for ; Wed, 27 May 2020 16:32:30 +0000 (UTC) Received: from oystercatcher.gentoo.org (unknown [IPv6:2a01:4f8:202:4333:225:90ff:fed9:fc84]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id E0BF734E5C3 for ; Wed, 27 May 2020 16:32:28 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 9DB3F9C for ; Wed, 27 May 2020 16:32:27 +0000 (UTC) From: "Mike Pagano" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Mike Pagano" Message-ID: <1590597136.4d328115ad37428d4e514eb35f786e11283b745d.mpagano@gentoo> Subject: [gentoo-commits] proj/linux-patches:5.6 commit in: / X-VCS-Repository: proj/linux-patches X-VCS-Files: 0000_README 1014_linux-5.6.15.patch X-VCS-Directories: / X-VCS-Committer: mpagano X-VCS-Committer-Name: Mike Pagano X-VCS-Revision: 4d328115ad37428d4e514eb35f786e11283b745d X-VCS-Branch: 5.6 Date: Wed, 27 May 2020 16:32:27 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: 4779972c-9e88-412c-8cdb-6d88641b1d98 X-Archives-Hash: e82f59a113b1b71f63df8c847ce3fac1 commit: 4d328115ad37428d4e514eb35f786e11283b745d Author: Mike Pagano gentoo org> AuthorDate: Wed May 27 16:32:16 2020 +0000 Commit: Mike Pagano gentoo org> CommitDate: Wed May 27 16:32:16 2020 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=4d328115 Linux patch 5.6.15 Signed-off-by: Mike Pagano gentoo.org> 0000_README | 4 +- 1014_linux-5.6.15.patch | 4946 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 4948 insertions(+), 2 deletions(-) diff --git a/0000_README b/0000_README index 50aaa31..1c0ea04 100644 --- a/0000_README +++ b/0000_README @@ -99,9 +99,9 @@ Patch: 1013_linux-5.6.14.patch From: http://www.kernel.org Desc: Linux 5.6.14 -Patch: 1013_linux-5.6.14.patch +Patch: 1014_linux-5.6.15.patch From: http://www.kernel.org -Desc: Linux 5.6.14 +Desc: Linux 5.6.15 Patch: 1500_XATTR_USER_PREFIX.patch From: https://bugs.gentoo.org/show_bug.cgi?id=470644 diff --git a/1014_linux-5.6.15.patch b/1014_linux-5.6.15.patch new file mode 100644 index 0000000..a62c0e3 --- /dev/null +++ b/1014_linux-5.6.15.patch @@ -0,0 +1,4946 @@ +diff --git a/Makefile b/Makefile +index 713f93cceffe..3eca0c523098 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 6 +-SUBLEVEL = 14 ++SUBLEVEL = 15 + EXTRAVERSION = + NAME = Kleptomaniac Octopus + +@@ -1248,11 +1248,15 @@ ifneq ($(dtstree),) + $(Q)$(MAKE) $(build)=$(dtstree) $(dtstree)/$@ + + PHONY += dtbs dtbs_install dtbs_check +-dtbs dtbs_check: include/config/kernel.release scripts_dtc ++dtbs: include/config/kernel.release scripts_dtc + $(Q)$(MAKE) $(build)=$(dtstree) + ++ifneq ($(filter dtbs_check, $(MAKECMDGOALS)),) ++dtbs: dt_binding_check ++endif ++ + dtbs_check: export CHECK_DTBS=1 +-dtbs_check: dt_binding_check ++dtbs_check: dtbs + + dtbs_install: + $(Q)$(MAKE) $(dtbinst)=$(dtstree) +diff --git a/arch/arc/configs/hsdk_defconfig b/arch/arc/configs/hsdk_defconfig +index 0974226fab55..aa000075a575 100644 +--- a/arch/arc/configs/hsdk_defconfig ++++ b/arch/arc/configs/hsdk_defconfig +@@ -65,6 +65,7 @@ CONFIG_DRM_UDL=y + CONFIG_DRM_ETNAVIV=y + CONFIG_FB=y + CONFIG_FRAMEBUFFER_CONSOLE=y ++CONFIG_USB=y + CONFIG_USB_EHCI_HCD=y + CONFIG_USB_EHCI_HCD_PLATFORM=y + CONFIG_USB_OHCI_HCD=y +diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig +index 97864aabc2a6..579f7eb6968a 100644 +--- a/arch/arm/Kconfig ++++ b/arch/arm/Kconfig +@@ -13,6 +13,7 @@ config ARM + select ARCH_HAS_KEEPINITRD + select ARCH_HAS_KCOV + select ARCH_HAS_MEMBARRIER_SYNC_CORE ++ select ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE + select ARCH_HAS_PTE_SPECIAL if ARM_LPAE + select ARCH_HAS_PHYS_TO_DMA + select ARCH_HAS_SETUP_DMA_OPS +diff --git a/arch/arm/include/asm/futex.h b/arch/arm/include/asm/futex.h +index 83c391b597d4..fdc4ae3e7378 100644 +--- a/arch/arm/include/asm/futex.h ++++ b/arch/arm/include/asm/futex.h +@@ -164,8 +164,13 @@ arch_futex_atomic_op_inuser(int op, int oparg, int *oval, u32 __user *uaddr) + preempt_enable(); + #endif + +- if (!ret) +- *oval = oldval; ++ /* ++ * Store unconditionally. If ret != 0 the extra store is the least ++ * of the worries but GCC cannot figure out that __futex_atomic_op() ++ * is either setting ret to -EFAULT or storing the old value in ++ * oldval which results in a uninitialized warning at the call site. ++ */ ++ *oval = oldval; + + return ret; + } +diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig +index 0b30e884e088..84e1f0a43cdb 100644 +--- a/arch/arm64/Kconfig ++++ b/arch/arm64/Kconfig +@@ -21,6 +21,7 @@ config ARM64 + select ARCH_HAS_KCOV + select ARCH_HAS_KEEPINITRD + select ARCH_HAS_MEMBARRIER_SYNC_CORE ++ select ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE + select ARCH_HAS_PTE_DEVMAP + select ARCH_HAS_PTE_SPECIAL + select ARCH_HAS_SETUP_DMA_OPS +diff --git a/arch/arm64/kernel/ptrace.c b/arch/arm64/kernel/ptrace.c +index cd6e5fa48b9c..c30f77bd875f 100644 +--- a/arch/arm64/kernel/ptrace.c ++++ b/arch/arm64/kernel/ptrace.c +@@ -1829,10 +1829,11 @@ static void tracehook_report_syscall(struct pt_regs *regs, + + int syscall_trace_enter(struct pt_regs *regs) + { +- if (test_thread_flag(TIF_SYSCALL_TRACE) || +- test_thread_flag(TIF_SYSCALL_EMU)) { ++ unsigned long flags = READ_ONCE(current_thread_info()->flags); ++ ++ if (flags & (_TIF_SYSCALL_EMU | _TIF_SYSCALL_TRACE)) { + tracehook_report_syscall(regs, PTRACE_SYSCALL_ENTER); +- if (!in_syscall(regs) || test_thread_flag(TIF_SYSCALL_EMU)) ++ if (!in_syscall(regs) || (flags & _TIF_SYSCALL_EMU)) + return -1; + } + +diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig +index 497b7d0b2d7e..b0fb42b0bf4b 100644 +--- a/arch/powerpc/Kconfig ++++ b/arch/powerpc/Kconfig +@@ -129,7 +129,7 @@ config PPC + select ARCH_HAS_PTE_SPECIAL + select ARCH_HAS_MEMBARRIER_CALLBACKS + select ARCH_HAS_SCALED_CPUTIME if VIRT_CPU_ACCOUNTING_NATIVE && PPC_BOOK3S_64 +- select ARCH_HAS_STRICT_KERNEL_RWX if ((PPC_BOOK3S_64 || PPC32) && !HIBERNATION) ++ select ARCH_HAS_STRICT_KERNEL_RWX if (PPC32 && !HIBERNATION) + select ARCH_HAS_TICK_BROADCAST if GENERIC_CLOCKEVENTS_BROADCAST + select ARCH_HAS_UACCESS_FLUSHCACHE + select ARCH_HAS_UACCESS_MCSAFE if PPC64 +diff --git a/arch/s390/include/asm/pci_io.h b/arch/s390/include/asm/pci_io.h +index cd060b5dd8fd..e4dc64cc9c55 100644 +--- a/arch/s390/include/asm/pci_io.h ++++ b/arch/s390/include/asm/pci_io.h +@@ -8,6 +8,10 @@ + #include + #include + ++/* I/O size constraints */ ++#define ZPCI_MAX_READ_SIZE 8 ++#define ZPCI_MAX_WRITE_SIZE 128 ++ + /* I/O Map */ + #define ZPCI_IOMAP_SHIFT 48 + #define ZPCI_IOMAP_ADDR_BASE 0x8000000000000000UL +@@ -140,7 +144,8 @@ static inline int zpci_memcpy_fromio(void *dst, + + while (n > 0) { + size = zpci_get_max_write_size((u64 __force) src, +- (u64) dst, n, 8); ++ (u64) dst, n, ++ ZPCI_MAX_READ_SIZE); + rc = zpci_read_single(dst, src, size); + if (rc) + break; +@@ -161,7 +166,8 @@ static inline int zpci_memcpy_toio(volatile void __iomem *dst, + + while (n > 0) { + size = zpci_get_max_write_size((u64 __force) dst, +- (u64) src, n, 128); ++ (u64) src, n, ++ ZPCI_MAX_WRITE_SIZE); + if (size > 8) /* main path */ + rc = zpci_write_block(dst, src, size); + else +diff --git a/arch/s390/kernel/machine_kexec_file.c b/arch/s390/kernel/machine_kexec_file.c +index 8415ae7d2a23..f9e4baa64b67 100644 +--- a/arch/s390/kernel/machine_kexec_file.c ++++ b/arch/s390/kernel/machine_kexec_file.c +@@ -151,7 +151,7 @@ static int kexec_file_add_initrd(struct kimage *image, + buf.mem += crashk_res.start; + buf.memsz = buf.bufsz; + +- data->parm->initrd_start = buf.mem; ++ data->parm->initrd_start = data->memsz; + data->parm->initrd_size = buf.memsz; + data->memsz += buf.memsz; + +diff --git a/arch/s390/kernel/machine_kexec_reloc.c b/arch/s390/kernel/machine_kexec_reloc.c +index d5035de9020e..b7182cec48dc 100644 +--- a/arch/s390/kernel/machine_kexec_reloc.c ++++ b/arch/s390/kernel/machine_kexec_reloc.c +@@ -28,6 +28,7 @@ int arch_kexec_do_relocs(int r_type, void *loc, unsigned long val, + break; + case R_390_64: /* Direct 64 bit. */ + case R_390_GLOB_DAT: ++ case R_390_JMP_SLOT: + *(u64 *)loc = val; + break; + case R_390_PC16: /* PC relative 16 bit. */ +diff --git a/arch/s390/pci/pci_mmio.c b/arch/s390/pci/pci_mmio.c +index 7d42a8794f10..020a2c514d96 100644 +--- a/arch/s390/pci/pci_mmio.c ++++ b/arch/s390/pci/pci_mmio.c +@@ -11,6 +11,113 @@ + #include + #include + #include ++#include ++#include ++ ++static inline void zpci_err_mmio(u8 cc, u8 status, u64 offset) ++{ ++ struct { ++ u64 offset; ++ u8 cc; ++ u8 status; ++ } data = {offset, cc, status}; ++ ++ zpci_err_hex(&data, sizeof(data)); ++} ++ ++static inline int __pcistb_mio_inuser( ++ void __iomem *ioaddr, const void __user *src, ++ u64 len, u8 *status) ++{ ++ int cc = -ENXIO; ++ ++ asm volatile ( ++ " sacf 256\n" ++ "0: .insn rsy,0xeb00000000d4,%[len],%[ioaddr],%[src]\n" ++ "1: ipm %[cc]\n" ++ " srl %[cc],28\n" ++ "2: sacf 768\n" ++ EX_TABLE(0b, 2b) EX_TABLE(1b, 2b) ++ : [cc] "+d" (cc), [len] "+d" (len) ++ : [ioaddr] "a" (ioaddr), [src] "Q" (*((u8 __force *)src)) ++ : "cc", "memory"); ++ *status = len >> 24 & 0xff; ++ return cc; ++} ++ ++static inline int __pcistg_mio_inuser( ++ void __iomem *ioaddr, const void __user *src, ++ u64 ulen, u8 *status) ++{ ++ register u64 addr asm("2") = (u64 __force) ioaddr; ++ register u64 len asm("3") = ulen; ++ int cc = -ENXIO; ++ u64 val = 0; ++ u64 cnt = ulen; ++ u8 tmp; ++ ++ /* ++ * copy 0 < @len <= 8 bytes from @src into the right most bytes of ++ * a register, then store it to PCI at @ioaddr while in secondary ++ * address space. pcistg then uses the user mappings. ++ */ ++ asm volatile ( ++ " sacf 256\n" ++ "0: llgc %[tmp],0(%[src])\n" ++ " sllg %[val],%[val],8\n" ++ " aghi %[src],1\n" ++ " ogr %[val],%[tmp]\n" ++ " brctg %[cnt],0b\n" ++ "1: .insn rre,0xb9d40000,%[val],%[ioaddr]\n" ++ "2: ipm %[cc]\n" ++ " srl %[cc],28\n" ++ "3: sacf 768\n" ++ EX_TABLE(0b, 3b) EX_TABLE(1b, 3b) EX_TABLE(2b, 3b) ++ : ++ [src] "+a" (src), [cnt] "+d" (cnt), ++ [val] "+d" (val), [tmp] "=d" (tmp), ++ [len] "+d" (len), [cc] "+d" (cc), ++ [ioaddr] "+a" (addr) ++ :: "cc", "memory"); ++ *status = len >> 24 & 0xff; ++ ++ /* did we read everything from user memory? */ ++ if (!cc && cnt != 0) ++ cc = -EFAULT; ++ ++ return cc; ++} ++ ++static inline int __memcpy_toio_inuser(void __iomem *dst, ++ const void __user *src, size_t n) ++{ ++ int size, rc = 0; ++ u8 status = 0; ++ mm_segment_t old_fs; ++ ++ if (!src) ++ return -EINVAL; ++ ++ old_fs = enable_sacf_uaccess(); ++ while (n > 0) { ++ size = zpci_get_max_write_size((u64 __force) dst, ++ (u64 __force) src, n, ++ ZPCI_MAX_WRITE_SIZE); ++ if (size > 8) /* main path */ ++ rc = __pcistb_mio_inuser(dst, src, size, &status); ++ else ++ rc = __pcistg_mio_inuser(dst, src, size, &status); ++ if (rc) ++ break; ++ src += size; ++ dst += size; ++ n -= size; ++ } ++ disable_sacf_uaccess(old_fs); ++ if (rc) ++ zpci_err_mmio(rc, status, (__force u64) dst); ++ return rc; ++} + + static long get_pfn(unsigned long user_addr, unsigned long access, + unsigned long *pfn) +@@ -46,6 +153,20 @@ SYSCALL_DEFINE3(s390_pci_mmio_write, unsigned long, mmio_addr, + + if (length <= 0 || PAGE_SIZE - (mmio_addr & ~PAGE_MASK) < length) + return -EINVAL; ++ ++ /* ++ * Only support read access to MIO capable devices on a MIO enabled ++ * system. Otherwise we would have to check for every address if it is ++ * a special ZPCI_ADDR and we would have to do a get_pfn() which we ++ * don't need for MIO capable devices. ++ */ ++ if (static_branch_likely(&have_mio)) { ++ ret = __memcpy_toio_inuser((void __iomem *) mmio_addr, ++ user_buffer, ++ length); ++ return ret; ++ } ++ + if (length > 64) { + buf = kmalloc(length, GFP_KERNEL); + if (!buf) +@@ -56,7 +177,8 @@ SYSCALL_DEFINE3(s390_pci_mmio_write, unsigned long, mmio_addr, + ret = get_pfn(mmio_addr, VM_WRITE, &pfn); + if (ret) + goto out; +- io_addr = (void __iomem *)((pfn << PAGE_SHIFT) | (mmio_addr & ~PAGE_MASK)); ++ io_addr = (void __iomem *)((pfn << PAGE_SHIFT) | ++ (mmio_addr & ~PAGE_MASK)); + + ret = -EFAULT; + if ((unsigned long) io_addr < ZPCI_IOMAP_ADDR_BASE) +@@ -72,6 +194,78 @@ out: + return ret; + } + ++static inline int __pcilg_mio_inuser( ++ void __user *dst, const void __iomem *ioaddr, ++ u64 ulen, u8 *status) ++{ ++ register u64 addr asm("2") = (u64 __force) ioaddr; ++ register u64 len asm("3") = ulen; ++ u64 cnt = ulen; ++ int shift = ulen * 8; ++ int cc = -ENXIO; ++ u64 val, tmp; ++ ++ /* ++ * read 0 < @len <= 8 bytes from the PCI memory mapped at @ioaddr (in ++ * user space) into a register using pcilg then store these bytes at ++ * user address @dst ++ */ ++ asm volatile ( ++ " sacf 256\n" ++ "0: .insn rre,0xb9d60000,%[val],%[ioaddr]\n" ++ "1: ipm %[cc]\n" ++ " srl %[cc],28\n" ++ " ltr %[cc],%[cc]\n" ++ " jne 4f\n" ++ "2: ahi %[shift],-8\n" ++ " srlg %[tmp],%[val],0(%[shift])\n" ++ "3: stc %[tmp],0(%[dst])\n" ++ " aghi %[dst],1\n" ++ " brctg %[cnt],2b\n" ++ "4: sacf 768\n" ++ EX_TABLE(0b, 4b) EX_TABLE(1b, 4b) EX_TABLE(3b, 4b) ++ : ++ [cc] "+d" (cc), [val] "=d" (val), [len] "+d" (len), ++ [dst] "+a" (dst), [cnt] "+d" (cnt), [tmp] "=d" (tmp), ++ [shift] "+d" (shift) ++ : ++ [ioaddr] "a" (addr) ++ : "cc", "memory"); ++ ++ /* did we write everything to the user space buffer? */ ++ if (!cc && cnt != 0) ++ cc = -EFAULT; ++ ++ *status = len >> 24 & 0xff; ++ return cc; ++} ++ ++static inline int __memcpy_fromio_inuser(void __user *dst, ++ const void __iomem *src, ++ unsigned long n) ++{ ++ int size, rc = 0; ++ u8 status; ++ mm_segment_t old_fs; ++ ++ old_fs = enable_sacf_uaccess(); ++ while (n > 0) { ++ size = zpci_get_max_write_size((u64 __force) src, ++ (u64 __force) dst, n, ++ ZPCI_MAX_READ_SIZE); ++ rc = __pcilg_mio_inuser(dst, src, size, &status); ++ if (rc) ++ break; ++ src += size; ++ dst += size; ++ n -= size; ++ } ++ disable_sacf_uaccess(old_fs); ++ if (rc) ++ zpci_err_mmio(rc, status, (__force u64) dst); ++ return rc; ++} ++ + SYSCALL_DEFINE3(s390_pci_mmio_read, unsigned long, mmio_addr, + void __user *, user_buffer, size_t, length) + { +@@ -86,12 +280,27 @@ SYSCALL_DEFINE3(s390_pci_mmio_read, unsigned long, mmio_addr, + + if (length <= 0 || PAGE_SIZE - (mmio_addr & ~PAGE_MASK) < length) + return -EINVAL; ++ ++ /* ++ * Only support write access to MIO capable devices on a MIO enabled ++ * system. Otherwise we would have to check for every address if it is ++ * a special ZPCI_ADDR and we would have to do a get_pfn() which we ++ * don't need for MIO capable devices. ++ */ ++ if (static_branch_likely(&have_mio)) { ++ ret = __memcpy_fromio_inuser( ++ user_buffer, (const void __iomem *)mmio_addr, ++ length); ++ return ret; ++ } ++ + if (length > 64) { + buf = kmalloc(length, GFP_KERNEL); + if (!buf) + return -ENOMEM; +- } else ++ } else { + buf = local_buf; ++ } + + ret = get_pfn(mmio_addr, VM_READ, &pfn); + if (ret) +diff --git a/arch/sh/include/uapi/asm/sockios.h b/arch/sh/include/uapi/asm/sockios.h +index 3da561453260..ef01ced9e169 100644 +--- a/arch/sh/include/uapi/asm/sockios.h ++++ b/arch/sh/include/uapi/asm/sockios.h +@@ -2,6 +2,8 @@ + #ifndef __ASM_SH_SOCKIOS_H + #define __ASM_SH_SOCKIOS_H + ++#include ++ + /* Socket-level I/O control calls. */ + #define FIOGETOWN _IOR('f', 123, int) + #define FIOSETOWN _IOW('f', 124, int) +diff --git a/arch/sparc/mm/srmmu.c b/arch/sparc/mm/srmmu.c +index f56c3c9a9793..80061bc93bdc 100644 +--- a/arch/sparc/mm/srmmu.c ++++ b/arch/sparc/mm/srmmu.c +@@ -331,9 +331,9 @@ static void __init srmmu_nocache_init(void) + + while (vaddr < srmmu_nocache_end) { + pgd = pgd_offset_k(vaddr); +- p4d = p4d_offset(__nocache_fix(pgd), vaddr); +- pud = pud_offset(__nocache_fix(p4d), vaddr); +- pmd = pmd_offset(__nocache_fix(pgd), vaddr); ++ p4d = p4d_offset(pgd, vaddr); ++ pud = pud_offset(p4d, vaddr); ++ pmd = pmd_offset(__nocache_fix(pud), vaddr); + pte = pte_offset_kernel(__nocache_fix(pmd), vaddr); + + pteval = ((paddr >> 4) | SRMMU_ET_PTE | SRMMU_PRIV); +diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig +index beea77046f9b..0bc9a74468be 100644 +--- a/arch/x86/Kconfig ++++ b/arch/x86/Kconfig +@@ -70,6 +70,7 @@ config X86 + select ARCH_HAS_KCOV if X86_64 + select ARCH_HAS_MEM_ENCRYPT + select ARCH_HAS_MEMBARRIER_SYNC_CORE ++ select ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE + select ARCH_HAS_PMEM_API if X86_64 + select ARCH_HAS_PTE_DEVMAP if X86_64 + select ARCH_HAS_PTE_SPECIAL +diff --git a/arch/x86/kernel/apic/apic.c b/arch/x86/kernel/apic/apic.c +index 5f973fed3c9f..e289722b04f6 100644 +--- a/arch/x86/kernel/apic/apic.c ++++ b/arch/x86/kernel/apic/apic.c +@@ -352,8 +352,6 @@ static void __setup_APIC_LVTT(unsigned int clocks, int oneshot, int irqen) + * According to Intel, MFENCE can do the serialization here. + */ + asm volatile("mfence" : : : "memory"); +- +- printk_once(KERN_DEBUG "TSC deadline timer enabled\n"); + return; + } + +@@ -552,7 +550,7 @@ static DEFINE_PER_CPU(struct clock_event_device, lapic_events); + #define DEADLINE_MODEL_MATCH_REV(model, rev) \ + { X86_VENDOR_INTEL, 6, model, X86_FEATURE_ANY, (unsigned long)rev } + +-static u32 hsx_deadline_rev(void) ++static __init u32 hsx_deadline_rev(void) + { + switch (boot_cpu_data.x86_stepping) { + case 0x02: return 0x3a; /* EP */ +@@ -562,7 +560,7 @@ static u32 hsx_deadline_rev(void) + return ~0U; + } + +-static u32 bdx_deadline_rev(void) ++static __init u32 bdx_deadline_rev(void) + { + switch (boot_cpu_data.x86_stepping) { + case 0x02: return 0x00000011; +@@ -574,7 +572,7 @@ static u32 bdx_deadline_rev(void) + return ~0U; + } + +-static u32 skx_deadline_rev(void) ++static __init u32 skx_deadline_rev(void) + { + switch (boot_cpu_data.x86_stepping) { + case 0x03: return 0x01000136; +@@ -587,7 +585,7 @@ static u32 skx_deadline_rev(void) + return ~0U; + } + +-static const struct x86_cpu_id deadline_match[] = { ++static const struct x86_cpu_id deadline_match[] __initconst = { + DEADLINE_MODEL_MATCH_FUNC( INTEL_FAM6_HASWELL_X, hsx_deadline_rev), + DEADLINE_MODEL_MATCH_REV ( INTEL_FAM6_BROADWELL_X, 0x0b000020), + DEADLINE_MODEL_MATCH_FUNC( INTEL_FAM6_BROADWELL_D, bdx_deadline_rev), +@@ -609,18 +607,19 @@ static const struct x86_cpu_id deadline_match[] = { + {}, + }; + +-static void apic_check_deadline_errata(void) ++static __init bool apic_validate_deadline_timer(void) + { + const struct x86_cpu_id *m; + u32 rev; + +- if (!boot_cpu_has(X86_FEATURE_TSC_DEADLINE_TIMER) || +- boot_cpu_has(X86_FEATURE_HYPERVISOR)) +- return; ++ if (!boot_cpu_has(X86_FEATURE_TSC_DEADLINE_TIMER)) ++ return false; ++ if (boot_cpu_has(X86_FEATURE_HYPERVISOR)) ++ return true; + + m = x86_match_cpu(deadline_match); + if (!m) +- return; ++ return true; + + /* + * Function pointers will have the MSB set due to address layout, +@@ -632,11 +631,12 @@ static void apic_check_deadline_errata(void) + rev = (u32)m->driver_data; + + if (boot_cpu_data.microcode >= rev) +- return; ++ return true; + + setup_clear_cpu_cap(X86_FEATURE_TSC_DEADLINE_TIMER); + pr_err(FW_BUG "TSC_DEADLINE disabled due to Errata; " + "please update microcode to version: 0x%x (or later)\n", rev); ++ return false; + } + + /* +@@ -2098,7 +2098,8 @@ void __init init_apic_mappings(void) + { + unsigned int new_apicid; + +- apic_check_deadline_errata(); ++ if (apic_validate_deadline_timer()) ++ pr_debug("TSC deadline timer available\n"); + + if (x2apic_mode) { + boot_cpu_physical_apicid = read_apic_id(); +diff --git a/arch/x86/kernel/unwind_orc.c b/arch/x86/kernel/unwind_orc.c +index 9414f02a55ea..1a90abeca5f3 100644 +--- a/arch/x86/kernel/unwind_orc.c ++++ b/arch/x86/kernel/unwind_orc.c +@@ -314,12 +314,19 @@ EXPORT_SYMBOL_GPL(unwind_get_return_address); + + unsigned long *unwind_get_return_address_ptr(struct unwind_state *state) + { ++ struct task_struct *task = state->task; ++ + if (unwind_done(state)) + return NULL; + + if (state->regs) + return &state->regs->ip; + ++ if (task != current && state->sp == task->thread.sp) { ++ struct inactive_task_frame *frame = (void *)task->thread.sp; ++ return &frame->ret_addr; ++ } ++ + if (state->sp) + return (unsigned long *)state->sp - 1; + +diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c +index 03b3067811c9..2713ddb3348c 100644 +--- a/drivers/acpi/ec.c ++++ b/drivers/acpi/ec.c +@@ -2064,9 +2064,13 @@ bool acpi_ec_dispatch_gpe(void) + * to allow the caller to process events properly after that. + */ + ret = acpi_dispatch_gpe(NULL, first_ec->gpe); +- if (ret == ACPI_INTERRUPT_HANDLED) ++ if (ret == ACPI_INTERRUPT_HANDLED) { + pm_pr_dbg("EC GPE dispatched\n"); + ++ /* Flush the event and query workqueues. */ ++ acpi_ec_flush_work(); ++ } ++ + return false; + } + #endif /* CONFIG_PM_SLEEP */ +diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c +index 3850704570c0..fd9d4e8318e9 100644 +--- a/drivers/acpi/sleep.c ++++ b/drivers/acpi/sleep.c +@@ -980,13 +980,6 @@ static int acpi_s2idle_prepare_late(void) + return 0; + } + +-static void acpi_s2idle_sync(void) +-{ +- /* The EC driver uses special workqueues that need to be flushed. */ +- acpi_ec_flush_work(); +- acpi_os_wait_events_complete(); /* synchronize Notify handling */ +-} +- + static bool acpi_s2idle_wake(void) + { + if (!acpi_sci_irq_valid()) +@@ -1018,7 +1011,7 @@ static bool acpi_s2idle_wake(void) + return true; + + /* +- * Cancel the wakeup and process all pending events in case ++ * Cancel the SCI wakeup and process all pending events in case + * there are any wakeup ones in there. + * + * Note that if any non-EC GPEs are active at this point, the +@@ -1026,8 +1019,7 @@ static bool acpi_s2idle_wake(void) + * should be missed by canceling the wakeup here. + */ + pm_system_cancel_wakeup(); +- +- acpi_s2idle_sync(); ++ acpi_os_wait_events_complete(); + + /* + * The SCI is in the "suspended" state now and it cannot produce +@@ -1060,7 +1052,8 @@ static void acpi_s2idle_restore(void) + * of GPEs. + */ + acpi_os_wait_events_complete(); /* synchronize GPE processing */ +- acpi_s2idle_sync(); ++ acpi_ec_flush_work(); /* flush the EC driver's workqueues */ ++ acpi_os_wait_events_complete(); /* synchronize Notify handling */ + + s2idle_wakeup = false; + +diff --git a/drivers/base/component.c b/drivers/base/component.c +index c7879f5ae2fb..53b19daca750 100644 +--- a/drivers/base/component.c ++++ b/drivers/base/component.c +@@ -256,7 +256,8 @@ static int try_to_bring_up_master(struct master *master, + ret = master->ops->bind(master->dev); + if (ret < 0) { + devres_release_group(master->dev, NULL); +- dev_info(master->dev, "master bind failed: %d\n", ret); ++ if (ret != -EPROBE_DEFER) ++ dev_info(master->dev, "master bind failed: %d\n", ret); + return ret; + } + +@@ -610,8 +611,9 @@ static int component_bind(struct component *component, struct master *master, + devres_release_group(component->dev, NULL); + devres_release_group(master->dev, NULL); + +- dev_err(master->dev, "failed to bind %s (ops %ps): %d\n", +- dev_name(component->dev), component->ops, ret); ++ if (ret != -EPROBE_DEFER) ++ dev_err(master->dev, "failed to bind %s (ops %ps): %d\n", ++ dev_name(component->dev), component->ops, ret); + } + + return ret; +diff --git a/drivers/base/core.c b/drivers/base/core.c +index d32a3aefff32..68277687c160 100644 +--- a/drivers/base/core.c ++++ b/drivers/base/core.c +@@ -365,6 +365,7 @@ struct device_link *device_link_add(struct device *consumer, + link->flags |= DL_FLAG_STATELESS; + goto reorder; + } else { ++ link->flags |= DL_FLAG_STATELESS; + goto out; + } + } +@@ -433,12 +434,16 @@ struct device_link *device_link_add(struct device *consumer, + flags & DL_FLAG_PM_RUNTIME) + pm_runtime_resume(supplier); + ++ list_add_tail_rcu(&link->s_node, &supplier->links.consumers); ++ list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); ++ + if (flags & DL_FLAG_SYNC_STATE_ONLY) { + dev_dbg(consumer, + "Linked as a sync state only consumer to %s\n", + dev_name(supplier)); + goto out; + } ++ + reorder: + /* + * Move the consumer and all of the devices depending on it to the end +@@ -449,12 +454,9 @@ reorder: + */ + device_reorder_to_tail(consumer, NULL); + +- list_add_tail_rcu(&link->s_node, &supplier->links.consumers); +- list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); +- + dev_dbg(consumer, "Linked as a consumer to %s\n", dev_name(supplier)); + +- out: ++out: + device_pm_unlock(); + device_links_write_unlock(); + +@@ -829,6 +831,13 @@ static void __device_links_supplier_defer_sync(struct device *sup) + list_add_tail(&sup->links.defer_sync, &deferred_sync); + } + ++static void device_link_drop_managed(struct device_link *link) ++{ ++ link->flags &= ~DL_FLAG_MANAGED; ++ WRITE_ONCE(link->status, DL_STATE_NONE); ++ kref_put(&link->kref, __device_link_del); ++} ++ + /** + * device_links_driver_bound - Update device links after probing its driver. + * @dev: Device to update the links for. +@@ -842,7 +851,7 @@ static void __device_links_supplier_defer_sync(struct device *sup) + */ + void device_links_driver_bound(struct device *dev) + { +- struct device_link *link; ++ struct device_link *link, *ln; + LIST_HEAD(sync_list); + + /* +@@ -882,18 +891,35 @@ void device_links_driver_bound(struct device *dev) + else + __device_links_queue_sync_state(dev, &sync_list); + +- list_for_each_entry(link, &dev->links.suppliers, c_node) { ++ list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { ++ struct device *supplier; ++ + if (!(link->flags & DL_FLAG_MANAGED)) + continue; + +- WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); +- WRITE_ONCE(link->status, DL_STATE_ACTIVE); ++ supplier = link->supplier; ++ if (link->flags & DL_FLAG_SYNC_STATE_ONLY) { ++ /* ++ * When DL_FLAG_SYNC_STATE_ONLY is set, it means no ++ * other DL_MANAGED_LINK_FLAGS have been set. So, it's ++ * save to drop the managed link completely. ++ */ ++ device_link_drop_managed(link); ++ } else { ++ WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); ++ WRITE_ONCE(link->status, DL_STATE_ACTIVE); ++ } + ++ /* ++ * This needs to be done even for the deleted ++ * DL_FLAG_SYNC_STATE_ONLY device link in case it was the last ++ * device link that was preventing the supplier from getting a ++ * sync_state() call. ++ */ + if (defer_sync_state_count) +- __device_links_supplier_defer_sync(link->supplier); ++ __device_links_supplier_defer_sync(supplier); + else +- __device_links_queue_sync_state(link->supplier, +- &sync_list); ++ __device_links_queue_sync_state(supplier, &sync_list); + } + + dev->links.status = DL_DEV_DRIVER_BOUND; +@@ -903,13 +929,6 @@ void device_links_driver_bound(struct device *dev) + device_links_flush_sync_list(&sync_list, dev); + } + +-static void device_link_drop_managed(struct device_link *link) +-{ +- link->flags &= ~DL_FLAG_MANAGED; +- WRITE_ONCE(link->status, DL_STATE_NONE); +- kref_put(&link->kref, __device_link_del); +-} +- + /** + * __device_links_no_driver - Update links of a device without a driver. + * @dev: Device without a drvier. +diff --git a/drivers/base/platform.c b/drivers/base/platform.c +index c81b68d5d66d..b5ce7b085795 100644 +--- a/drivers/base/platform.c ++++ b/drivers/base/platform.c +@@ -361,8 +361,6 @@ struct platform_object { + */ + static void setup_pdev_dma_masks(struct platform_device *pdev) + { +- pdev->dev.dma_parms = &pdev->dma_parms; +- + if (!pdev->dev.coherent_dma_mask) + pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32); + if (!pdev->dev.dma_mask) { +diff --git a/drivers/dax/kmem.c b/drivers/dax/kmem.c +index 3d0a7e702c94..1e678bdf5aed 100644 +--- a/drivers/dax/kmem.c ++++ b/drivers/dax/kmem.c +@@ -22,6 +22,7 @@ int dev_dax_kmem_probe(struct device *dev) + resource_size_t kmem_size; + resource_size_t kmem_end; + struct resource *new_res; ++ const char *new_res_name; + int numa_node; + int rc; + +@@ -48,11 +49,16 @@ int dev_dax_kmem_probe(struct device *dev) + kmem_size &= ~(memory_block_size_bytes() - 1); + kmem_end = kmem_start + kmem_size; + +- /* Region is permanently reserved. Hot-remove not yet implemented. */ +- new_res = request_mem_region(kmem_start, kmem_size, dev_name(dev)); ++ new_res_name = kstrdup(dev_name(dev), GFP_KERNEL); ++ if (!new_res_name) ++ return -ENOMEM; ++ ++ /* Region is permanently reserved if hotremove fails. */ ++ new_res = request_mem_region(kmem_start, kmem_size, new_res_name); + if (!new_res) { + dev_warn(dev, "could not reserve region [%pa-%pa]\n", + &kmem_start, &kmem_end); ++ kfree(new_res_name); + return -EBUSY; + } + +@@ -63,12 +69,12 @@ int dev_dax_kmem_probe(struct device *dev) + * unknown to us that will break add_memory() below. + */ + new_res->flags = IORESOURCE_SYSTEM_RAM; +- new_res->name = dev_name(dev); + + rc = add_memory(numa_node, new_res->start, resource_size(new_res)); + if (rc) { + release_resource(new_res); + kfree(new_res); ++ kfree(new_res_name); + return rc; + } + dev_dax->dax_kmem_res = new_res; +@@ -83,6 +89,7 @@ static int dev_dax_kmem_remove(struct device *dev) + struct resource *res = dev_dax->dax_kmem_res; + resource_size_t kmem_start = res->start; + resource_size_t kmem_size = resource_size(res); ++ const char *res_name = res->name; + int rc; + + /* +@@ -102,6 +109,7 @@ static int dev_dax_kmem_remove(struct device *dev) + /* Release and free dax resources */ + release_resource(res); + kfree(res); ++ kfree(res_name); + dev_dax->dax_kmem_res = NULL; + + return 0; +diff --git a/drivers/dma/dmatest.c b/drivers/dma/dmatest.c +index 364dd34799d4..0425984db118 100644 +--- a/drivers/dma/dmatest.c ++++ b/drivers/dma/dmatest.c +@@ -1166,10 +1166,11 @@ static int dmatest_run_set(const char *val, const struct kernel_param *kp) + mutex_unlock(&info->lock); + return ret; + } else if (dmatest_run) { +- if (is_threaded_test_pending(info)) +- start_threaded_tests(info); +- else +- pr_info("Could not start test, no channels configured\n"); ++ if (!is_threaded_test_pending(info)) { ++ pr_info("No channels configured, continue with any\n"); ++ add_threaded_test(info); ++ } ++ start_threaded_tests(info); + } else { + stop_threaded_test(info); + } +diff --git a/drivers/dma/idxd/device.c b/drivers/dma/idxd/device.c +index f6f49f0f6fae..8d79a8787104 100644 +--- a/drivers/dma/idxd/device.c ++++ b/drivers/dma/idxd/device.c +@@ -62,6 +62,13 @@ int idxd_unmask_msix_vector(struct idxd_device *idxd, int vec_id) + perm.ignore = 0; + iowrite32(perm.bits, idxd->reg_base + offset); + ++ /* ++ * A readback from the device ensures that any previously generated ++ * completion record writes are visible to software based on PCI ++ * ordering rules. ++ */ ++ perm.bits = ioread32(idxd->reg_base + offset); ++ + return 0; + } + +diff --git a/drivers/dma/idxd/irq.c b/drivers/dma/idxd/irq.c +index d6fcd2e60103..6510791b9921 100644 +--- a/drivers/dma/idxd/irq.c ++++ b/drivers/dma/idxd/irq.c +@@ -173,6 +173,7 @@ static int irq_process_pending_llist(struct idxd_irq_entry *irq_entry, + struct llist_node *head; + int queued = 0; + ++ *processed = 0; + head = llist_del_all(&irq_entry->pending_llist); + if (!head) + return 0; +@@ -197,6 +198,7 @@ static int irq_process_work_list(struct idxd_irq_entry *irq_entry, + struct list_head *node, *next; + int queued = 0; + ++ *processed = 0; + if (list_empty(&irq_entry->work_list)) + return 0; + +@@ -218,10 +220,9 @@ static int irq_process_work_list(struct idxd_irq_entry *irq_entry, + return queued; + } + +-irqreturn_t idxd_wq_thread(int irq, void *data) ++static int idxd_desc_process(struct idxd_irq_entry *irq_entry) + { +- struct idxd_irq_entry *irq_entry = data; +- int rc, processed = 0, retry = 0; ++ int rc, processed, total = 0; + + /* + * There are two lists we are processing. The pending_llist is where +@@ -244,15 +245,26 @@ irqreturn_t idxd_wq_thread(int irq, void *data) + */ + do { + rc = irq_process_work_list(irq_entry, &processed); +- if (rc != 0) { +- retry++; ++ total += processed; ++ if (rc != 0) + continue; +- } + + rc = irq_process_pending_llist(irq_entry, &processed); +- } while (rc != 0 && retry != 10); ++ total += processed; ++ } while (rc != 0); ++ ++ return total; ++} ++ ++irqreturn_t idxd_wq_thread(int irq, void *data) ++{ ++ struct idxd_irq_entry *irq_entry = data; ++ int processed; + ++ processed = idxd_desc_process(irq_entry); + idxd_unmask_msix_vector(irq_entry->idxd, irq_entry->id); ++ /* catch anything unprocessed after unmasking */ ++ processed += idxd_desc_process(irq_entry); + + if (processed == 0) + return IRQ_NONE; +diff --git a/drivers/dma/owl-dma.c b/drivers/dma/owl-dma.c +index c683051257fd..66ef70b00ec0 100644 +--- a/drivers/dma/owl-dma.c ++++ b/drivers/dma/owl-dma.c +@@ -175,13 +175,11 @@ struct owl_dma_txd { + * @id: physical index to this channel + * @base: virtual memory base for the dma channel + * @vchan: the virtual channel currently being served by this physical channel +- * @lock: a lock to use when altering an instance of this struct + */ + struct owl_dma_pchan { + u32 id; + void __iomem *base; + struct owl_dma_vchan *vchan; +- spinlock_t lock; + }; + + /** +@@ -437,14 +435,14 @@ static struct owl_dma_pchan *owl_dma_get_pchan(struct owl_dma *od, + for (i = 0; i < od->nr_pchans; i++) { + pchan = &od->pchans[i]; + +- spin_lock_irqsave(&pchan->lock, flags); ++ spin_lock_irqsave(&od->lock, flags); + if (!pchan->vchan) { + pchan->vchan = vchan; +- spin_unlock_irqrestore(&pchan->lock, flags); ++ spin_unlock_irqrestore(&od->lock, flags); + break; + } + +- spin_unlock_irqrestore(&pchan->lock, flags); ++ spin_unlock_irqrestore(&od->lock, flags); + } + + return pchan; +diff --git a/drivers/dma/tegra210-adma.c b/drivers/dma/tegra210-adma.c +index 6e1268552f74..914901a680c8 100644 +--- a/drivers/dma/tegra210-adma.c ++++ b/drivers/dma/tegra210-adma.c +@@ -900,7 +900,7 @@ static int tegra_adma_probe(struct platform_device *pdev) + ret = dma_async_device_register(&tdma->dma_dev); + if (ret < 0) { + dev_err(&pdev->dev, "ADMA registration failed: %d\n", ret); +- goto irq_dispose; ++ goto rpm_put; + } + + ret = of_dma_controller_register(pdev->dev.of_node, +diff --git a/drivers/firmware/efi/libstub/tpm.c b/drivers/firmware/efi/libstub/tpm.c +index 1d59e103a2e3..e9a684637b70 100644 +--- a/drivers/firmware/efi/libstub/tpm.c ++++ b/drivers/firmware/efi/libstub/tpm.c +@@ -54,7 +54,7 @@ void efi_retrieve_tpm2_eventlog(void) + efi_status_t status; + efi_physical_addr_t log_location = 0, log_last_entry = 0; + struct linux_efi_tpm_eventlog *log_tbl = NULL; +- struct efi_tcg2_final_events_table *final_events_table; ++ struct efi_tcg2_final_events_table *final_events_table = NULL; + unsigned long first_entry_addr, last_entry_addr; + size_t log_size, last_entry_size; + efi_bool_t truncated; +@@ -127,7 +127,8 @@ void efi_retrieve_tpm2_eventlog(void) + * Figure out whether any events have already been logged to the + * final events structure, and if so how much space they take up + */ +- final_events_table = get_efi_config_table(LINUX_EFI_TPM_FINAL_LOG_GUID); ++ if (version == EFI_TCG2_EVENT_LOG_FORMAT_TCG_2) ++ final_events_table = get_efi_config_table(LINUX_EFI_TPM_FINAL_LOG_GUID); + if (final_events_table && final_events_table->nr_events) { + struct tcg_pcr_event2_head *header; + int offset; +diff --git a/drivers/firmware/efi/tpm.c b/drivers/firmware/efi/tpm.c +index 55b031d2c989..c1955d320fec 100644 +--- a/drivers/firmware/efi/tpm.c ++++ b/drivers/firmware/efi/tpm.c +@@ -62,8 +62,11 @@ int __init efi_tpm_eventlog_init(void) + tbl_size = sizeof(*log_tbl) + log_tbl->size; + memblock_reserve(efi.tpm_log, tbl_size); + +- if (efi.tpm_final_log == EFI_INVALID_TABLE_ADDR) ++ if (efi.tpm_final_log == EFI_INVALID_TABLE_ADDR || ++ log_tbl->version != EFI_TCG2_EVENT_LOG_FORMAT_TCG_2) { ++ pr_warn(FW_BUG "TPM Final Events table missing or invalid\n"); + goto out; ++ } + + final_tbl = early_memremap(efi.tpm_final_log, sizeof(*final_tbl)); + +diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +index 5e27a67fbc58..0cd11d3d4cf4 100644 +--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c ++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +@@ -1941,17 +1941,22 @@ amdgpu_dm_update_connector_after_detect(struct amdgpu_dm_connector *aconnector) + dc_sink_retain(aconnector->dc_sink); + if (sink->dc_edid.length == 0) { + aconnector->edid = NULL; +- drm_dp_cec_unset_edid(&aconnector->dm_dp_aux.aux); ++ if (aconnector->dc_link->aux_mode) { ++ drm_dp_cec_unset_edid( ++ &aconnector->dm_dp_aux.aux); ++ } + } else { + aconnector->edid = +- (struct edid *) sink->dc_edid.raw_edid; +- ++ (struct edid *)sink->dc_edid.raw_edid; + + drm_connector_update_edid_property(connector, +- aconnector->edid); +- drm_dp_cec_set_edid(&aconnector->dm_dp_aux.aux, +- aconnector->edid); ++ aconnector->edid); ++ ++ if (aconnector->dc_link->aux_mode) ++ drm_dp_cec_set_edid(&aconnector->dm_dp_aux.aux, ++ aconnector->edid); + } ++ + amdgpu_dm_update_freesync_caps(connector, aconnector->edid); + + } else { +diff --git a/drivers/gpu/drm/amd/display/dc/core/dc.c b/drivers/gpu/drm/amd/display/dc/core/dc.c +index 188e51600070..b3987124183a 100644 +--- a/drivers/gpu/drm/amd/display/dc/core/dc.c ++++ b/drivers/gpu/drm/amd/display/dc/core/dc.c +@@ -803,11 +803,10 @@ static void disable_dangling_plane(struct dc *dc, struct dc_state *context) + static void wait_for_no_pipes_pending(struct dc *dc, struct dc_state *context) + { + int i; +- int count = 0; +- struct pipe_ctx *pipe; + PERF_TRACE(); + for (i = 0; i < MAX_PIPES; i++) { +- pipe = &context->res_ctx.pipe_ctx[i]; ++ int count = 0; ++ struct pipe_ctx *pipe = &context->res_ctx.pipe_ctx[i]; + + if (!pipe->plane_state) + continue; +diff --git a/drivers/gpu/drm/etnaviv/etnaviv_gem_submit.c b/drivers/gpu/drm/etnaviv/etnaviv_gem_submit.c +index 3b0afa156d92..54def341c1db 100644 +--- a/drivers/gpu/drm/etnaviv/etnaviv_gem_submit.c ++++ b/drivers/gpu/drm/etnaviv/etnaviv_gem_submit.c +@@ -238,8 +238,10 @@ static int submit_pin_objects(struct etnaviv_gem_submit *submit) + } + + if ((submit->flags & ETNA_SUBMIT_SOFTPIN) && +- submit->bos[i].va != mapping->iova) ++ submit->bos[i].va != mapping->iova) { ++ etnaviv_gem_mapping_unreference(mapping); + return -EINVAL; ++ } + + atomic_inc(&etnaviv_obj->gpu_active); + +diff --git a/drivers/gpu/drm/etnaviv/etnaviv_perfmon.c b/drivers/gpu/drm/etnaviv/etnaviv_perfmon.c +index e6795bafcbb9..75f9db8f7bec 100644 +--- a/drivers/gpu/drm/etnaviv/etnaviv_perfmon.c ++++ b/drivers/gpu/drm/etnaviv/etnaviv_perfmon.c +@@ -453,7 +453,7 @@ static const struct etnaviv_pm_domain *pm_domain(const struct etnaviv_gpu *gpu, + if (!(gpu->identity.features & meta->feature)) + continue; + +- if (meta->nr_domains < (index - offset)) { ++ if (index - offset >= meta->nr_domains) { + offset += meta->nr_domains; + continue; + } +diff --git a/drivers/gpu/drm/i915/gvt/display.c b/drivers/gpu/drm/i915/gvt/display.c +index a62bdf9be682..59aa5e64acb0 100644 +--- a/drivers/gpu/drm/i915/gvt/display.c ++++ b/drivers/gpu/drm/i915/gvt/display.c +@@ -207,14 +207,41 @@ static void emulate_monitor_status_change(struct intel_vgpu *vgpu) + SKL_FUSE_PG_DIST_STATUS(SKL_PG0) | + SKL_FUSE_PG_DIST_STATUS(SKL_PG1) | + SKL_FUSE_PG_DIST_STATUS(SKL_PG2); +- vgpu_vreg_t(vgpu, LCPLL1_CTL) |= +- LCPLL_PLL_ENABLE | +- LCPLL_PLL_LOCK; +- vgpu_vreg_t(vgpu, LCPLL2_CTL) |= LCPLL_PLL_ENABLE; +- ++ /* ++ * Only 1 PIPE enabled in current vGPU display and PIPE_A is ++ * tied to TRANSCODER_A in HW, so it's safe to assume PIPE_A, ++ * TRANSCODER_A can be enabled. PORT_x depends on the input of ++ * setup_virtual_dp_monitor, we can bind DPLL0 to any PORT_x ++ * so we fixed to DPLL0 here. ++ * Setup DPLL0: DP link clk 1620 MHz, non SSC, DP Mode ++ */ ++ vgpu_vreg_t(vgpu, DPLL_CTRL1) = ++ DPLL_CTRL1_OVERRIDE(DPLL_ID_SKL_DPLL0); ++ vgpu_vreg_t(vgpu, DPLL_CTRL1) |= ++ DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_1620, DPLL_ID_SKL_DPLL0); ++ vgpu_vreg_t(vgpu, LCPLL1_CTL) = ++ LCPLL_PLL_ENABLE | LCPLL_PLL_LOCK; ++ vgpu_vreg_t(vgpu, DPLL_STATUS) = DPLL_LOCK(DPLL_ID_SKL_DPLL0); ++ /* ++ * Golden M/N are calculated based on: ++ * 24 bpp, 4 lanes, 154000 pixel clk (from virtual EDID), ++ * DP link clk 1620 MHz and non-constant_n. ++ * TODO: calculate DP link symbol clk and stream clk m/n. ++ */ ++ vgpu_vreg_t(vgpu, PIPE_DATA_M1(TRANSCODER_A)) = 63 << TU_SIZE_SHIFT; ++ vgpu_vreg_t(vgpu, PIPE_DATA_M1(TRANSCODER_A)) |= 0x5b425e; ++ vgpu_vreg_t(vgpu, PIPE_DATA_N1(TRANSCODER_A)) = 0x800000; ++ vgpu_vreg_t(vgpu, PIPE_LINK_M1(TRANSCODER_A)) = 0x3cd6e; ++ vgpu_vreg_t(vgpu, PIPE_LINK_N1(TRANSCODER_A)) = 0x80000; + } + + if (intel_vgpu_has_monitor_on_port(vgpu, PORT_B)) { ++ vgpu_vreg_t(vgpu, DPLL_CTRL2) &= ++ ~DPLL_CTRL2_DDI_CLK_OFF(PORT_B); ++ vgpu_vreg_t(vgpu, DPLL_CTRL2) |= ++ DPLL_CTRL2_DDI_CLK_SEL(DPLL_ID_SKL_DPLL0, PORT_B); ++ vgpu_vreg_t(vgpu, DPLL_CTRL2) |= ++ DPLL_CTRL2_DDI_SEL_OVERRIDE(PORT_B); + vgpu_vreg_t(vgpu, SFUSE_STRAP) |= SFUSE_STRAP_DDIB_DETECTED; + vgpu_vreg_t(vgpu, TRANS_DDI_FUNC_CTL(TRANSCODER_A)) &= + ~(TRANS_DDI_BPC_MASK | TRANS_DDI_MODE_SELECT_MASK | +@@ -235,6 +262,12 @@ static void emulate_monitor_status_change(struct intel_vgpu *vgpu) + } + + if (intel_vgpu_has_monitor_on_port(vgpu, PORT_C)) { ++ vgpu_vreg_t(vgpu, DPLL_CTRL2) &= ++ ~DPLL_CTRL2_DDI_CLK_OFF(PORT_C); ++ vgpu_vreg_t(vgpu, DPLL_CTRL2) |= ++ DPLL_CTRL2_DDI_CLK_SEL(DPLL_ID_SKL_DPLL0, PORT_C); ++ vgpu_vreg_t(vgpu, DPLL_CTRL2) |= ++ DPLL_CTRL2_DDI_SEL_OVERRIDE(PORT_C); + vgpu_vreg_t(vgpu, SDEISR) |= SDE_PORTC_HOTPLUG_CPT; + vgpu_vreg_t(vgpu, TRANS_DDI_FUNC_CTL(TRANSCODER_A)) &= + ~(TRANS_DDI_BPC_MASK | TRANS_DDI_MODE_SELECT_MASK | +@@ -255,6 +288,12 @@ static void emulate_monitor_status_change(struct intel_vgpu *vgpu) + } + + if (intel_vgpu_has_monitor_on_port(vgpu, PORT_D)) { ++ vgpu_vreg_t(vgpu, DPLL_CTRL2) &= ++ ~DPLL_CTRL2_DDI_CLK_OFF(PORT_D); ++ vgpu_vreg_t(vgpu, DPLL_CTRL2) |= ++ DPLL_CTRL2_DDI_CLK_SEL(DPLL_ID_SKL_DPLL0, PORT_D); ++ vgpu_vreg_t(vgpu, DPLL_CTRL2) |= ++ DPLL_CTRL2_DDI_SEL_OVERRIDE(PORT_D); + vgpu_vreg_t(vgpu, SDEISR) |= SDE_PORTD_HOTPLUG_CPT; + vgpu_vreg_t(vgpu, TRANS_DDI_FUNC_CTL(TRANSCODER_A)) &= + ~(TRANS_DDI_BPC_MASK | TRANS_DDI_MODE_SELECT_MASK | +diff --git a/drivers/gpu/drm/i915/i915_request.c b/drivers/gpu/drm/i915/i915_request.c +index 32ab154db788..1f50fc8bcebf 100644 +--- a/drivers/gpu/drm/i915/i915_request.c ++++ b/drivers/gpu/drm/i915/i915_request.c +@@ -947,8 +947,10 @@ i915_request_await_request(struct i915_request *to, struct i915_request *from) + GEM_BUG_ON(to == from); + GEM_BUG_ON(to->timeline == from->timeline); + +- if (i915_request_completed(from)) ++ if (i915_request_completed(from)) { ++ i915_sw_fence_set_error_once(&to->submit, from->fence.error); + return 0; ++ } + + if (to->engine->schedule) { + ret = i915_sched_node_add_dependency(&to->sched, +diff --git a/drivers/hid/hid-alps.c b/drivers/hid/hid-alps.c +index fa704153cb00..b2ad319a74b9 100644 +--- a/drivers/hid/hid-alps.c ++++ b/drivers/hid/hid-alps.c +@@ -802,6 +802,7 @@ static int alps_probe(struct hid_device *hdev, const struct hid_device_id *id) + break; + case HID_DEVICE_ID_ALPS_U1_DUAL: + case HID_DEVICE_ID_ALPS_U1: ++ case HID_DEVICE_ID_ALPS_U1_UNICORN_LEGACY: + data->dev_type = U1; + break; + default: +diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h +index 9f2213426556..b1d6156ebf9d 100644 +--- a/drivers/hid/hid-ids.h ++++ b/drivers/hid/hid-ids.h +@@ -79,10 +79,10 @@ + #define HID_DEVICE_ID_ALPS_U1_DUAL_PTP 0x121F + #define HID_DEVICE_ID_ALPS_U1_DUAL_3BTN_PTP 0x1220 + #define HID_DEVICE_ID_ALPS_U1 0x1215 ++#define HID_DEVICE_ID_ALPS_U1_UNICORN_LEGACY 0x121E + #define HID_DEVICE_ID_ALPS_T4_BTNLESS 0x120C + #define HID_DEVICE_ID_ALPS_1222 0x1222 + +- + #define USB_VENDOR_ID_AMI 0x046b + #define USB_DEVICE_ID_AMI_VIRT_KEYBOARD_AND_MOUSE 0xff10 + +@@ -385,6 +385,7 @@ + #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349 0x7349 + #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_73F7 0x73f7 + #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001 0xa001 ++#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_C002 0xc002 + + #define USB_VENDOR_ID_ELAN 0x04f3 + #define USB_DEVICE_ID_TOSHIBA_CLICK_L9W 0x0401 +@@ -755,6 +756,7 @@ + #define USB_DEVICE_ID_LOGITECH_RUMBLEPAD2 0xc218 + #define USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2 0xc219 + #define USB_DEVICE_ID_LOGITECH_G15_LCD 0xc222 ++#define USB_DEVICE_ID_LOGITECH_G11 0xc225 + #define USB_DEVICE_ID_LOGITECH_G15_V2_LCD 0xc227 + #define USB_DEVICE_ID_LOGITECH_G510 0xc22d + #define USB_DEVICE_ID_LOGITECH_G510_USB_AUDIO 0xc22e +@@ -1092,6 +1094,9 @@ + #define USB_DEVICE_ID_SYMBOL_SCANNER_2 0x1300 + #define USB_DEVICE_ID_SYMBOL_SCANNER_3 0x1200 + ++#define I2C_VENDOR_ID_SYNAPTICS 0x06cb ++#define I2C_PRODUCT_ID_SYNAPTICS_SYNA2393 0x7a13 ++ + #define USB_VENDOR_ID_SYNAPTICS 0x06cb + #define USB_DEVICE_ID_SYNAPTICS_TP 0x0001 + #define USB_DEVICE_ID_SYNAPTICS_INT_TP 0x0002 +@@ -1106,6 +1111,7 @@ + #define USB_DEVICE_ID_SYNAPTICS_LTS2 0x1d10 + #define USB_DEVICE_ID_SYNAPTICS_HD 0x0ac3 + #define USB_DEVICE_ID_SYNAPTICS_QUAD_HD 0x1ac3 ++#define USB_DEVICE_ID_SYNAPTICS_DELL_K12A 0x2819 + #define USB_DEVICE_ID_SYNAPTICS_ACER_SWITCH5_012 0x2968 + #define USB_DEVICE_ID_SYNAPTICS_TP_V103 0x5710 + #define USB_DEVICE_ID_SYNAPTICS_ACER_SWITCH5 0x81a7 +diff --git a/drivers/hid/hid-lg-g15.c b/drivers/hid/hid-lg-g15.c +index ad4b5412a9f4..ef0cbcd7540d 100644 +--- a/drivers/hid/hid-lg-g15.c ++++ b/drivers/hid/hid-lg-g15.c +@@ -872,6 +872,10 @@ error_hw_stop: + } + + static const struct hid_device_id lg_g15_devices[] = { ++ /* The G11 is a G15 without the LCD, treat it as a G15 */ ++ { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, ++ USB_DEVICE_ID_LOGITECH_G11), ++ .driver_data = LG_G15 }, + { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, + USB_DEVICE_ID_LOGITECH_G15_LCD), + .driver_data = LG_G15 }, +diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c +index 362805ddf377..03c720b47306 100644 +--- a/drivers/hid/hid-multitouch.c ++++ b/drivers/hid/hid-multitouch.c +@@ -1922,6 +1922,9 @@ static const struct hid_device_id mt_devices[] = { + { .driver_data = MT_CLS_EGALAX_SERIAL, + MT_USB_DEVICE(USB_VENDOR_ID_DWAV, + USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) }, ++ { .driver_data = MT_CLS_EGALAX, ++ MT_USB_DEVICE(USB_VENDOR_ID_DWAV, ++ USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_C002) }, + + /* Elitegroup panel */ + { .driver_data = MT_CLS_SERIAL, +diff --git a/drivers/hid/hid-quirks.c b/drivers/hid/hid-quirks.c +index 3735546bb524..acc7c14f7fbc 100644 +--- a/drivers/hid/hid-quirks.c ++++ b/drivers/hid/hid-quirks.c +@@ -163,6 +163,7 @@ static const struct hid_device_id hid_quirks[] = { + { HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_LTS2), HID_QUIRK_NO_INIT_REPORTS }, + { HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_QUAD_HD), HID_QUIRK_NO_INIT_REPORTS }, + { HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_TP_V103), HID_QUIRK_NO_INIT_REPORTS }, ++ { HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_DELL_K12A), HID_QUIRK_NO_INIT_REPORTS }, + { HID_USB_DEVICE(USB_VENDOR_ID_TOPMAX, USB_DEVICE_ID_TOPMAX_COBRAPAD), HID_QUIRK_BADPAD }, + { HID_USB_DEVICE(USB_VENDOR_ID_TOUCHPACK, USB_DEVICE_ID_TOUCHPACK_RTS), HID_QUIRK_MULTI_INPUT }, + { HID_USB_DEVICE(USB_VENDOR_ID_TPV, USB_DEVICE_ID_TPV_OPTICAL_TOUCHSCREEN_8882), HID_QUIRK_NOGET }, +diff --git a/drivers/hid/i2c-hid/i2c-hid-core.c b/drivers/hid/i2c-hid/i2c-hid-core.c +index 009000c5d55c..294c84e136d7 100644 +--- a/drivers/hid/i2c-hid/i2c-hid-core.c ++++ b/drivers/hid/i2c-hid/i2c-hid-core.c +@@ -177,6 +177,8 @@ static const struct i2c_hid_quirks { + I2C_HID_QUIRK_BOGUS_IRQ }, + { USB_VENDOR_ID_ALPS_JP, HID_ANY_ID, + I2C_HID_QUIRK_RESET_ON_RESUME }, ++ { I2C_VENDOR_ID_SYNAPTICS, I2C_PRODUCT_ID_SYNAPTICS_SYNA2393, ++ I2C_HID_QUIRK_RESET_ON_RESUME }, + { USB_VENDOR_ID_ITE, I2C_DEVICE_ID_ITE_LENOVO_LEGION_Y720, + I2C_HID_QUIRK_BAD_INPUT_SIZE }, + { 0, 0 } +diff --git a/drivers/i2c/i2c-core-base.c b/drivers/i2c/i2c-core-base.c +index cefad0881942..fd3199782b6e 100644 +--- a/drivers/i2c/i2c-core-base.c ++++ b/drivers/i2c/i2c-core-base.c +@@ -338,8 +338,10 @@ static int i2c_device_probe(struct device *dev) + } else if (ACPI_COMPANION(dev)) { + irq = i2c_acpi_get_irq(client); + } +- if (irq == -EPROBE_DEFER) +- return irq; ++ if (irq == -EPROBE_DEFER) { ++ status = irq; ++ goto put_sync_adapter; ++ } + + if (irq < 0) + irq = 0; +@@ -353,15 +355,19 @@ static int i2c_device_probe(struct device *dev) + */ + if (!driver->id_table && + !i2c_acpi_match_device(dev->driver->acpi_match_table, client) && +- !i2c_of_match_device(dev->driver->of_match_table, client)) +- return -ENODEV; ++ !i2c_of_match_device(dev->driver->of_match_table, client)) { ++ status = -ENODEV; ++ goto put_sync_adapter; ++ } + + if (client->flags & I2C_CLIENT_WAKE) { + int wakeirq; + + wakeirq = of_irq_get_byname(dev->of_node, "wakeup"); +- if (wakeirq == -EPROBE_DEFER) +- return wakeirq; ++ if (wakeirq == -EPROBE_DEFER) { ++ status = wakeirq; ++ goto put_sync_adapter; ++ } + + device_init_wakeup(&client->dev, true); + +@@ -408,6 +414,10 @@ err_detach_pm_domain: + err_clear_wakeup_irq: + dev_pm_clear_wake_irq(&client->dev); + device_init_wakeup(&client->dev, false); ++put_sync_adapter: ++ if (client->flags & I2C_CLIENT_HOST_NOTIFY) ++ pm_runtime_put_sync(&client->adapter->dev); ++ + return status; + } + +diff --git a/drivers/i2c/i2c-dev.c b/drivers/i2c/i2c-dev.c +index 2ea4585d18c5..94beacc41302 100644 +--- a/drivers/i2c/i2c-dev.c ++++ b/drivers/i2c/i2c-dev.c +@@ -40,7 +40,7 @@ + struct i2c_dev { + struct list_head list; + struct i2c_adapter *adap; +- struct device *dev; ++ struct device dev; + struct cdev cdev; + }; + +@@ -84,12 +84,14 @@ static struct i2c_dev *get_free_i2c_dev(struct i2c_adapter *adap) + return i2c_dev; + } + +-static void put_i2c_dev(struct i2c_dev *i2c_dev) ++static void put_i2c_dev(struct i2c_dev *i2c_dev, bool del_cdev) + { + spin_lock(&i2c_dev_list_lock); + list_del(&i2c_dev->list); + spin_unlock(&i2c_dev_list_lock); +- kfree(i2c_dev); ++ if (del_cdev) ++ cdev_device_del(&i2c_dev->cdev, &i2c_dev->dev); ++ put_device(&i2c_dev->dev); + } + + static ssize_t name_show(struct device *dev, +@@ -628,6 +630,14 @@ static const struct file_operations i2cdev_fops = { + + static struct class *i2c_dev_class; + ++static void i2cdev_dev_release(struct device *dev) ++{ ++ struct i2c_dev *i2c_dev; ++ ++ i2c_dev = container_of(dev, struct i2c_dev, dev); ++ kfree(i2c_dev); ++} ++ + static int i2cdev_attach_adapter(struct device *dev, void *dummy) + { + struct i2c_adapter *adap; +@@ -644,27 +654,23 @@ static int i2cdev_attach_adapter(struct device *dev, void *dummy) + + cdev_init(&i2c_dev->cdev, &i2cdev_fops); + i2c_dev->cdev.owner = THIS_MODULE; +- res = cdev_add(&i2c_dev->cdev, MKDEV(I2C_MAJOR, adap->nr), 1); +- if (res) +- goto error_cdev; +- +- /* register this i2c device with the driver core */ +- i2c_dev->dev = device_create(i2c_dev_class, &adap->dev, +- MKDEV(I2C_MAJOR, adap->nr), NULL, +- "i2c-%d", adap->nr); +- if (IS_ERR(i2c_dev->dev)) { +- res = PTR_ERR(i2c_dev->dev); +- goto error; ++ ++ device_initialize(&i2c_dev->dev); ++ i2c_dev->dev.devt = MKDEV(I2C_MAJOR, adap->nr); ++ i2c_dev->dev.class = i2c_dev_class; ++ i2c_dev->dev.parent = &adap->dev; ++ i2c_dev->dev.release = i2cdev_dev_release; ++ dev_set_name(&i2c_dev->dev, "i2c-%d", adap->nr); ++ ++ res = cdev_device_add(&i2c_dev->cdev, &i2c_dev->dev); ++ if (res) { ++ put_i2c_dev(i2c_dev, false); ++ return res; + } + + pr_debug("i2c-dev: adapter [%s] registered as minor %d\n", + adap->name, adap->nr); + return 0; +-error: +- cdev_del(&i2c_dev->cdev); +-error_cdev: +- put_i2c_dev(i2c_dev); +- return res; + } + + static int i2cdev_detach_adapter(struct device *dev, void *dummy) +@@ -680,9 +686,7 @@ static int i2cdev_detach_adapter(struct device *dev, void *dummy) + if (!i2c_dev) /* attach_adapter must have failed */ + return 0; + +- cdev_del(&i2c_dev->cdev); +- put_i2c_dev(i2c_dev); +- device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, adap->nr)); ++ put_i2c_dev(i2c_dev, true); + + pr_debug("i2c-dev: adapter [%s] unregistered\n", adap->name); + return 0; +diff --git a/drivers/i2c/muxes/i2c-demux-pinctrl.c b/drivers/i2c/muxes/i2c-demux-pinctrl.c +index 0e16490eb3a1..5365199a31f4 100644 +--- a/drivers/i2c/muxes/i2c-demux-pinctrl.c ++++ b/drivers/i2c/muxes/i2c-demux-pinctrl.c +@@ -272,6 +272,7 @@ static int i2c_demux_pinctrl_probe(struct platform_device *pdev) + err_rollback_available: + device_remove_file(&pdev->dev, &dev_attr_available_masters); + err_rollback: ++ i2c_demux_deactivate_master(priv); + for (j = 0; j < i; j++) { + of_node_put(priv->chan[j].parent_np); + of_changeset_destroy(&priv->chan[j].chgset); +diff --git a/drivers/iio/accel/sca3000.c b/drivers/iio/accel/sca3000.c +index 66d768d971e1..6e429072e44a 100644 +--- a/drivers/iio/accel/sca3000.c ++++ b/drivers/iio/accel/sca3000.c +@@ -980,7 +980,7 @@ static int sca3000_read_data(struct sca3000_state *st, + st->tx[0] = SCA3000_READ_REG(reg_address_high); + ret = spi_sync_transfer(st->us, xfer, ARRAY_SIZE(xfer)); + if (ret) { +- dev_err(get_device(&st->us->dev), "problem reading register"); ++ dev_err(&st->us->dev, "problem reading register\n"); + return ret; + } + +diff --git a/drivers/iio/adc/stm32-adc.c b/drivers/iio/adc/stm32-adc.c +index ae622ee6d08c..dfc3a306c667 100644 +--- a/drivers/iio/adc/stm32-adc.c ++++ b/drivers/iio/adc/stm32-adc.c +@@ -1812,18 +1812,18 @@ static int stm32_adc_chan_of_init(struct iio_dev *indio_dev) + return 0; + } + +-static int stm32_adc_dma_request(struct iio_dev *indio_dev) ++static int stm32_adc_dma_request(struct device *dev, struct iio_dev *indio_dev) + { + struct stm32_adc *adc = iio_priv(indio_dev); + struct dma_slave_config config; + int ret; + +- adc->dma_chan = dma_request_chan(&indio_dev->dev, "rx"); ++ adc->dma_chan = dma_request_chan(dev, "rx"); + if (IS_ERR(adc->dma_chan)) { + ret = PTR_ERR(adc->dma_chan); + if (ret != -ENODEV) { + if (ret != -EPROBE_DEFER) +- dev_err(&indio_dev->dev, ++ dev_err(dev, + "DMA channel request failed with %d\n", + ret); + return ret; +@@ -1930,7 +1930,7 @@ static int stm32_adc_probe(struct platform_device *pdev) + if (ret < 0) + return ret; + +- ret = stm32_adc_dma_request(indio_dev); ++ ret = stm32_adc_dma_request(dev, indio_dev); + if (ret < 0) + return ret; + +diff --git a/drivers/iio/adc/stm32-dfsdm-adc.c b/drivers/iio/adc/stm32-dfsdm-adc.c +index 76a60d93fe23..506bf519f64c 100644 +--- a/drivers/iio/adc/stm32-dfsdm-adc.c ++++ b/drivers/iio/adc/stm32-dfsdm-adc.c +@@ -62,7 +62,7 @@ enum sd_converter_type { + + struct stm32_dfsdm_dev_data { + int type; +- int (*init)(struct iio_dev *indio_dev); ++ int (*init)(struct device *dev, struct iio_dev *indio_dev); + unsigned int num_channels; + const struct regmap_config *regmap_cfg; + }; +@@ -1365,11 +1365,12 @@ static void stm32_dfsdm_dma_release(struct iio_dev *indio_dev) + } + } + +-static int stm32_dfsdm_dma_request(struct iio_dev *indio_dev) ++static int stm32_dfsdm_dma_request(struct device *dev, ++ struct iio_dev *indio_dev) + { + struct stm32_dfsdm_adc *adc = iio_priv(indio_dev); + +- adc->dma_chan = dma_request_chan(&indio_dev->dev, "rx"); ++ adc->dma_chan = dma_request_chan(dev, "rx"); + if (IS_ERR(adc->dma_chan)) { + int ret = PTR_ERR(adc->dma_chan); + +@@ -1425,7 +1426,7 @@ static int stm32_dfsdm_adc_chan_init_one(struct iio_dev *indio_dev, + &adc->dfsdm->ch_list[ch->channel]); + } + +-static int stm32_dfsdm_audio_init(struct iio_dev *indio_dev) ++static int stm32_dfsdm_audio_init(struct device *dev, struct iio_dev *indio_dev) + { + struct iio_chan_spec *ch; + struct stm32_dfsdm_adc *adc = iio_priv(indio_dev); +@@ -1452,10 +1453,10 @@ static int stm32_dfsdm_audio_init(struct iio_dev *indio_dev) + indio_dev->num_channels = 1; + indio_dev->channels = ch; + +- return stm32_dfsdm_dma_request(indio_dev); ++ return stm32_dfsdm_dma_request(dev, indio_dev); + } + +-static int stm32_dfsdm_adc_init(struct iio_dev *indio_dev) ++static int stm32_dfsdm_adc_init(struct device *dev, struct iio_dev *indio_dev) + { + struct iio_chan_spec *ch; + struct stm32_dfsdm_adc *adc = iio_priv(indio_dev); +@@ -1499,17 +1500,17 @@ static int stm32_dfsdm_adc_init(struct iio_dev *indio_dev) + init_completion(&adc->completion); + + /* Optionally request DMA */ +- ret = stm32_dfsdm_dma_request(indio_dev); ++ ret = stm32_dfsdm_dma_request(dev, indio_dev); + if (ret) { + if (ret != -ENODEV) { + if (ret != -EPROBE_DEFER) +- dev_err(&indio_dev->dev, ++ dev_err(dev, + "DMA channel request failed with %d\n", + ret); + return ret; + } + +- dev_dbg(&indio_dev->dev, "No DMA support\n"); ++ dev_dbg(dev, "No DMA support\n"); + return 0; + } + +@@ -1622,7 +1623,7 @@ static int stm32_dfsdm_adc_probe(struct platform_device *pdev) + adc->dfsdm->fl_list[adc->fl_id].sync_mode = val; + + adc->dev_data = dev_data; +- ret = dev_data->init(iio); ++ ret = dev_data->init(dev, iio); + if (ret < 0) + return ret; + +diff --git a/drivers/iio/adc/ti-ads8344.c b/drivers/iio/adc/ti-ads8344.c +index abe4b56c847c..8a8792010c20 100644 +--- a/drivers/iio/adc/ti-ads8344.c ++++ b/drivers/iio/adc/ti-ads8344.c +@@ -32,16 +32,17 @@ struct ads8344 { + u8 rx_buf[3]; + }; + +-#define ADS8344_VOLTAGE_CHANNEL(chan, si) \ ++#define ADS8344_VOLTAGE_CHANNEL(chan, addr) \ + { \ + .type = IIO_VOLTAGE, \ + .indexed = 1, \ + .channel = chan, \ + .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ + .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ ++ .address = addr, \ + } + +-#define ADS8344_VOLTAGE_CHANNEL_DIFF(chan1, chan2, si) \ ++#define ADS8344_VOLTAGE_CHANNEL_DIFF(chan1, chan2, addr) \ + { \ + .type = IIO_VOLTAGE, \ + .indexed = 1, \ +@@ -50,6 +51,7 @@ struct ads8344 { + .differential = 1, \ + .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ + .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ ++ .address = addr, \ + } + + static const struct iio_chan_spec ads8344_channels[] = { +@@ -105,7 +107,7 @@ static int ads8344_read_raw(struct iio_dev *iio, + switch (mask) { + case IIO_CHAN_INFO_RAW: + mutex_lock(&adc->lock); +- *value = ads8344_adc_conversion(adc, channel->scan_index, ++ *value = ads8344_adc_conversion(adc, channel->address, + channel->differential); + mutex_unlock(&adc->lock); + if (*value < 0) +diff --git a/drivers/iio/dac/vf610_dac.c b/drivers/iio/dac/vf610_dac.c +index 71f8a5c471c4..7f1e9317c3f3 100644 +--- a/drivers/iio/dac/vf610_dac.c ++++ b/drivers/iio/dac/vf610_dac.c +@@ -223,6 +223,7 @@ static int vf610_dac_probe(struct platform_device *pdev) + return 0; + + error_iio_device_register: ++ vf610_dac_exit(info); + clk_disable_unprepare(info->clk); + + return ret; +diff --git a/drivers/iio/imu/st_lsm6dsx/st_lsm6dsx_shub.c b/drivers/iio/imu/st_lsm6dsx/st_lsm6dsx_shub.c +index 64ef07a30726..1cf98195f84d 100644 +--- a/drivers/iio/imu/st_lsm6dsx/st_lsm6dsx_shub.c ++++ b/drivers/iio/imu/st_lsm6dsx/st_lsm6dsx_shub.c +@@ -544,8 +544,10 @@ st_lsm6dsx_shub_write_raw(struct iio_dev *iio_dev, + + ref_sensor = iio_priv(hw->iio_devs[ST_LSM6DSX_ID_ACC]); + odr = st_lsm6dsx_check_odr(ref_sensor, val, &odr_val); +- if (odr < 0) +- return odr; ++ if (odr < 0) { ++ err = odr; ++ goto release; ++ } + + sensor->ext_info.slv_odr = val; + sensor->odr = odr; +@@ -557,6 +559,7 @@ st_lsm6dsx_shub_write_raw(struct iio_dev *iio_dev, + break; + } + ++release: + iio_device_release_direct_mode(iio_dev); + + return err; +diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c +index 500d0a8c966f..2aa46a6de172 100644 +--- a/drivers/iommu/amd_iommu.c ++++ b/drivers/iommu/amd_iommu.c +@@ -127,7 +127,8 @@ static inline int get_acpihid_device_id(struct device *dev, + return -ENODEV; + + list_for_each_entry(p, &acpihid_map, list) { +- if (acpi_dev_hid_uid_match(adev, p->hid, p->uid)) { ++ if (acpi_dev_hid_uid_match(adev, p->hid, ++ p->uid[0] ? p->uid : NULL)) { + if (entry) + *entry = p; + return p->devid; +@@ -1499,8 +1500,19 @@ static u64 *alloc_pte(struct protection_domain *domain, + amd_iommu_domain_get_pgtable(domain, &pgtable); + + while (address > PM_LEVEL_SIZE(pgtable.mode)) { +- *updated = increase_address_space(domain, address, gfp) || *updated; ++ bool upd = increase_address_space(domain, address, gfp); ++ ++ /* Read new values to check if update was successful */ + amd_iommu_domain_get_pgtable(domain, &pgtable); ++ ++ /* ++ * Return an error if there is no memory to update the ++ * page-table. ++ */ ++ if (!upd && (address > PM_LEVEL_SIZE(pgtable.mode))) ++ return NULL; ++ ++ *updated = *updated || upd; + } + + +@@ -2333,6 +2345,7 @@ static void update_domain(struct protection_domain *domain) + + /* Flush domain TLB(s) and wait for completion */ + domain_flush_tlb_pde(domain); ++ domain_flush_complete(domain); + } + + int __init amd_iommu_init_api(void) +diff --git a/drivers/iommu/amd_iommu_init.c b/drivers/iommu/amd_iommu_init.c +index 2b9a67ecc6ac..5b81fd16f5fa 100644 +--- a/drivers/iommu/amd_iommu_init.c ++++ b/drivers/iommu/amd_iommu_init.c +@@ -1329,8 +1329,8 @@ static int __init init_iommu_from_acpi(struct amd_iommu *iommu, + } + case IVHD_DEV_ACPI_HID: { + u16 devid; +- u8 hid[ACPIHID_HID_LEN] = {0}; +- u8 uid[ACPIHID_UID_LEN] = {0}; ++ u8 hid[ACPIHID_HID_LEN]; ++ u8 uid[ACPIHID_UID_LEN]; + int ret; + + if (h->type != 0x40) { +@@ -1347,6 +1347,7 @@ static int __init init_iommu_from_acpi(struct amd_iommu *iommu, + break; + } + ++ uid[0] = '\0'; + switch (e->uidf) { + case UID_NOT_PRESENT: + +@@ -1361,8 +1362,8 @@ static int __init init_iommu_from_acpi(struct amd_iommu *iommu, + break; + case UID_IS_CHARACTER: + +- memcpy(uid, (u8 *)(&e->uid), ACPIHID_UID_LEN - 1); +- uid[ACPIHID_UID_LEN - 1] = '\0'; ++ memcpy(uid, &e->uid, e->uidl); ++ uid[e->uidl] = '\0'; + + break; + default: +diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c +index 8d2477941fd9..22b28076d48e 100644 +--- a/drivers/iommu/iommu.c ++++ b/drivers/iommu/iommu.c +@@ -692,6 +692,15 @@ out: + return ret; + } + ++static bool iommu_is_attach_deferred(struct iommu_domain *domain, ++ struct device *dev) ++{ ++ if (domain->ops->is_attach_deferred) ++ return domain->ops->is_attach_deferred(domain, dev); ++ ++ return false; ++} ++ + /** + * iommu_group_add_device - add a device to an iommu group + * @group: the group into which to add the device (reference should be held) +@@ -746,7 +755,7 @@ rename: + + mutex_lock(&group->mutex); + list_add_tail(&device->list, &group->devices); +- if (group->domain) ++ if (group->domain && !iommu_is_attach_deferred(group->domain, dev)) + ret = __iommu_attach_device(group->domain, dev); + mutex_unlock(&group->mutex); + if (ret) +@@ -1652,9 +1661,6 @@ static int __iommu_attach_device(struct iommu_domain *domain, + struct device *dev) + { + int ret; +- if ((domain->ops->is_attach_deferred != NULL) && +- domain->ops->is_attach_deferred(domain, dev)) +- return 0; + + if (unlikely(domain->ops->attach_dev == NULL)) + return -ENODEV; +@@ -1726,8 +1732,7 @@ EXPORT_SYMBOL_GPL(iommu_sva_unbind_gpasid); + static void __iommu_detach_device(struct iommu_domain *domain, + struct device *dev) + { +- if ((domain->ops->is_attach_deferred != NULL) && +- domain->ops->is_attach_deferred(domain, dev)) ++ if (iommu_is_attach_deferred(domain, dev)) + return; + + if (unlikely(domain->ops->detach_dev == NULL)) +diff --git a/drivers/ipack/carriers/tpci200.c b/drivers/ipack/carriers/tpci200.c +index 23445ebfda5c..ec71063fff76 100644 +--- a/drivers/ipack/carriers/tpci200.c ++++ b/drivers/ipack/carriers/tpci200.c +@@ -306,6 +306,7 @@ static int tpci200_register(struct tpci200_board *tpci200) + "(bn 0x%X, sn 0x%X) failed to map driver user space!", + tpci200->info->pdev->bus->number, + tpci200->info->pdev->devfn); ++ res = -ENOMEM; + goto out_release_mem8_space; + } + +diff --git a/drivers/misc/cardreader/rtsx_pcr.c b/drivers/misc/cardreader/rtsx_pcr.c +index 06038b325b02..55da6428ceb0 100644 +--- a/drivers/misc/cardreader/rtsx_pcr.c ++++ b/drivers/misc/cardreader/rtsx_pcr.c +@@ -142,6 +142,9 @@ static void rtsx_comm_pm_full_on(struct rtsx_pcr *pcr) + + rtsx_disable_aspm(pcr); + ++ /* Fixes DMA transfer timout issue after disabling ASPM on RTS5260 */ ++ msleep(1); ++ + if (option->ltr_enabled) + rtsx_set_ltr_latency(pcr, option->ltr_active_latency); + +diff --git a/drivers/misc/mei/client.c b/drivers/misc/mei/client.c +index 1e3edbbacb1e..c6b163060c76 100644 +--- a/drivers/misc/mei/client.c ++++ b/drivers/misc/mei/client.c +@@ -266,6 +266,7 @@ void mei_me_cl_rm_by_uuid(struct mei_device *dev, const uuid_le *uuid) + down_write(&dev->me_clients_rwsem); + me_cl = __mei_me_cl_by_uuid(dev, uuid); + __mei_me_cl_del(dev, me_cl); ++ mei_me_cl_put(me_cl); + up_write(&dev->me_clients_rwsem); + } + +@@ -287,6 +288,7 @@ void mei_me_cl_rm_by_uuid_id(struct mei_device *dev, const uuid_le *uuid, u8 id) + down_write(&dev->me_clients_rwsem); + me_cl = __mei_me_cl_by_uuid_id(dev, uuid, id); + __mei_me_cl_del(dev, me_cl); ++ mei_me_cl_put(me_cl); + up_write(&dev->me_clients_rwsem); + } + +diff --git a/drivers/mtd/mtdcore.c b/drivers/mtd/mtdcore.c +index 5fac4355b9c2..559b6930b6f6 100644 +--- a/drivers/mtd/mtdcore.c ++++ b/drivers/mtd/mtdcore.c +@@ -551,7 +551,7 @@ static int mtd_nvmem_add(struct mtd_info *mtd) + + config.id = -1; + config.dev = &mtd->dev; +- config.name = mtd->name; ++ config.name = dev_name(&mtd->dev); + config.owner = THIS_MODULE; + config.reg_read = mtd_nvmem_reg_read; + config.size = mtd->size; +diff --git a/drivers/mtd/nand/spi/core.c b/drivers/mtd/nand/spi/core.c +index 8dda51bbdd11..0d21c68bfe24 100644 +--- a/drivers/mtd/nand/spi/core.c ++++ b/drivers/mtd/nand/spi/core.c +@@ -1049,6 +1049,10 @@ static int spinand_init(struct spinand_device *spinand) + + mtd->oobavail = ret; + ++ /* Propagate ECC information to mtd_info */ ++ mtd->ecc_strength = nand->eccreq.strength; ++ mtd->ecc_step_size = nand->eccreq.step_size; ++ + return 0; + + err_cleanup_nanddev: +diff --git a/drivers/mtd/ubi/debug.c b/drivers/mtd/ubi/debug.c +index 54646c2c2744..ac2bdba8bb1a 100644 +--- a/drivers/mtd/ubi/debug.c ++++ b/drivers/mtd/ubi/debug.c +@@ -393,9 +393,6 @@ static void *eraseblk_count_seq_start(struct seq_file *s, loff_t *pos) + { + struct ubi_device *ubi = s->private; + +- if (*pos == 0) +- return SEQ_START_TOKEN; +- + if (*pos < ubi->peb_count) + return pos; + +@@ -409,8 +406,6 @@ static void *eraseblk_count_seq_next(struct seq_file *s, void *v, loff_t *pos) + { + struct ubi_device *ubi = s->private; + +- if (v == SEQ_START_TOKEN) +- return pos; + (*pos)++; + + if (*pos < ubi->peb_count) +@@ -432,11 +427,8 @@ static int eraseblk_count_seq_show(struct seq_file *s, void *iter) + int err; + + /* If this is the start, print a header */ +- if (iter == SEQ_START_TOKEN) { +- seq_puts(s, +- "physical_block_number\terase_count\tblock_status\tread_status\n"); +- return 0; +- } ++ if (*block_number == 0) ++ seq_puts(s, "physical_block_number\terase_count\n"); + + err = ubi_io_is_bad(ubi, *block_number); + if (err) +diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.h b/drivers/net/ethernet/amazon/ena/ena_netdev.h +index 8795e0b1dc3c..8984aa211112 100644 +--- a/drivers/net/ethernet/amazon/ena/ena_netdev.h ++++ b/drivers/net/ethernet/amazon/ena/ena_netdev.h +@@ -69,7 +69,7 @@ + * 16kB. + */ + #if PAGE_SIZE > SZ_16K +-#define ENA_PAGE_SIZE SZ_16K ++#define ENA_PAGE_SIZE (_AC(SZ_16K, UL)) + #else + #define ENA_PAGE_SIZE PAGE_SIZE + #endif +diff --git a/drivers/net/ethernet/aquantia/atlantic/aq_pci_func.c b/drivers/net/ethernet/aquantia/atlantic/aq_pci_func.c +index 78b6f3248756..e0625c67eed3 100644 +--- a/drivers/net/ethernet/aquantia/atlantic/aq_pci_func.c ++++ b/drivers/net/ethernet/aquantia/atlantic/aq_pci_func.c +@@ -56,7 +56,7 @@ static const struct aq_board_revision_s hw_atl_boards[] = { + { AQ_DEVICE_ID_D108, AQ_HWREV_2, &hw_atl_ops_b0, &hw_atl_b0_caps_aqc108, }, + { AQ_DEVICE_ID_D109, AQ_HWREV_2, &hw_atl_ops_b0, &hw_atl_b0_caps_aqc109, }, + +- { AQ_DEVICE_ID_AQC100, AQ_HWREV_ANY, &hw_atl_ops_b1, &hw_atl_b0_caps_aqc107, }, ++ { AQ_DEVICE_ID_AQC100, AQ_HWREV_ANY, &hw_atl_ops_b1, &hw_atl_b0_caps_aqc100, }, + { AQ_DEVICE_ID_AQC107, AQ_HWREV_ANY, &hw_atl_ops_b1, &hw_atl_b0_caps_aqc107, }, + { AQ_DEVICE_ID_AQC108, AQ_HWREV_ANY, &hw_atl_ops_b1, &hw_atl_b0_caps_aqc108, }, + { AQ_DEVICE_ID_AQC109, AQ_HWREV_ANY, &hw_atl_ops_b1, &hw_atl_b0_caps_aqc109, }, +diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c +index 4bd33245bad6..3de549c6c693 100644 +--- a/drivers/net/ethernet/ibm/ibmvnic.c ++++ b/drivers/net/ethernet/ibm/ibmvnic.c +@@ -2189,7 +2189,8 @@ static void __ibmvnic_reset(struct work_struct *work) + rc = do_hard_reset(adapter, rwi, reset_state); + rtnl_unlock(); + } +- } else { ++ } else if (!(rwi->reset_reason == VNIC_RESET_FATAL && ++ adapter->from_passive_init)) { + rc = do_reset(adapter, rwi, reset_state); + } + kfree(rwi); +diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c +index 7da18c9afa01..d564459290ce 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c ++++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c +@@ -3988,7 +3988,7 @@ static int stmmac_set_features(struct net_device *netdev, + /** + * stmmac_interrupt - main ISR + * @irq: interrupt number. +- * @dev_id: to pass the net device pointer. ++ * @dev_id: to pass the net device pointer (must be valid). + * Description: this is the main driver interrupt service routine. + * It can call: + * o DMA service routine (to manage incoming frame reception and transmission +@@ -4012,11 +4012,6 @@ static irqreturn_t stmmac_interrupt(int irq, void *dev_id) + if (priv->irq_wake) + pm_wakeup_event(priv->device, 0); + +- if (unlikely(!dev)) { +- netdev_err(priv->dev, "%s: invalid dev pointer\n", __func__); +- return IRQ_NONE; +- } +- + /* Check if adapter is up */ + if (test_bit(STMMAC_DOWN, &priv->state)) + return IRQ_HANDLED; +diff --git a/drivers/net/gtp.c b/drivers/net/gtp.c +index 672cd2caf2fb..21640a035d7d 100644 +--- a/drivers/net/gtp.c ++++ b/drivers/net/gtp.c +@@ -1169,11 +1169,11 @@ out_unlock: + static struct genl_family gtp_genl_family; + + static int gtp_genl_fill_info(struct sk_buff *skb, u32 snd_portid, u32 snd_seq, +- u32 type, struct pdp_ctx *pctx) ++ int flags, u32 type, struct pdp_ctx *pctx) + { + void *genlh; + +- genlh = genlmsg_put(skb, snd_portid, snd_seq, >p_genl_family, 0, ++ genlh = genlmsg_put(skb, snd_portid, snd_seq, >p_genl_family, flags, + type); + if (genlh == NULL) + goto nlmsg_failure; +@@ -1227,8 +1227,8 @@ static int gtp_genl_get_pdp(struct sk_buff *skb, struct genl_info *info) + goto err_unlock; + } + +- err = gtp_genl_fill_info(skb2, NETLINK_CB(skb).portid, +- info->snd_seq, info->nlhdr->nlmsg_type, pctx); ++ err = gtp_genl_fill_info(skb2, NETLINK_CB(skb).portid, info->snd_seq, ++ 0, info->nlhdr->nlmsg_type, pctx); + if (err < 0) + goto err_unlock_free; + +@@ -1271,6 +1271,7 @@ static int gtp_genl_dump_pdp(struct sk_buff *skb, + gtp_genl_fill_info(skb, + NETLINK_CB(cb->skb).portid, + cb->nlh->nlmsg_seq, ++ NLM_F_MULTI, + cb->nlh->nlmsg_type, pctx)) { + cb->args[0] = i; + cb->args[1] = j; +diff --git a/drivers/pinctrl/qcom/pinctrl-msm.c b/drivers/pinctrl/qcom/pinctrl-msm.c +index 9f1c9951949e..14a8f8fa0ea3 100644 +--- a/drivers/pinctrl/qcom/pinctrl-msm.c ++++ b/drivers/pinctrl/qcom/pinctrl-msm.c +@@ -1010,6 +1010,29 @@ static void msm_gpio_irq_relres(struct irq_data *d) + module_put(gc->owner); + } + ++static int msm_gpio_irq_set_affinity(struct irq_data *d, ++ const struct cpumask *dest, bool force) ++{ ++ struct gpio_chip *gc = irq_data_get_irq_chip_data(d); ++ struct msm_pinctrl *pctrl = gpiochip_get_data(gc); ++ ++ if (d->parent_data && test_bit(d->hwirq, pctrl->skip_wake_irqs)) ++ return irq_chip_set_affinity_parent(d, dest, force); ++ ++ return 0; ++} ++ ++static int msm_gpio_irq_set_vcpu_affinity(struct irq_data *d, void *vcpu_info) ++{ ++ struct gpio_chip *gc = irq_data_get_irq_chip_data(d); ++ struct msm_pinctrl *pctrl = gpiochip_get_data(gc); ++ ++ if (d->parent_data && test_bit(d->hwirq, pctrl->skip_wake_irqs)) ++ return irq_chip_set_vcpu_affinity_parent(d, vcpu_info); ++ ++ return 0; ++} ++ + static void msm_gpio_irq_handler(struct irq_desc *desc) + { + struct gpio_chip *gc = irq_desc_get_handler_data(desc); +@@ -1108,6 +1131,8 @@ static int msm_gpio_init(struct msm_pinctrl *pctrl) + pctrl->irq_chip.irq_set_wake = msm_gpio_irq_set_wake; + pctrl->irq_chip.irq_request_resources = msm_gpio_irq_reqres; + pctrl->irq_chip.irq_release_resources = msm_gpio_irq_relres; ++ pctrl->irq_chip.irq_set_affinity = msm_gpio_irq_set_affinity; ++ pctrl->irq_chip.irq_set_vcpu_affinity = msm_gpio_irq_set_vcpu_affinity; + + np = of_parse_phandle(pctrl->dev->of_node, "wakeup-parent", 0); + if (np) { +diff --git a/drivers/platform/x86/asus-nb-wmi.c b/drivers/platform/x86/asus-nb-wmi.c +index 6f12747a359a..c4404d9c1de4 100644 +--- a/drivers/platform/x86/asus-nb-wmi.c ++++ b/drivers/platform/x86/asus-nb-wmi.c +@@ -515,9 +515,33 @@ static struct asus_wmi_driver asus_nb_wmi_driver = { + .detect_quirks = asus_nb_wmi_quirks, + }; + ++static const struct dmi_system_id asus_nb_wmi_blacklist[] __initconst = { ++ { ++ /* ++ * asus-nb-wm adds no functionality. The T100TA has a detachable ++ * USB kbd, so no hotkeys and it has no WMI rfkill; and loading ++ * asus-nb-wm causes the camera LED to turn and _stay_ on. ++ */ ++ .matches = { ++ DMI_EXACT_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."), ++ DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "T100TA"), ++ }, ++ }, ++ { ++ /* The Asus T200TA has the same issue as the T100TA */ ++ .matches = { ++ DMI_EXACT_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."), ++ DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "T200TA"), ++ }, ++ }, ++ {} /* Terminating entry */ ++}; + + static int __init asus_nb_wmi_init(void) + { ++ if (dmi_check_system(asus_nb_wmi_blacklist)) ++ return -ENODEV; ++ + return asus_wmi_register_driver(&asus_nb_wmi_driver); + } + +diff --git a/drivers/rapidio/devices/rio_mport_cdev.c b/drivers/rapidio/devices/rio_mport_cdev.c +index 8155f59ece38..10af330153b5 100644 +--- a/drivers/rapidio/devices/rio_mport_cdev.c ++++ b/drivers/rapidio/devices/rio_mport_cdev.c +@@ -877,6 +877,11 @@ rio_dma_transfer(struct file *filp, u32 transfer_mode, + rmcd_error("pinned %ld out of %ld pages", + pinned, nr_pages); + ret = -EFAULT; ++ /* ++ * Set nr_pages up to mean "how many pages to unpin, in ++ * the error handler: ++ */ ++ nr_pages = pinned; + goto err_pg; + } + +diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.c b/drivers/scsi/ibmvscsi/ibmvscsi.c +index 7f66a7783209..59f0f1030c54 100644 +--- a/drivers/scsi/ibmvscsi/ibmvscsi.c ++++ b/drivers/scsi/ibmvscsi/ibmvscsi.c +@@ -2320,16 +2320,12 @@ static int ibmvscsi_probe(struct vio_dev *vdev, const struct vio_device_id *id) + static int ibmvscsi_remove(struct vio_dev *vdev) + { + struct ibmvscsi_host_data *hostdata = dev_get_drvdata(&vdev->dev); +- unsigned long flags; + + srp_remove_host(hostdata->host); + scsi_remove_host(hostdata->host); + + purge_requests(hostdata, DID_ERROR); +- +- spin_lock_irqsave(hostdata->host->host_lock, flags); + release_event_pool(&hostdata->pool, hostdata); +- spin_unlock_irqrestore(hostdata->host->host_lock, flags); + + ibmvscsi_release_crq_queue(&hostdata->queue, hostdata, + max_events); +diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c +index d7e7043f9eab..e3c45edd0e18 100644 +--- a/drivers/scsi/qla2xxx/qla_attr.c ++++ b/drivers/scsi/qla2xxx/qla_attr.c +@@ -1777,9 +1777,6 @@ qla2x00_port_speed_show(struct device *dev, struct device_attribute *attr, + return -EINVAL; + } + +- ql_log(ql_log_info, vha, 0x70d6, +- "port speed:%d\n", ha->link_data_rate); +- + return scnprintf(buf, PAGE_SIZE, "%s\n", spd[ha->link_data_rate]); + } + +@@ -2928,11 +2925,11 @@ qla24xx_vport_delete(struct fc_vport *fc_vport) + test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags)) + msleep(1000); + +- qla_nvme_delete(vha); + + qla24xx_disable_vp(vha); + qla2x00_wait_for_sess_deletion(vha); + ++ qla_nvme_delete(vha); + vha->flags.delete_progress = 1; + + qlt_remove_target(ha, vha); +diff --git a/drivers/scsi/qla2xxx/qla_mbx.c b/drivers/scsi/qla2xxx/qla_mbx.c +index 9e09964f5c0e..7b341e41bb85 100644 +--- a/drivers/scsi/qla2xxx/qla_mbx.c ++++ b/drivers/scsi/qla2xxx/qla_mbx.c +@@ -3117,7 +3117,7 @@ qla24xx_abort_command(srb_t *sp) + ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x108c, + "Entered %s.\n", __func__); + +- if (vha->flags.qpairs_available && sp->qpair) ++ if (sp->qpair) + req = sp->qpair->req; + else + return QLA_FUNCTION_FAILED; +diff --git a/drivers/staging/greybus/uart.c b/drivers/staging/greybus/uart.c +index 55c51143bb09..4ffb334cd5cd 100644 +--- a/drivers/staging/greybus/uart.c ++++ b/drivers/staging/greybus/uart.c +@@ -537,9 +537,9 @@ static void gb_tty_set_termios(struct tty_struct *tty, + } + + if (C_CRTSCTS(tty) && C_BAUD(tty) != B0) +- newline.flow_control |= GB_SERIAL_AUTO_RTSCTS_EN; ++ newline.flow_control = GB_SERIAL_AUTO_RTSCTS_EN; + else +- newline.flow_control &= ~GB_SERIAL_AUTO_RTSCTS_EN; ++ newline.flow_control = 0; + + if (memcmp(&gb_tty->line_coding, &newline, sizeof(newline))) { + memcpy(&gb_tty->line_coding, &newline, sizeof(newline)); +diff --git a/drivers/staging/iio/resolver/ad2s1210.c b/drivers/staging/iio/resolver/ad2s1210.c +index 4b25a3a314ed..ed404355ea4c 100644 +--- a/drivers/staging/iio/resolver/ad2s1210.c ++++ b/drivers/staging/iio/resolver/ad2s1210.c +@@ -130,17 +130,24 @@ static int ad2s1210_config_write(struct ad2s1210_state *st, u8 data) + static int ad2s1210_config_read(struct ad2s1210_state *st, + unsigned char address) + { +- struct spi_transfer xfer = { +- .len = 2, +- .rx_buf = st->rx, +- .tx_buf = st->tx, ++ struct spi_transfer xfers[] = { ++ { ++ .len = 1, ++ .rx_buf = &st->rx[0], ++ .tx_buf = &st->tx[0], ++ .cs_change = 1, ++ }, { ++ .len = 1, ++ .rx_buf = &st->rx[1], ++ .tx_buf = &st->tx[1], ++ }, + }; + int ret = 0; + + ad2s1210_set_mode(MOD_CONFIG, st); + st->tx[0] = address | AD2S1210_MSB_IS_HIGH; + st->tx[1] = AD2S1210_REG_FAULT; +- ret = spi_sync_transfer(st->sdev, &xfer, 1); ++ ret = spi_sync_transfer(st->sdev, xfers, 2); + if (ret < 0) + return ret; + +diff --git a/drivers/staging/kpc2000/kpc2000/core.c b/drivers/staging/kpc2000/kpc2000/core.c +index 7b00d7069e21..358d7b2f4ad1 100644 +--- a/drivers/staging/kpc2000/kpc2000/core.c ++++ b/drivers/staging/kpc2000/kpc2000/core.c +@@ -298,7 +298,6 @@ static int kp2000_pcie_probe(struct pci_dev *pdev, + { + int err = 0; + struct kp2000_device *pcard; +- int rv; + unsigned long reg_bar_phys_addr; + unsigned long reg_bar_phys_len; + unsigned long dma_bar_phys_addr; +@@ -445,11 +444,11 @@ static int kp2000_pcie_probe(struct pci_dev *pdev, + if (err < 0) + goto err_release_dma; + +- rv = request_irq(pcard->pdev->irq, kp2000_irq_handler, IRQF_SHARED, +- pcard->name, pcard); +- if (rv) { ++ err = request_irq(pcard->pdev->irq, kp2000_irq_handler, IRQF_SHARED, ++ pcard->name, pcard); ++ if (err) { + dev_err(&pcard->pdev->dev, +- "%s: failed to request_irq: %d\n", __func__, rv); ++ "%s: failed to request_irq: %d\n", __func__, err); + goto err_disable_msi; + } + +diff --git a/drivers/staging/wfx/scan.c b/drivers/staging/wfx/scan.c +index 6e1e50048651..9aa14331affd 100644 +--- a/drivers/staging/wfx/scan.c ++++ b/drivers/staging/wfx/scan.c +@@ -57,8 +57,10 @@ static int send_scan_req(struct wfx_vif *wvif, + wvif->scan_abort = false; + reinit_completion(&wvif->scan_complete); + timeout = hif_scan(wvif, req, start_idx, i - start_idx); +- if (timeout < 0) ++ if (timeout < 0) { ++ wfx_tx_unlock(wvif->wdev); + return timeout; ++ } + ret = wait_for_completion_timeout(&wvif->scan_complete, timeout); + if (req->channels[start_idx]->max_power != wvif->vif->bss_conf.txpower) + hif_set_output_power(wvif, wvif->vif->bss_conf.txpower); +diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c +index 0ae9e60fc4d5..61486e5abee4 100644 +--- a/drivers/target/target_core_transport.c ++++ b/drivers/target/target_core_transport.c +@@ -3349,6 +3349,7 @@ static void target_tmr_work(struct work_struct *work) + + cmd->se_tfo->queue_tm_rsp(cmd); + ++ transport_lun_remove_cmd(cmd); + transport_cmd_check_stop_to_fabric(cmd); + return; + +diff --git a/drivers/tty/serial/sifive.c b/drivers/tty/serial/sifive.c +index d5f81b98e4d7..38133eba83a8 100644 +--- a/drivers/tty/serial/sifive.c ++++ b/drivers/tty/serial/sifive.c +@@ -840,6 +840,7 @@ console_initcall(sifive_console_init); + + static void __ssp_add_console_port(struct sifive_serial_port *ssp) + { ++ spin_lock_init(&ssp->port.lock); + sifive_serial_console_ports[ssp->port.line] = ssp; + } + +diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c +index 02eaac7e1e34..a1ac2f0723b0 100644 +--- a/drivers/usb/core/message.c ++++ b/drivers/usb/core/message.c +@@ -1143,11 +1143,11 @@ void usb_disable_endpoint(struct usb_device *dev, unsigned int epaddr, + + if (usb_endpoint_out(epaddr)) { + ep = dev->ep_out[epnum]; +- if (reset_hardware) ++ if (reset_hardware && epnum != 0) + dev->ep_out[epnum] = NULL; + } else { + ep = dev->ep_in[epnum]; +- if (reset_hardware) ++ if (reset_hardware && epnum != 0) + dev->ep_in[epnum] = NULL; + } + if (ep) { +diff --git a/drivers/vhost/vsock.c b/drivers/vhost/vsock.c +index bb3f63386b47..53294c2f8cff 100644 +--- a/drivers/vhost/vsock.c ++++ b/drivers/vhost/vsock.c +@@ -181,14 +181,14 @@ vhost_transport_do_send_pkt(struct vhost_vsock *vsock, + break; + } + +- vhost_add_used(vq, head, sizeof(pkt->hdr) + payload_len); +- added = true; +- +- /* Deliver to monitoring devices all correctly transmitted +- * packets. ++ /* Deliver to monitoring devices all packets that we ++ * will transmit. + */ + virtio_transport_deliver_tap_pkt(pkt); + ++ vhost_add_used(vq, head, sizeof(pkt->hdr) + payload_len); ++ added = true; ++ + pkt->off += payload_len; + total_len += payload_len; + +diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c +index 44375a22307b..341458fd95ca 100644 +--- a/drivers/virtio/virtio_balloon.c ++++ b/drivers/virtio/virtio_balloon.c +@@ -14,7 +14,6 @@ + #include + #include + #include +-#include + #include + #include + #include +@@ -28,9 +27,7 @@ + */ + #define VIRTIO_BALLOON_PAGES_PER_PAGE (unsigned)(PAGE_SIZE >> VIRTIO_BALLOON_PFN_SHIFT) + #define VIRTIO_BALLOON_ARRAY_PFNS_MAX 256 +-/* Maximum number of (4k) pages to deflate on OOM notifications. */ +-#define VIRTIO_BALLOON_OOM_NR_PAGES 256 +-#define VIRTIO_BALLOON_OOM_NOTIFY_PRIORITY 80 ++#define VIRTBALLOON_OOM_NOTIFY_PRIORITY 80 + + #define VIRTIO_BALLOON_FREE_PAGE_ALLOC_FLAG (__GFP_NORETRY | __GFP_NOWARN | \ + __GFP_NOMEMALLOC) +@@ -115,11 +112,8 @@ struct virtio_balloon { + /* Memory statistics */ + struct virtio_balloon_stat stats[VIRTIO_BALLOON_S_NR]; + +- /* Shrinker to return free pages - VIRTIO_BALLOON_F_FREE_PAGE_HINT */ ++ /* To register a shrinker to shrink memory upon memory pressure */ + struct shrinker shrinker; +- +- /* OOM notifier to deflate on OOM - VIRTIO_BALLOON_F_DEFLATE_ON_OOM */ +- struct notifier_block oom_nb; + }; + + static struct virtio_device_id id_table[] = { +@@ -794,13 +788,50 @@ static unsigned long shrink_free_pages(struct virtio_balloon *vb, + return blocks_freed * VIRTIO_BALLOON_HINT_BLOCK_PAGES; + } + ++static unsigned long leak_balloon_pages(struct virtio_balloon *vb, ++ unsigned long pages_to_free) ++{ ++ return leak_balloon(vb, pages_to_free * VIRTIO_BALLOON_PAGES_PER_PAGE) / ++ VIRTIO_BALLOON_PAGES_PER_PAGE; ++} ++ ++static unsigned long shrink_balloon_pages(struct virtio_balloon *vb, ++ unsigned long pages_to_free) ++{ ++ unsigned long pages_freed = 0; ++ ++ /* ++ * One invocation of leak_balloon can deflate at most ++ * VIRTIO_BALLOON_ARRAY_PFNS_MAX balloon pages, so we call it ++ * multiple times to deflate pages till reaching pages_to_free. ++ */ ++ while (vb->num_pages && pages_freed < pages_to_free) ++ pages_freed += leak_balloon_pages(vb, ++ pages_to_free - pages_freed); ++ ++ update_balloon_size(vb); ++ ++ return pages_freed; ++} ++ + static unsigned long virtio_balloon_shrinker_scan(struct shrinker *shrinker, + struct shrink_control *sc) + { ++ unsigned long pages_to_free, pages_freed = 0; + struct virtio_balloon *vb = container_of(shrinker, + struct virtio_balloon, shrinker); + +- return shrink_free_pages(vb, sc->nr_to_scan); ++ pages_to_free = sc->nr_to_scan; ++ ++ if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_HINT)) ++ pages_freed = shrink_free_pages(vb, pages_to_free); ++ ++ if (pages_freed >= pages_to_free) ++ return pages_freed; ++ ++ pages_freed += shrink_balloon_pages(vb, pages_to_free - pages_freed); ++ ++ return pages_freed; + } + + static unsigned long virtio_balloon_shrinker_count(struct shrinker *shrinker, +@@ -808,22 +839,26 @@ static unsigned long virtio_balloon_shrinker_count(struct shrinker *shrinker, + { + struct virtio_balloon *vb = container_of(shrinker, + struct virtio_balloon, shrinker); ++ unsigned long count; ++ ++ count = vb->num_pages / VIRTIO_BALLOON_PAGES_PER_PAGE; ++ count += vb->num_free_page_blocks * VIRTIO_BALLOON_HINT_BLOCK_PAGES; + +- return vb->num_free_page_blocks * VIRTIO_BALLOON_HINT_BLOCK_PAGES; ++ return count; + } + +-static int virtio_balloon_oom_notify(struct notifier_block *nb, +- unsigned long dummy, void *parm) ++static void virtio_balloon_unregister_shrinker(struct virtio_balloon *vb) + { +- struct virtio_balloon *vb = container_of(nb, +- struct virtio_balloon, oom_nb); +- unsigned long *freed = parm; ++ unregister_shrinker(&vb->shrinker); ++} + +- *freed += leak_balloon(vb, VIRTIO_BALLOON_OOM_NR_PAGES) / +- VIRTIO_BALLOON_PAGES_PER_PAGE; +- update_balloon_size(vb); ++static int virtio_balloon_register_shrinker(struct virtio_balloon *vb) ++{ ++ vb->shrinker.scan_objects = virtio_balloon_shrinker_scan; ++ vb->shrinker.count_objects = virtio_balloon_shrinker_count; ++ vb->shrinker.seeks = DEFAULT_SEEKS; + +- return NOTIFY_OK; ++ return register_shrinker(&vb->shrinker); + } + + static int virtballoon_probe(struct virtio_device *vdev) +@@ -900,35 +935,22 @@ static int virtballoon_probe(struct virtio_device *vdev) + virtio_cwrite(vb->vdev, struct virtio_balloon_config, + poison_val, &poison_val); + } +- +- /* +- * We're allowed to reuse any free pages, even if they are +- * still to be processed by the host. +- */ +- vb->shrinker.scan_objects = virtio_balloon_shrinker_scan; +- vb->shrinker.count_objects = virtio_balloon_shrinker_count; +- vb->shrinker.seeks = DEFAULT_SEEKS; +- err = register_shrinker(&vb->shrinker); ++ } ++ /* ++ * We continue to use VIRTIO_BALLOON_F_DEFLATE_ON_OOM to decide if a ++ * shrinker needs to be registered to relieve memory pressure. ++ */ ++ if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_DEFLATE_ON_OOM)) { ++ err = virtio_balloon_register_shrinker(vb); + if (err) + goto out_del_balloon_wq; + } +- if (virtio_has_feature(vdev, VIRTIO_BALLOON_F_DEFLATE_ON_OOM)) { +- vb->oom_nb.notifier_call = virtio_balloon_oom_notify; +- vb->oom_nb.priority = VIRTIO_BALLOON_OOM_NOTIFY_PRIORITY; +- err = register_oom_notifier(&vb->oom_nb); +- if (err < 0) +- goto out_unregister_shrinker; +- } +- + virtio_device_ready(vdev); + + if (towards_target(vb)) + virtballoon_changed(vdev); + return 0; + +-out_unregister_shrinker: +- if (virtio_has_feature(vdev, VIRTIO_BALLOON_F_FREE_PAGE_HINT)) +- unregister_shrinker(&vb->shrinker); + out_del_balloon_wq: + if (virtio_has_feature(vdev, VIRTIO_BALLOON_F_FREE_PAGE_HINT)) + destroy_workqueue(vb->balloon_wq); +@@ -967,11 +989,8 @@ static void virtballoon_remove(struct virtio_device *vdev) + { + struct virtio_balloon *vb = vdev->priv; + +- if (virtio_has_feature(vdev, VIRTIO_BALLOON_F_DEFLATE_ON_OOM)) +- unregister_oom_notifier(&vb->oom_nb); +- if (virtio_has_feature(vdev, VIRTIO_BALLOON_F_FREE_PAGE_HINT)) +- unregister_shrinker(&vb->shrinker); +- ++ if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_DEFLATE_ON_OOM)) ++ virtio_balloon_unregister_shrinker(vb); + spin_lock_irq(&vb->stop_update_lock); + vb->stop_update = true; + spin_unlock_irq(&vb->stop_update_lock); +diff --git a/fs/afs/fs_probe.c b/fs/afs/fs_probe.c +index e1b9ed679045..02e976ca5732 100644 +--- a/fs/afs/fs_probe.c ++++ b/fs/afs/fs_probe.c +@@ -32,9 +32,8 @@ void afs_fileserver_probe_result(struct afs_call *call) + struct afs_server *server = call->server; + unsigned int server_index = call->server_index; + unsigned int index = call->addr_ix; +- unsigned int rtt = UINT_MAX; ++ unsigned int rtt_us; + bool have_result = false; +- u64 _rtt; + int ret = call->error; + + _enter("%pU,%u", &server->uuid, index); +@@ -93,15 +92,9 @@ responded: + } + } + +- /* Get the RTT and scale it to fit into a 32-bit value that represents +- * over a minute of time so that we can access it with one instruction +- * on a 32-bit system. +- */ +- _rtt = rxrpc_kernel_get_rtt(call->net->socket, call->rxcall); +- _rtt /= 64; +- rtt = (_rtt > UINT_MAX) ? UINT_MAX : _rtt; +- if (rtt < server->probe.rtt) { +- server->probe.rtt = rtt; ++ rtt_us = rxrpc_kernel_get_srtt(call->net->socket, call->rxcall); ++ if (rtt_us < server->probe.rtt) { ++ server->probe.rtt = rtt_us; + alist->preferred = index; + have_result = true; + } +@@ -113,8 +106,7 @@ out: + spin_unlock(&server->probe_lock); + + _debug("probe [%u][%u] %pISpc rtt=%u ret=%d", +- server_index, index, &alist->addrs[index].transport, +- (unsigned int)rtt, ret); ++ server_index, index, &alist->addrs[index].transport, rtt_us, ret); + + have_result |= afs_fs_probe_done(server); + if (have_result) { +diff --git a/fs/afs/fsclient.c b/fs/afs/fsclient.c +index 68fc46634346..d2b3798c1932 100644 +--- a/fs/afs/fsclient.c ++++ b/fs/afs/fsclient.c +@@ -385,8 +385,6 @@ static int afs_deliver_fs_fetch_data(struct afs_call *call) + ASSERTCMP(req->offset, <=, PAGE_SIZE); + if (req->offset == PAGE_SIZE) { + req->offset = 0; +- if (req->page_done) +- req->page_done(req); + req->index++; + if (req->remain > 0) + goto begin_page; +@@ -440,11 +438,13 @@ static int afs_deliver_fs_fetch_data(struct afs_call *call) + if (req->offset < PAGE_SIZE) + zero_user_segment(req->pages[req->index], + req->offset, PAGE_SIZE); +- if (req->page_done) +- req->page_done(req); + req->offset = 0; + } + ++ if (req->page_done) ++ for (req->index = 0; req->index < req->nr_pages; req->index++) ++ req->page_done(req); ++ + _leave(" = 0 [done]"); + return 0; + } +diff --git a/fs/afs/vl_probe.c b/fs/afs/vl_probe.c +index 858498cc1b05..e3aa013c2177 100644 +--- a/fs/afs/vl_probe.c ++++ b/fs/afs/vl_probe.c +@@ -31,10 +31,9 @@ void afs_vlserver_probe_result(struct afs_call *call) + struct afs_addr_list *alist = call->alist; + struct afs_vlserver *server = call->vlserver; + unsigned int server_index = call->server_index; ++ unsigned int rtt_us = 0; + unsigned int index = call->addr_ix; +- unsigned int rtt = UINT_MAX; + bool have_result = false; +- u64 _rtt; + int ret = call->error; + + _enter("%s,%u,%u,%d,%d", server->name, server_index, index, ret, call->abort_code); +@@ -93,15 +92,9 @@ responded: + } + } + +- /* Get the RTT and scale it to fit into a 32-bit value that represents +- * over a minute of time so that we can access it with one instruction +- * on a 32-bit system. +- */ +- _rtt = rxrpc_kernel_get_rtt(call->net->socket, call->rxcall); +- _rtt /= 64; +- rtt = (_rtt > UINT_MAX) ? UINT_MAX : _rtt; +- if (rtt < server->probe.rtt) { +- server->probe.rtt = rtt; ++ rtt_us = rxrpc_kernel_get_srtt(call->net->socket, call->rxcall); ++ if (rtt_us < server->probe.rtt) { ++ server->probe.rtt = rtt_us; + alist->preferred = index; + have_result = true; + } +@@ -113,8 +106,7 @@ out: + spin_unlock(&server->probe_lock); + + _debug("probe [%u][%u] %pISpc rtt=%u ret=%d", +- server_index, index, &alist->addrs[index].transport, +- (unsigned int)rtt, ret); ++ server_index, index, &alist->addrs[index].transport, rtt_us, ret); + + have_result |= afs_vl_probe_done(server); + if (have_result) { +diff --git a/fs/afs/yfsclient.c b/fs/afs/yfsclient.c +index b5b45c57e1b1..fe413e7a5cf4 100644 +--- a/fs/afs/yfsclient.c ++++ b/fs/afs/yfsclient.c +@@ -497,8 +497,6 @@ static int yfs_deliver_fs_fetch_data64(struct afs_call *call) + ASSERTCMP(req->offset, <=, PAGE_SIZE); + if (req->offset == PAGE_SIZE) { + req->offset = 0; +- if (req->page_done) +- req->page_done(req); + req->index++; + if (req->remain > 0) + goto begin_page; +@@ -556,11 +554,13 @@ static int yfs_deliver_fs_fetch_data64(struct afs_call *call) + if (req->offset < PAGE_SIZE) + zero_user_segment(req->pages[req->index], + req->offset, PAGE_SIZE); +- if (req->page_done) +- req->page_done(req); + req->offset = 0; + } + ++ if (req->page_done) ++ for (req->index = 0; req->index < req->nr_pages; req->index++) ++ req->page_done(req); ++ + _leave(" = 0 [done]"); + return 0; + } +diff --git a/fs/ceph/caps.c b/fs/ceph/caps.c +index d050acc1fd5d..f50204380a65 100644 +--- a/fs/ceph/caps.c ++++ b/fs/ceph/caps.c +@@ -3707,6 +3707,7 @@ retry: + WARN_ON(1); + tsession = NULL; + target = -1; ++ mutex_lock(&session->s_mutex); + } + goto retry; + +diff --git a/fs/configfs/dir.c b/fs/configfs/dir.c +index cf7b7e1d5bd7..cb733652ecca 100644 +--- a/fs/configfs/dir.c ++++ b/fs/configfs/dir.c +@@ -1519,6 +1519,7 @@ static int configfs_rmdir(struct inode *dir, struct dentry *dentry) + spin_lock(&configfs_dirent_lock); + configfs_detach_rollback(dentry); + spin_unlock(&configfs_dirent_lock); ++ config_item_put(parent_item); + return -EINTR; + } + frag->frag_dead = true; +diff --git a/fs/file.c b/fs/file.c +index c8a4e4c86e55..abb8b7081d7a 100644 +--- a/fs/file.c ++++ b/fs/file.c +@@ -70,7 +70,7 @@ static void copy_fd_bitmaps(struct fdtable *nfdt, struct fdtable *ofdt, + */ + static void copy_fdtable(struct fdtable *nfdt, struct fdtable *ofdt) + { +- unsigned int cpy, set; ++ size_t cpy, set; + + BUG_ON(nfdt->max_fds < ofdt->max_fds); + +diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c +index 19ebc6cd0f2b..d0eceaff3cea 100644 +--- a/fs/gfs2/glock.c ++++ b/fs/gfs2/glock.c +@@ -645,9 +645,6 @@ __acquires(&gl->gl_lockref.lock) + goto out_unlock; + if (nonblock) + goto out_sched; +- smp_mb(); +- if (atomic_read(&gl->gl_revokes) != 0) +- goto out_sched; + set_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags); + GLOCK_BUG_ON(gl, gl->gl_demote_state == LM_ST_EXCLUSIVE); + gl->gl_target = gl->gl_demote_state; +diff --git a/fs/overlayfs/export.c b/fs/overlayfs/export.c +index 6f54d70cef27..e605017031ee 100644 +--- a/fs/overlayfs/export.c ++++ b/fs/overlayfs/export.c +@@ -777,6 +777,9 @@ static struct ovl_fh *ovl_fid_to_fh(struct fid *fid, int buflen, int fh_type) + if (fh_type != OVL_FILEID_V0) + return ERR_PTR(-EINVAL); + ++ if (buflen <= OVL_FH_WIRE_OFFSET) ++ return ERR_PTR(-EINVAL); ++ + fh = kzalloc(buflen, GFP_KERNEL); + if (!fh) + return ERR_PTR(-ENOMEM); +diff --git a/fs/splice.c b/fs/splice.c +index d671936d0aad..39b11a9a6b98 100644 +--- a/fs/splice.c ++++ b/fs/splice.c +@@ -1503,7 +1503,7 @@ static int opipe_prep(struct pipe_inode_info *pipe, unsigned int flags) + * Check pipe occupancy without the inode lock first. This function + * is speculative anyways, so missing one is ok. + */ +- if (pipe_full(pipe->head, pipe->tail, pipe->max_usage)) ++ if (!pipe_full(pipe->head, pipe->tail, pipe->max_usage)) + return 0; + + ret = 0; +diff --git a/fs/ubifs/auth.c b/fs/ubifs/auth.c +index 8cdbd53d780c..f985a3fbbb36 100644 +--- a/fs/ubifs/auth.c ++++ b/fs/ubifs/auth.c +@@ -79,13 +79,9 @@ int ubifs_prepare_auth_node(struct ubifs_info *c, void *node, + struct shash_desc *inhash) + { + struct ubifs_auth_node *auth = node; +- u8 *hash; ++ u8 hash[UBIFS_HASH_ARR_SZ]; + int err; + +- hash = kmalloc(crypto_shash_descsize(c->hash_tfm), GFP_NOFS); +- if (!hash) +- return -ENOMEM; +- + { + SHASH_DESC_ON_STACK(hash_desc, c->hash_tfm); + +@@ -94,21 +90,16 @@ int ubifs_prepare_auth_node(struct ubifs_info *c, void *node, + + err = crypto_shash_final(hash_desc, hash); + if (err) +- goto out; ++ return err; + } + + err = ubifs_hash_calc_hmac(c, hash, auth->hmac); + if (err) +- goto out; ++ return err; + + auth->ch.node_type = UBIFS_AUTH_NODE; + ubifs_prepare_node(c, auth, ubifs_auth_node_sz(c), 0); +- +- err = 0; +-out: +- kfree(hash); +- +- return err; ++ return 0; + } + + static struct shash_desc *ubifs_get_desc(const struct ubifs_info *c, +diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c +index 743928efffc1..49fe062ce45e 100644 +--- a/fs/ubifs/file.c ++++ b/fs/ubifs/file.c +@@ -1375,7 +1375,6 @@ int ubifs_update_time(struct inode *inode, struct timespec64 *time, + struct ubifs_info *c = inode->i_sb->s_fs_info; + struct ubifs_budget_req req = { .dirtied_ino = 1, + .dirtied_ino_d = ALIGN(ui->data_len, 8) }; +- int iflags = I_DIRTY_TIME; + int err, release; + + if (!IS_ENABLED(CONFIG_UBIFS_ATIME_SUPPORT)) +@@ -1393,11 +1392,8 @@ int ubifs_update_time(struct inode *inode, struct timespec64 *time, + if (flags & S_MTIME) + inode->i_mtime = *time; + +- if (!(inode->i_sb->s_flags & SB_LAZYTIME)) +- iflags |= I_DIRTY_SYNC; +- + release = ui->dirty; +- __mark_inode_dirty(inode, iflags); ++ __mark_inode_dirty(inode, I_DIRTY_SYNC); + mutex_unlock(&ui->ui_mutex); + if (release) + ubifs_release_budget(c, &req); +diff --git a/fs/ubifs/replay.c b/fs/ubifs/replay.c +index b28ac4dfb407..01fcf7975047 100644 +--- a/fs/ubifs/replay.c ++++ b/fs/ubifs/replay.c +@@ -601,18 +601,12 @@ static int authenticate_sleb(struct ubifs_info *c, struct ubifs_scan_leb *sleb, + struct ubifs_scan_node *snod; + int n_nodes = 0; + int err; +- u8 *hash, *hmac; ++ u8 hash[UBIFS_HASH_ARR_SZ]; ++ u8 hmac[UBIFS_HMAC_ARR_SZ]; + + if (!ubifs_authenticated(c)) + return sleb->nodes_cnt; + +- hash = kmalloc(crypto_shash_descsize(c->hash_tfm), GFP_NOFS); +- hmac = kmalloc(c->hmac_desc_len, GFP_NOFS); +- if (!hash || !hmac) { +- err = -ENOMEM; +- goto out; +- } +- + list_for_each_entry(snod, &sleb->nodes, list) { + + n_nodes++; +@@ -662,9 +656,6 @@ static int authenticate_sleb(struct ubifs_info *c, struct ubifs_scan_leb *sleb, + err = 0; + } + out: +- kfree(hash); +- kfree(hmac); +- + return err ? err : n_nodes - n_not_auth; + } + +diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h +index 81900b3cbe37..041bfa412aa0 100644 +--- a/include/linux/platform_device.h ++++ b/include/linux/platform_device.h +@@ -25,7 +25,6 @@ struct platform_device { + bool id_auto; + struct device dev; + u64 platform_dma_mask; +- struct device_dma_parameters dma_parms; + u32 num_resources; + struct resource *resource; + +diff --git a/include/net/af_rxrpc.h b/include/net/af_rxrpc.h +index 04e97bab6f28..ab988940bf04 100644 +--- a/include/net/af_rxrpc.h ++++ b/include/net/af_rxrpc.h +@@ -59,7 +59,7 @@ bool rxrpc_kernel_abort_call(struct socket *, struct rxrpc_call *, + void rxrpc_kernel_end_call(struct socket *, struct rxrpc_call *); + void rxrpc_kernel_get_peer(struct socket *, struct rxrpc_call *, + struct sockaddr_rxrpc *); +-u64 rxrpc_kernel_get_rtt(struct socket *, struct rxrpc_call *); ++u32 rxrpc_kernel_get_srtt(struct socket *, struct rxrpc_call *); + int rxrpc_kernel_charge_accept(struct socket *, rxrpc_notify_rx_t, + rxrpc_user_attach_call_t, unsigned long, gfp_t, + unsigned int); +diff --git a/include/net/drop_monitor.h b/include/net/drop_monitor.h +index 2ab668461463..f68bc373544a 100644 +--- a/include/net/drop_monitor.h ++++ b/include/net/drop_monitor.h +@@ -19,7 +19,7 @@ struct net_dm_hw_metadata { + struct net_device *input_dev; + }; + +-#if IS_ENABLED(CONFIG_NET_DROP_MONITOR) ++#if IS_REACHABLE(CONFIG_NET_DROP_MONITOR) + void net_dm_hw_report(struct sk_buff *skb, + const struct net_dm_hw_metadata *hw_metadata); + #else +diff --git a/include/trace/events/rxrpc.h b/include/trace/events/rxrpc.h +index 191fe447f990..ba9efdc848f9 100644 +--- a/include/trace/events/rxrpc.h ++++ b/include/trace/events/rxrpc.h +@@ -1112,18 +1112,17 @@ TRACE_EVENT(rxrpc_rtt_tx, + TRACE_EVENT(rxrpc_rtt_rx, + TP_PROTO(struct rxrpc_call *call, enum rxrpc_rtt_rx_trace why, + rxrpc_serial_t send_serial, rxrpc_serial_t resp_serial, +- s64 rtt, u8 nr, s64 avg), ++ u32 rtt, u32 rto), + +- TP_ARGS(call, why, send_serial, resp_serial, rtt, nr, avg), ++ TP_ARGS(call, why, send_serial, resp_serial, rtt, rto), + + TP_STRUCT__entry( + __field(unsigned int, call ) + __field(enum rxrpc_rtt_rx_trace, why ) +- __field(u8, nr ) + __field(rxrpc_serial_t, send_serial ) + __field(rxrpc_serial_t, resp_serial ) +- __field(s64, rtt ) +- __field(u64, avg ) ++ __field(u32, rtt ) ++ __field(u32, rto ) + ), + + TP_fast_assign( +@@ -1132,18 +1131,16 @@ TRACE_EVENT(rxrpc_rtt_rx, + __entry->send_serial = send_serial; + __entry->resp_serial = resp_serial; + __entry->rtt = rtt; +- __entry->nr = nr; +- __entry->avg = avg; ++ __entry->rto = rto; + ), + +- TP_printk("c=%08x %s sr=%08x rr=%08x rtt=%lld nr=%u avg=%lld", ++ TP_printk("c=%08x %s sr=%08x rr=%08x rtt=%u rto=%u", + __entry->call, + __print_symbolic(__entry->why, rxrpc_rtt_rx_traces), + __entry->send_serial, + __entry->resp_serial, + __entry->rtt, +- __entry->nr, +- __entry->avg) ++ __entry->rto) + ); + + TRACE_EVENT(rxrpc_timer, +@@ -1544,6 +1541,41 @@ TRACE_EVENT(rxrpc_notify_socket, + __entry->serial) + ); + ++TRACE_EVENT(rxrpc_rx_discard_ack, ++ TP_PROTO(unsigned int debug_id, rxrpc_serial_t serial, ++ rxrpc_seq_t first_soft_ack, rxrpc_seq_t call_ackr_first, ++ rxrpc_seq_t prev_pkt, rxrpc_seq_t call_ackr_prev), ++ ++ TP_ARGS(debug_id, serial, first_soft_ack, call_ackr_first, ++ prev_pkt, call_ackr_prev), ++ ++ TP_STRUCT__entry( ++ __field(unsigned int, debug_id ) ++ __field(rxrpc_serial_t, serial ) ++ __field(rxrpc_seq_t, first_soft_ack) ++ __field(rxrpc_seq_t, call_ackr_first) ++ __field(rxrpc_seq_t, prev_pkt) ++ __field(rxrpc_seq_t, call_ackr_prev) ++ ), ++ ++ TP_fast_assign( ++ __entry->debug_id = debug_id; ++ __entry->serial = serial; ++ __entry->first_soft_ack = first_soft_ack; ++ __entry->call_ackr_first = call_ackr_first; ++ __entry->prev_pkt = prev_pkt; ++ __entry->call_ackr_prev = call_ackr_prev; ++ ), ++ ++ TP_printk("c=%08x r=%08x %08x<%08x %08x<%08x", ++ __entry->debug_id, ++ __entry->serial, ++ __entry->first_soft_ack, ++ __entry->call_ackr_first, ++ __entry->prev_pkt, ++ __entry->call_ackr_prev) ++ ); ++ + #endif /* _TRACE_RXRPC_H */ + + /* This part must be outside protection */ +diff --git a/init/Kconfig b/init/Kconfig +index ef59c5c36cdb..59908e87ece2 100644 +--- a/init/Kconfig ++++ b/init/Kconfig +@@ -2223,6 +2223,9 @@ config ASN1 + + source "kernel/Kconfig.locks" + ++config ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE ++ bool ++ + config ARCH_HAS_SYNC_CORE_BEFORE_USERMODE + bool + +diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c +index e04ea4c8f935..c0ab9bfdf28a 100644 +--- a/kernel/bpf/syscall.c ++++ b/kernel/bpf/syscall.c +@@ -629,9 +629,20 @@ static int bpf_map_mmap(struct file *filp, struct vm_area_struct *vma) + + mutex_lock(&map->freeze_mutex); + +- if ((vma->vm_flags & VM_WRITE) && map->frozen) { +- err = -EPERM; +- goto out; ++ if (vma->vm_flags & VM_WRITE) { ++ if (map->frozen) { ++ err = -EPERM; ++ goto out; ++ } ++ /* map is meant to be read-only, so do not allow mapping as ++ * writable, because it's possible to leak a writable page ++ * reference and allows user-space to still modify it after ++ * freezing, while verifier will assume contents do not change ++ */ ++ if (map->map_flags & BPF_F_RDONLY_PROG) { ++ err = -EACCES; ++ goto out; ++ } + } + + /* set default open/close callbacks */ +diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c +index c1bb5be530e9..775fca737909 100644 +--- a/kernel/bpf/verifier.c ++++ b/kernel/bpf/verifier.c +@@ -4113,7 +4113,9 @@ static int do_refine_retval_range(struct bpf_verifier_env *env, + + if (ret_type != RET_INTEGER || + (func_id != BPF_FUNC_get_stack && +- func_id != BPF_FUNC_probe_read_str)) ++ func_id != BPF_FUNC_probe_read_str && ++ func_id != BPF_FUNC_probe_read_kernel_str && ++ func_id != BPF_FUNC_probe_read_user_str)) + return 0; + + /* Error case where ret is in interval [S32MIN, -1]. */ +diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c +index c76a20648b72..603d3d3cbf77 100644 +--- a/kernel/sched/fair.c ++++ b/kernel/sched/fair.c +@@ -5276,32 +5276,38 @@ enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags) + cfs_rq = cfs_rq_of(se); + enqueue_entity(cfs_rq, se, flags); + +- /* +- * end evaluation on encountering a throttled cfs_rq +- * +- * note: in the case of encountering a throttled cfs_rq we will +- * post the final h_nr_running increment below. +- */ +- if (cfs_rq_throttled(cfs_rq)) +- break; + cfs_rq->h_nr_running++; + cfs_rq->idle_h_nr_running += idle_h_nr_running; + ++ /* end evaluation on encountering a throttled cfs_rq */ ++ if (cfs_rq_throttled(cfs_rq)) ++ goto enqueue_throttle; ++ + flags = ENQUEUE_WAKEUP; + } + + for_each_sched_entity(se) { + cfs_rq = cfs_rq_of(se); ++ ++ update_load_avg(cfs_rq, se, UPDATE_TG); ++ update_cfs_group(se); ++ + cfs_rq->h_nr_running++; + cfs_rq->idle_h_nr_running += idle_h_nr_running; + ++ /* end evaluation on encountering a throttled cfs_rq */ + if (cfs_rq_throttled(cfs_rq)) +- break; ++ goto enqueue_throttle; + +- update_load_avg(cfs_rq, se, UPDATE_TG); +- update_cfs_group(se); ++ /* ++ * One parent has been throttled and cfs_rq removed from the ++ * list. Add it back to not break the leaf list. ++ */ ++ if (throttled_hierarchy(cfs_rq)) ++ list_add_leaf_cfs_rq(cfs_rq); + } + ++enqueue_throttle: + if (!se) { + add_nr_running(rq, 1); + /* +@@ -5362,17 +5368,13 @@ static void dequeue_task_fair(struct rq *rq, struct task_struct *p, int flags) + cfs_rq = cfs_rq_of(se); + dequeue_entity(cfs_rq, se, flags); + +- /* +- * end evaluation on encountering a throttled cfs_rq +- * +- * note: in the case of encountering a throttled cfs_rq we will +- * post the final h_nr_running decrement below. +- */ +- if (cfs_rq_throttled(cfs_rq)) +- break; + cfs_rq->h_nr_running--; + cfs_rq->idle_h_nr_running -= idle_h_nr_running; + ++ /* end evaluation on encountering a throttled cfs_rq */ ++ if (cfs_rq_throttled(cfs_rq)) ++ goto dequeue_throttle; ++ + /* Don't dequeue parent if it has other entities besides us */ + if (cfs_rq->load.weight) { + /* Avoid re-evaluating load for this entity: */ +@@ -5390,16 +5392,20 @@ static void dequeue_task_fair(struct rq *rq, struct task_struct *p, int flags) + + for_each_sched_entity(se) { + cfs_rq = cfs_rq_of(se); ++ ++ update_load_avg(cfs_rq, se, UPDATE_TG); ++ update_cfs_group(se); ++ + cfs_rq->h_nr_running--; + cfs_rq->idle_h_nr_running -= idle_h_nr_running; + ++ /* end evaluation on encountering a throttled cfs_rq */ + if (cfs_rq_throttled(cfs_rq)) +- break; ++ goto dequeue_throttle; + +- update_load_avg(cfs_rq, se, UPDATE_TG); +- update_cfs_group(se); + } + ++dequeue_throttle: + if (!se) + sub_nr_running(rq, 1); + +diff --git a/kernel/trace/bpf_trace.c b/kernel/trace/bpf_trace.c +index b899a2d7e900..158233a2ab6c 100644 +--- a/kernel/trace/bpf_trace.c ++++ b/kernel/trace/bpf_trace.c +@@ -857,14 +857,16 @@ tracing_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) + return &bpf_probe_read_user_proto; + case BPF_FUNC_probe_read_kernel: + return &bpf_probe_read_kernel_proto; +- case BPF_FUNC_probe_read: +- return &bpf_probe_read_compat_proto; + case BPF_FUNC_probe_read_user_str: + return &bpf_probe_read_user_str_proto; + case BPF_FUNC_probe_read_kernel_str: + return &bpf_probe_read_kernel_str_proto; ++#ifdef CONFIG_ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE ++ case BPF_FUNC_probe_read: ++ return &bpf_probe_read_compat_proto; + case BPF_FUNC_probe_read_str: + return &bpf_probe_read_compat_str_proto; ++#endif + #ifdef CONFIG_CGROUPS + case BPF_FUNC_get_current_cgroup_id: + return &bpf_get_current_cgroup_id_proto; +diff --git a/lib/test_printf.c b/lib/test_printf.c +index 2d9f520d2f27..6b1622f4d7c2 100644 +--- a/lib/test_printf.c ++++ b/lib/test_printf.c +@@ -214,6 +214,7 @@ test_string(void) + #define PTR_STR "ffff0123456789ab" + #define PTR_VAL_NO_CRNG "(____ptrval____)" + #define ZEROS "00000000" /* hex 32 zero bits */ ++#define ONES "ffffffff" /* hex 32 one bits */ + + static int __init + plain_format(void) +@@ -245,6 +246,7 @@ plain_format(void) + #define PTR_STR "456789ab" + #define PTR_VAL_NO_CRNG "(ptrval)" + #define ZEROS "" ++#define ONES "" + + static int __init + plain_format(void) +@@ -330,14 +332,28 @@ test_hashed(const char *fmt, const void *p) + test(buf, fmt, p); + } + ++/* ++ * NULL pointers aren't hashed. ++ */ + static void __init + null_pointer(void) + { +- test_hashed("%p", NULL); ++ test(ZEROS "00000000", "%p", NULL); + test(ZEROS "00000000", "%px", NULL); + test("(null)", "%pE", NULL); + } + ++/* ++ * Error pointers aren't hashed. ++ */ ++static void __init ++error_pointer(void) ++{ ++ test(ONES "fffffff5", "%p", ERR_PTR(-11)); ++ test(ONES "fffffff5", "%px", ERR_PTR(-11)); ++ test("(efault)", "%pE", ERR_PTR(-11)); ++} ++ + #define PTR_INVALID ((void *)0x000000ab) + + static void __init +@@ -649,6 +665,7 @@ test_pointer(void) + { + plain(); + null_pointer(); ++ error_pointer(); + invalid_pointer(); + symbol_ptr(); + kernel_ptr(); +diff --git a/lib/vsprintf.c b/lib/vsprintf.c +index 532b6606a18a..7c47ad52ce2f 100644 +--- a/lib/vsprintf.c ++++ b/lib/vsprintf.c +@@ -794,6 +794,13 @@ static char *ptr_to_id(char *buf, char *end, const void *ptr, + unsigned long hashval; + int ret; + ++ /* ++ * Print the real pointer value for NULL and error pointers, ++ * as they are not actual addresses. ++ */ ++ if (IS_ERR_OR_NULL(ptr)) ++ return pointer_string(buf, end, ptr, spec); ++ + /* When debugging early boot use non-cryptographically secure hash. */ + if (unlikely(debug_boot_weak_hash)) { + hashval = hash_long((unsigned long)ptr, 32); +diff --git a/mm/kasan/Makefile b/mm/kasan/Makefile +index 08b43de2383b..f36ffc090f5f 100644 +--- a/mm/kasan/Makefile ++++ b/mm/kasan/Makefile +@@ -14,10 +14,10 @@ CFLAGS_REMOVE_tags.o = $(CC_FLAGS_FTRACE) + # Function splitter causes unnecessary splits in __asan_load1/__asan_store1 + # see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63533 + +-CFLAGS_common.o := $(call cc-option, -fno-conserve-stack -fno-stack-protector) +-CFLAGS_generic.o := $(call cc-option, -fno-conserve-stack -fno-stack-protector) +-CFLAGS_generic_report.o := $(call cc-option, -fno-conserve-stack -fno-stack-protector) +-CFLAGS_tags.o := $(call cc-option, -fno-conserve-stack -fno-stack-protector) ++CFLAGS_common.o := $(call cc-option, -fno-conserve-stack -fno-stack-protector) -DDISABLE_BRANCH_PROFILING ++CFLAGS_generic.o := $(call cc-option, -fno-conserve-stack -fno-stack-protector) -DDISABLE_BRANCH_PROFILING ++CFLAGS_generic_report.o := $(call cc-option, -fno-conserve-stack -fno-stack-protector) -DDISABLE_BRANCH_PROFILING ++CFLAGS_tags.o := $(call cc-option, -fno-conserve-stack -fno-stack-protector) -DDISABLE_BRANCH_PROFILING + + obj-$(CONFIG_KASAN) := common.o init.o report.o + obj-$(CONFIG_KASAN_GENERIC) += generic.o generic_report.o quarantine.o +diff --git a/mm/kasan/generic.c b/mm/kasan/generic.c +index 616f9dd82d12..76a80033e0b7 100644 +--- a/mm/kasan/generic.c ++++ b/mm/kasan/generic.c +@@ -15,7 +15,6 @@ + */ + + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt +-#define DISABLE_BRANCH_PROFILING + + #include + #include +diff --git a/mm/kasan/tags.c b/mm/kasan/tags.c +index 0e987c9ca052..caf4efd9888c 100644 +--- a/mm/kasan/tags.c ++++ b/mm/kasan/tags.c +@@ -12,7 +12,6 @@ + */ + + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt +-#define DISABLE_BRANCH_PROFILING + + #include + #include +diff --git a/mm/z3fold.c b/mm/z3fold.c +index 42f31c4b53ad..8c3bb5e508b8 100644 +--- a/mm/z3fold.c ++++ b/mm/z3fold.c +@@ -318,16 +318,16 @@ static inline void free_handle(unsigned long handle) + slots = handle_to_slots(handle); + write_lock(&slots->lock); + *(unsigned long *)handle = 0; +- write_unlock(&slots->lock); +- if (zhdr->slots == slots) ++ if (zhdr->slots == slots) { ++ write_unlock(&slots->lock); + return; /* simple case, nothing else to do */ ++ } + + /* we are freeing a foreign handle if we are here */ + zhdr->foreign_handles--; + is_free = true; +- read_lock(&slots->lock); + if (!test_bit(HANDLES_ORPHANED, &slots->pool)) { +- read_unlock(&slots->lock); ++ write_unlock(&slots->lock); + return; + } + for (i = 0; i <= BUDDY_MASK; i++) { +@@ -336,7 +336,7 @@ static inline void free_handle(unsigned long handle) + break; + } + } +- read_unlock(&slots->lock); ++ write_unlock(&slots->lock); + + if (is_free) { + struct z3fold_pool *pool = slots_to_pool(slots); +@@ -422,6 +422,7 @@ static struct z3fold_header *init_z3fold_page(struct page *page, bool headless, + zhdr->start_middle = 0; + zhdr->cpu = -1; + zhdr->foreign_handles = 0; ++ zhdr->mapped_count = 0; + zhdr->slots = slots; + zhdr->pool = pool; + INIT_LIST_HEAD(&zhdr->buddy); +diff --git a/net/core/flow_dissector.c b/net/core/flow_dissector.c +index a1670dff0629..0e5012d7b7b5 100644 +--- a/net/core/flow_dissector.c ++++ b/net/core/flow_dissector.c +@@ -160,12 +160,10 @@ out: + return ret; + } + +-int skb_flow_dissector_bpf_prog_detach(const union bpf_attr *attr) ++static int flow_dissector_bpf_prog_detach(struct net *net) + { + struct bpf_prog *attached; +- struct net *net; + +- net = current->nsproxy->net_ns; + mutex_lock(&flow_dissector_mutex); + attached = rcu_dereference_protected(net->flow_dissector_prog, + lockdep_is_held(&flow_dissector_mutex)); +@@ -179,6 +177,24 @@ int skb_flow_dissector_bpf_prog_detach(const union bpf_attr *attr) + return 0; + } + ++int skb_flow_dissector_bpf_prog_detach(const union bpf_attr *attr) ++{ ++ return flow_dissector_bpf_prog_detach(current->nsproxy->net_ns); ++} ++ ++static void __net_exit flow_dissector_pernet_pre_exit(struct net *net) ++{ ++ /* We're not racing with attach/detach because there are no ++ * references to netns left when pre_exit gets called. ++ */ ++ if (rcu_access_pointer(net->flow_dissector_prog)) ++ flow_dissector_bpf_prog_detach(net); ++} ++ ++static struct pernet_operations flow_dissector_pernet_ops __net_initdata = { ++ .pre_exit = flow_dissector_pernet_pre_exit, ++}; ++ + /** + * __skb_flow_get_ports - extract the upper layer ports and return them + * @skb: sk_buff to extract the ports from +@@ -1838,7 +1854,7 @@ static int __init init_default_flow_dissectors(void) + skb_flow_dissector_init(&flow_keys_basic_dissector, + flow_keys_basic_dissector_keys, + ARRAY_SIZE(flow_keys_basic_dissector_keys)); +- return 0; +-} + ++ return register_pernet_subsys(&flow_dissector_pernet_ops); ++} + core_initcall(init_default_flow_dissectors); +diff --git a/net/rxrpc/Makefile b/net/rxrpc/Makefile +index 6ffb7e9887ce..ddd0f95713a9 100644 +--- a/net/rxrpc/Makefile ++++ b/net/rxrpc/Makefile +@@ -25,6 +25,7 @@ rxrpc-y := \ + peer_event.o \ + peer_object.o \ + recvmsg.o \ ++ rtt.o \ + security.o \ + sendmsg.o \ + skbuff.o \ +diff --git a/net/rxrpc/ar-internal.h b/net/rxrpc/ar-internal.h +index 3eb1ab40ca5c..9fe264bec70c 100644 +--- a/net/rxrpc/ar-internal.h ++++ b/net/rxrpc/ar-internal.h +@@ -7,6 +7,7 @@ + + #include + #include ++#include + #include + #include + #include +@@ -311,11 +312,14 @@ struct rxrpc_peer { + #define RXRPC_RTT_CACHE_SIZE 32 + spinlock_t rtt_input_lock; /* RTT lock for input routine */ + ktime_t rtt_last_req; /* Time of last RTT request */ +- u64 rtt; /* Current RTT estimate (in nS) */ +- u64 rtt_sum; /* Sum of cache contents */ +- u64 rtt_cache[RXRPC_RTT_CACHE_SIZE]; /* Determined RTT cache */ +- u8 rtt_cursor; /* next entry at which to insert */ +- u8 rtt_usage; /* amount of cache actually used */ ++ unsigned int rtt_count; /* Number of samples we've got */ ++ ++ u32 srtt_us; /* smoothed round trip time << 3 in usecs */ ++ u32 mdev_us; /* medium deviation */ ++ u32 mdev_max_us; /* maximal mdev for the last rtt period */ ++ u32 rttvar_us; /* smoothed mdev_max */ ++ u32 rto_j; /* Retransmission timeout in jiffies */ ++ u8 backoff; /* Backoff timeout */ + + u8 cong_cwnd; /* Congestion window size */ + }; +@@ -1041,7 +1045,6 @@ extern unsigned long rxrpc_idle_ack_delay; + extern unsigned int rxrpc_rx_window_size; + extern unsigned int rxrpc_rx_mtu; + extern unsigned int rxrpc_rx_jumbo_max; +-extern unsigned long rxrpc_resend_timeout; + + extern const s8 rxrpc_ack_priority[]; + +@@ -1069,8 +1072,6 @@ void rxrpc_send_keepalive(struct rxrpc_peer *); + * peer_event.c + */ + void rxrpc_error_report(struct sock *); +-void rxrpc_peer_add_rtt(struct rxrpc_call *, enum rxrpc_rtt_rx_trace, +- rxrpc_serial_t, rxrpc_serial_t, ktime_t, ktime_t); + void rxrpc_peer_keepalive_worker(struct work_struct *); + + /* +@@ -1102,6 +1103,14 @@ extern const struct seq_operations rxrpc_peer_seq_ops; + void rxrpc_notify_socket(struct rxrpc_call *); + int rxrpc_recvmsg(struct socket *, struct msghdr *, size_t, int); + ++/* ++ * rtt.c ++ */ ++void rxrpc_peer_add_rtt(struct rxrpc_call *, enum rxrpc_rtt_rx_trace, ++ rxrpc_serial_t, rxrpc_serial_t, ktime_t, ktime_t); ++unsigned long rxrpc_get_rto_backoff(struct rxrpc_peer *, bool); ++void rxrpc_peer_init_rtt(struct rxrpc_peer *); ++ + /* + * rxkad.c + */ +diff --git a/net/rxrpc/call_accept.c b/net/rxrpc/call_accept.c +index 70e44abf106c..b7611cc159e5 100644 +--- a/net/rxrpc/call_accept.c ++++ b/net/rxrpc/call_accept.c +@@ -248,7 +248,7 @@ static void rxrpc_send_ping(struct rxrpc_call *call, struct sk_buff *skb) + struct rxrpc_skb_priv *sp = rxrpc_skb(skb); + ktime_t now = skb->tstamp; + +- if (call->peer->rtt_usage < 3 || ++ if (call->peer->rtt_count < 3 || + ktime_before(ktime_add_ms(call->peer->rtt_last_req, 1000), now)) + rxrpc_propose_ACK(call, RXRPC_ACK_PING, sp->hdr.serial, + true, true, +diff --git a/net/rxrpc/call_event.c b/net/rxrpc/call_event.c +index cedbbb3a7c2e..2a65ac41055f 100644 +--- a/net/rxrpc/call_event.c ++++ b/net/rxrpc/call_event.c +@@ -111,8 +111,8 @@ static void __rxrpc_propose_ACK(struct rxrpc_call *call, u8 ack_reason, + } else { + unsigned long now = jiffies, ack_at; + +- if (call->peer->rtt_usage > 0) +- ack_at = nsecs_to_jiffies(call->peer->rtt); ++ if (call->peer->srtt_us != 0) ++ ack_at = usecs_to_jiffies(call->peer->srtt_us >> 3); + else + ack_at = expiry; + +@@ -157,24 +157,18 @@ static void rxrpc_congestion_timeout(struct rxrpc_call *call) + static void rxrpc_resend(struct rxrpc_call *call, unsigned long now_j) + { + struct sk_buff *skb; +- unsigned long resend_at; ++ unsigned long resend_at, rto_j; + rxrpc_seq_t cursor, seq, top; +- ktime_t now, max_age, oldest, ack_ts, timeout, min_timeo; ++ ktime_t now, max_age, oldest, ack_ts; + int ix; + u8 annotation, anno_type, retrans = 0, unacked = 0; + + _enter("{%d,%d}", call->tx_hard_ack, call->tx_top); + +- if (call->peer->rtt_usage > 1) +- timeout = ns_to_ktime(call->peer->rtt * 3 / 2); +- else +- timeout = ms_to_ktime(rxrpc_resend_timeout); +- min_timeo = ns_to_ktime((1000000000 / HZ) * 4); +- if (ktime_before(timeout, min_timeo)) +- timeout = min_timeo; ++ rto_j = call->peer->rto_j; + + now = ktime_get_real(); +- max_age = ktime_sub(now, timeout); ++ max_age = ktime_sub(now, jiffies_to_usecs(rto_j)); + + spin_lock_bh(&call->lock); + +@@ -219,7 +213,7 @@ static void rxrpc_resend(struct rxrpc_call *call, unsigned long now_j) + } + + resend_at = nsecs_to_jiffies(ktime_to_ns(ktime_sub(now, oldest))); +- resend_at += jiffies + rxrpc_resend_timeout; ++ resend_at += jiffies + rto_j; + WRITE_ONCE(call->resend_at, resend_at); + + if (unacked) +@@ -234,7 +228,7 @@ static void rxrpc_resend(struct rxrpc_call *call, unsigned long now_j) + rxrpc_timer_set_for_resend); + spin_unlock_bh(&call->lock); + ack_ts = ktime_sub(now, call->acks_latest_ts); +- if (ktime_to_ns(ack_ts) < call->peer->rtt) ++ if (ktime_to_us(ack_ts) < (call->peer->srtt_us >> 3)) + goto out; + rxrpc_propose_ACK(call, RXRPC_ACK_PING, 0, true, false, + rxrpc_propose_ack_ping_for_lost_ack); +diff --git a/net/rxrpc/input.c b/net/rxrpc/input.c +index 69e09d69c896..3be4177baf70 100644 +--- a/net/rxrpc/input.c ++++ b/net/rxrpc/input.c +@@ -91,11 +91,11 @@ static void rxrpc_congestion_management(struct rxrpc_call *call, + /* We analyse the number of packets that get ACK'd per RTT + * period and increase the window if we managed to fill it. + */ +- if (call->peer->rtt_usage == 0) ++ if (call->peer->rtt_count == 0) + goto out; + if (ktime_before(skb->tstamp, +- ktime_add_ns(call->cong_tstamp, +- call->peer->rtt))) ++ ktime_add_us(call->cong_tstamp, ++ call->peer->srtt_us >> 3))) + goto out_no_clear_ca; + change = rxrpc_cong_rtt_window_end; + call->cong_tstamp = skb->tstamp; +@@ -802,6 +802,30 @@ static void rxrpc_input_soft_acks(struct rxrpc_call *call, u8 *acks, + } + } + ++/* ++ * Return true if the ACK is valid - ie. it doesn't appear to have regressed ++ * with respect to the ack state conveyed by preceding ACKs. ++ */ ++static bool rxrpc_is_ack_valid(struct rxrpc_call *call, ++ rxrpc_seq_t first_pkt, rxrpc_seq_t prev_pkt) ++{ ++ rxrpc_seq_t base = READ_ONCE(call->ackr_first_seq); ++ ++ if (after(first_pkt, base)) ++ return true; /* The window advanced */ ++ ++ if (before(first_pkt, base)) ++ return false; /* firstPacket regressed */ ++ ++ if (after_eq(prev_pkt, call->ackr_prev_seq)) ++ return true; /* previousPacket hasn't regressed. */ ++ ++ /* Some rx implementations put a serial number in previousPacket. */ ++ if (after_eq(prev_pkt, base + call->tx_winsize)) ++ return false; ++ return true; ++} ++ + /* + * Process an ACK packet. + * +@@ -865,9 +889,12 @@ static void rxrpc_input_ack(struct rxrpc_call *call, struct sk_buff *skb) + } + + /* Discard any out-of-order or duplicate ACKs (outside lock). */ +- if (before(first_soft_ack, call->ackr_first_seq) || +- before(prev_pkt, call->ackr_prev_seq)) ++ if (!rxrpc_is_ack_valid(call, first_soft_ack, prev_pkt)) { ++ trace_rxrpc_rx_discard_ack(call->debug_id, sp->hdr.serial, ++ first_soft_ack, call->ackr_first_seq, ++ prev_pkt, call->ackr_prev_seq); + return; ++ } + + buf.info.rxMTU = 0; + ioffset = offset + nr_acks + 3; +@@ -878,9 +905,12 @@ static void rxrpc_input_ack(struct rxrpc_call *call, struct sk_buff *skb) + spin_lock(&call->input_lock); + + /* Discard any out-of-order or duplicate ACKs (inside lock). */ +- if (before(first_soft_ack, call->ackr_first_seq) || +- before(prev_pkt, call->ackr_prev_seq)) ++ if (!rxrpc_is_ack_valid(call, first_soft_ack, prev_pkt)) { ++ trace_rxrpc_rx_discard_ack(call->debug_id, sp->hdr.serial, ++ first_soft_ack, call->ackr_first_seq, ++ prev_pkt, call->ackr_prev_seq); + goto out; ++ } + call->acks_latest_ts = skb->tstamp; + + call->ackr_first_seq = first_soft_ack; +diff --git a/net/rxrpc/misc.c b/net/rxrpc/misc.c +index 214405f75346..d4144fd86f84 100644 +--- a/net/rxrpc/misc.c ++++ b/net/rxrpc/misc.c +@@ -63,11 +63,6 @@ unsigned int rxrpc_rx_mtu = 5692; + */ + unsigned int rxrpc_rx_jumbo_max = 4; + +-/* +- * Time till packet resend (in milliseconds). +- */ +-unsigned long rxrpc_resend_timeout = 4 * HZ; +- + const s8 rxrpc_ack_priority[] = { + [0] = 0, + [RXRPC_ACK_DELAY] = 1, +diff --git a/net/rxrpc/output.c b/net/rxrpc/output.c +index 90e263c6aa69..f8b632a5c619 100644 +--- a/net/rxrpc/output.c ++++ b/net/rxrpc/output.c +@@ -369,7 +369,7 @@ int rxrpc_send_data_packet(struct rxrpc_call *call, struct sk_buff *skb, + (test_and_clear_bit(RXRPC_CALL_EV_ACK_LOST, &call->events) || + retrans || + call->cong_mode == RXRPC_CALL_SLOW_START || +- (call->peer->rtt_usage < 3 && sp->hdr.seq & 1) || ++ (call->peer->rtt_count < 3 && sp->hdr.seq & 1) || + ktime_before(ktime_add_ms(call->peer->rtt_last_req, 1000), + ktime_get_real()))) + whdr.flags |= RXRPC_REQUEST_ACK; +@@ -423,13 +423,10 @@ done: + if (whdr.flags & RXRPC_REQUEST_ACK) { + call->peer->rtt_last_req = skb->tstamp; + trace_rxrpc_rtt_tx(call, rxrpc_rtt_tx_data, serial); +- if (call->peer->rtt_usage > 1) { ++ if (call->peer->rtt_count > 1) { + unsigned long nowj = jiffies, ack_lost_at; + +- ack_lost_at = nsecs_to_jiffies(2 * call->peer->rtt); +- if (ack_lost_at < 1) +- ack_lost_at = 1; +- ++ ack_lost_at = rxrpc_get_rto_backoff(call->peer, retrans); + ack_lost_at += nowj; + WRITE_ONCE(call->ack_lost_at, ack_lost_at); + rxrpc_reduce_call_timer(call, ack_lost_at, nowj, +diff --git a/net/rxrpc/peer_event.c b/net/rxrpc/peer_event.c +index 923b263c401b..b1449d971883 100644 +--- a/net/rxrpc/peer_event.c ++++ b/net/rxrpc/peer_event.c +@@ -295,52 +295,6 @@ static void rxrpc_distribute_error(struct rxrpc_peer *peer, int error, + } + } + +-/* +- * Add RTT information to cache. This is called in softirq mode and has +- * exclusive access to the peer RTT data. +- */ +-void rxrpc_peer_add_rtt(struct rxrpc_call *call, enum rxrpc_rtt_rx_trace why, +- rxrpc_serial_t send_serial, rxrpc_serial_t resp_serial, +- ktime_t send_time, ktime_t resp_time) +-{ +- struct rxrpc_peer *peer = call->peer; +- s64 rtt; +- u64 sum = peer->rtt_sum, avg; +- u8 cursor = peer->rtt_cursor, usage = peer->rtt_usage; +- +- rtt = ktime_to_ns(ktime_sub(resp_time, send_time)); +- if (rtt < 0) +- return; +- +- spin_lock(&peer->rtt_input_lock); +- +- /* Replace the oldest datum in the RTT buffer */ +- sum -= peer->rtt_cache[cursor]; +- sum += rtt; +- peer->rtt_cache[cursor] = rtt; +- peer->rtt_cursor = (cursor + 1) & (RXRPC_RTT_CACHE_SIZE - 1); +- peer->rtt_sum = sum; +- if (usage < RXRPC_RTT_CACHE_SIZE) { +- usage++; +- peer->rtt_usage = usage; +- } +- +- spin_unlock(&peer->rtt_input_lock); +- +- /* Now recalculate the average */ +- if (usage == RXRPC_RTT_CACHE_SIZE) { +- avg = sum / RXRPC_RTT_CACHE_SIZE; +- } else { +- avg = sum; +- do_div(avg, usage); +- } +- +- /* Don't need to update this under lock */ +- peer->rtt = avg; +- trace_rxrpc_rtt_rx(call, why, send_serial, resp_serial, rtt, +- usage, avg); +-} +- + /* + * Perform keep-alive pings. + */ +diff --git a/net/rxrpc/peer_object.c b/net/rxrpc/peer_object.c +index 452163eadb98..ca29976bb193 100644 +--- a/net/rxrpc/peer_object.c ++++ b/net/rxrpc/peer_object.c +@@ -225,6 +225,8 @@ struct rxrpc_peer *rxrpc_alloc_peer(struct rxrpc_local *local, gfp_t gfp) + spin_lock_init(&peer->rtt_input_lock); + peer->debug_id = atomic_inc_return(&rxrpc_debug_id); + ++ rxrpc_peer_init_rtt(peer); ++ + if (RXRPC_TX_SMSS > 2190) + peer->cong_cwnd = 2; + else if (RXRPC_TX_SMSS > 1095) +@@ -497,14 +499,14 @@ void rxrpc_kernel_get_peer(struct socket *sock, struct rxrpc_call *call, + EXPORT_SYMBOL(rxrpc_kernel_get_peer); + + /** +- * rxrpc_kernel_get_rtt - Get a call's peer RTT ++ * rxrpc_kernel_get_srtt - Get a call's peer smoothed RTT + * @sock: The socket on which the call is in progress. + * @call: The call to query + * +- * Get the call's peer RTT. ++ * Get the call's peer smoothed RTT. + */ +-u64 rxrpc_kernel_get_rtt(struct socket *sock, struct rxrpc_call *call) ++u32 rxrpc_kernel_get_srtt(struct socket *sock, struct rxrpc_call *call) + { +- return call->peer->rtt; ++ return call->peer->srtt_us >> 3; + } +-EXPORT_SYMBOL(rxrpc_kernel_get_rtt); ++EXPORT_SYMBOL(rxrpc_kernel_get_srtt); +diff --git a/net/rxrpc/proc.c b/net/rxrpc/proc.c +index b9d053e42821..8b179e3c802a 100644 +--- a/net/rxrpc/proc.c ++++ b/net/rxrpc/proc.c +@@ -222,7 +222,7 @@ static int rxrpc_peer_seq_show(struct seq_file *seq, void *v) + seq_puts(seq, + "Proto Local " + " Remote " +- " Use CW MTU LastUse RTT Rc\n" ++ " Use CW MTU LastUse RTT RTO\n" + ); + return 0; + } +@@ -236,15 +236,15 @@ static int rxrpc_peer_seq_show(struct seq_file *seq, void *v) + now = ktime_get_seconds(); + seq_printf(seq, + "UDP %-47.47s %-47.47s %3u" +- " %3u %5u %6llus %12llu %2u\n", ++ " %3u %5u %6llus %8u %8u\n", + lbuff, + rbuff, + atomic_read(&peer->usage), + peer->cong_cwnd, + peer->mtu, + now - peer->last_tx_at, +- peer->rtt, +- peer->rtt_cursor); ++ peer->srtt_us >> 3, ++ jiffies_to_usecs(peer->rto_j)); + + return 0; + } +diff --git a/net/rxrpc/rtt.c b/net/rxrpc/rtt.c +new file mode 100644 +index 000000000000..928d8b34a3ee +--- /dev/null ++++ b/net/rxrpc/rtt.c +@@ -0,0 +1,195 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* RTT/RTO calculation. ++ * ++ * Adapted from TCP for AF_RXRPC by David Howells (dhowells@redhat.com) ++ * ++ * https://tools.ietf.org/html/rfc6298 ++ * https://tools.ietf.org/html/rfc1122#section-4.2.3.1 ++ * http://ccr.sigcomm.org/archive/1995/jan95/ccr-9501-partridge87.pdf ++ */ ++ ++#include ++#include "ar-internal.h" ++ ++#define RXRPC_RTO_MAX ((unsigned)(120 * HZ)) ++#define RXRPC_TIMEOUT_INIT ((unsigned)(1*HZ)) /* RFC6298 2.1 initial RTO value */ ++#define rxrpc_jiffies32 ((u32)jiffies) /* As rxrpc_jiffies32 */ ++#define rxrpc_min_rtt_wlen 300 /* As sysctl_tcp_min_rtt_wlen */ ++ ++static u32 rxrpc_rto_min_us(struct rxrpc_peer *peer) ++{ ++ return 200; ++} ++ ++static u32 __rxrpc_set_rto(const struct rxrpc_peer *peer) ++{ ++ return _usecs_to_jiffies((peer->srtt_us >> 3) + peer->rttvar_us); ++} ++ ++static u32 rxrpc_bound_rto(u32 rto) ++{ ++ return min(rto, RXRPC_RTO_MAX); ++} ++ ++/* ++ * Called to compute a smoothed rtt estimate. The data fed to this ++ * routine either comes from timestamps, or from segments that were ++ * known _not_ to have been retransmitted [see Karn/Partridge ++ * Proceedings SIGCOMM 87]. The algorithm is from the SIGCOMM 88 ++ * piece by Van Jacobson. ++ * NOTE: the next three routines used to be one big routine. ++ * To save cycles in the RFC 1323 implementation it was better to break ++ * it up into three procedures. -- erics ++ */ ++static void rxrpc_rtt_estimator(struct rxrpc_peer *peer, long sample_rtt_us) ++{ ++ long m = sample_rtt_us; /* RTT */ ++ u32 srtt = peer->srtt_us; ++ ++ /* The following amusing code comes from Jacobson's ++ * article in SIGCOMM '88. Note that rtt and mdev ++ * are scaled versions of rtt and mean deviation. ++ * This is designed to be as fast as possible ++ * m stands for "measurement". ++ * ++ * On a 1990 paper the rto value is changed to: ++ * RTO = rtt + 4 * mdev ++ * ++ * Funny. This algorithm seems to be very broken. ++ * These formulae increase RTO, when it should be decreased, increase ++ * too slowly, when it should be increased quickly, decrease too quickly ++ * etc. I guess in BSD RTO takes ONE value, so that it is absolutely ++ * does not matter how to _calculate_ it. Seems, it was trap ++ * that VJ failed to avoid. 8) ++ */ ++ if (srtt != 0) { ++ m -= (srtt >> 3); /* m is now error in rtt est */ ++ srtt += m; /* rtt = 7/8 rtt + 1/8 new */ ++ if (m < 0) { ++ m = -m; /* m is now abs(error) */ ++ m -= (peer->mdev_us >> 2); /* similar update on mdev */ ++ /* This is similar to one of Eifel findings. ++ * Eifel blocks mdev updates when rtt decreases. ++ * This solution is a bit different: we use finer gain ++ * for mdev in this case (alpha*beta). ++ * Like Eifel it also prevents growth of rto, ++ * but also it limits too fast rto decreases, ++ * happening in pure Eifel. ++ */ ++ if (m > 0) ++ m >>= 3; ++ } else { ++ m -= (peer->mdev_us >> 2); /* similar update on mdev */ ++ } ++ ++ peer->mdev_us += m; /* mdev = 3/4 mdev + 1/4 new */ ++ if (peer->mdev_us > peer->mdev_max_us) { ++ peer->mdev_max_us = peer->mdev_us; ++ if (peer->mdev_max_us > peer->rttvar_us) ++ peer->rttvar_us = peer->mdev_max_us; ++ } ++ } else { ++ /* no previous measure. */ ++ srtt = m << 3; /* take the measured time to be rtt */ ++ peer->mdev_us = m << 1; /* make sure rto = 3*rtt */ ++ peer->rttvar_us = max(peer->mdev_us, rxrpc_rto_min_us(peer)); ++ peer->mdev_max_us = peer->rttvar_us; ++ } ++ ++ peer->srtt_us = max(1U, srtt); ++} ++ ++/* ++ * Calculate rto without backoff. This is the second half of Van Jacobson's ++ * routine referred to above. ++ */ ++static void rxrpc_set_rto(struct rxrpc_peer *peer) ++{ ++ u32 rto; ++ ++ /* 1. If rtt variance happened to be less 50msec, it is hallucination. ++ * It cannot be less due to utterly erratic ACK generation made ++ * at least by solaris and freebsd. "Erratic ACKs" has _nothing_ ++ * to do with delayed acks, because at cwnd>2 true delack timeout ++ * is invisible. Actually, Linux-2.4 also generates erratic ++ * ACKs in some circumstances. ++ */ ++ rto = __rxrpc_set_rto(peer); ++ ++ /* 2. Fixups made earlier cannot be right. ++ * If we do not estimate RTO correctly without them, ++ * all the algo is pure shit and should be replaced ++ * with correct one. It is exactly, which we pretend to do. ++ */ ++ ++ /* NOTE: clamping at RXRPC_RTO_MIN is not required, current algo ++ * guarantees that rto is higher. ++ */ ++ peer->rto_j = rxrpc_bound_rto(rto); ++} ++ ++static void rxrpc_ack_update_rtt(struct rxrpc_peer *peer, long rtt_us) ++{ ++ if (rtt_us < 0) ++ return; ++ ++ //rxrpc_update_rtt_min(peer, rtt_us); ++ rxrpc_rtt_estimator(peer, rtt_us); ++ rxrpc_set_rto(peer); ++ ++ /* RFC6298: only reset backoff on valid RTT measurement. */ ++ peer->backoff = 0; ++} ++ ++/* ++ * Add RTT information to cache. This is called in softirq mode and has ++ * exclusive access to the peer RTT data. ++ */ ++void rxrpc_peer_add_rtt(struct rxrpc_call *call, enum rxrpc_rtt_rx_trace why, ++ rxrpc_serial_t send_serial, rxrpc_serial_t resp_serial, ++ ktime_t send_time, ktime_t resp_time) ++{ ++ struct rxrpc_peer *peer = call->peer; ++ s64 rtt_us; ++ ++ rtt_us = ktime_to_us(ktime_sub(resp_time, send_time)); ++ if (rtt_us < 0) ++ return; ++ ++ spin_lock(&peer->rtt_input_lock); ++ rxrpc_ack_update_rtt(peer, rtt_us); ++ if (peer->rtt_count < 3) ++ peer->rtt_count++; ++ spin_unlock(&peer->rtt_input_lock); ++ ++ trace_rxrpc_rtt_rx(call, why, send_serial, resp_serial, ++ peer->srtt_us >> 3, peer->rto_j); ++} ++ ++/* ++ * Get the retransmission timeout to set in jiffies, backing it off each time ++ * we retransmit. ++ */ ++unsigned long rxrpc_get_rto_backoff(struct rxrpc_peer *peer, bool retrans) ++{ ++ u64 timo_j; ++ u8 backoff = READ_ONCE(peer->backoff); ++ ++ timo_j = peer->rto_j; ++ timo_j <<= backoff; ++ if (retrans && timo_j * 2 <= RXRPC_RTO_MAX) ++ WRITE_ONCE(peer->backoff, backoff + 1); ++ ++ if (timo_j < 1) ++ timo_j = 1; ++ ++ return timo_j; ++} ++ ++void rxrpc_peer_init_rtt(struct rxrpc_peer *peer) ++{ ++ peer->rto_j = RXRPC_TIMEOUT_INIT; ++ peer->mdev_us = jiffies_to_usecs(RXRPC_TIMEOUT_INIT); ++ peer->backoff = 0; ++ //minmax_reset(&peer->rtt_min, rxrpc_jiffies32, ~0U); ++} +diff --git a/net/rxrpc/rxkad.c b/net/rxrpc/rxkad.c +index 098f1f9ec53b..52a24d4ef5d8 100644 +--- a/net/rxrpc/rxkad.c ++++ b/net/rxrpc/rxkad.c +@@ -1148,7 +1148,7 @@ static int rxkad_verify_response(struct rxrpc_connection *conn, + ret = rxkad_decrypt_ticket(conn, skb, ticket, ticket_len, &session_key, + &expiry, _abort_code); + if (ret < 0) +- goto temporary_error_free_resp; ++ goto temporary_error_free_ticket; + + /* use the session key from inside the ticket to decrypt the + * response */ +@@ -1230,7 +1230,6 @@ protocol_error: + + temporary_error_free_ticket: + kfree(ticket); +-temporary_error_free_resp: + kfree(response); + temporary_error: + /* Ignore the response packet if we got a temporary error such as +diff --git a/net/rxrpc/sendmsg.c b/net/rxrpc/sendmsg.c +index 0fcf157aa09f..5e9c43d4a314 100644 +--- a/net/rxrpc/sendmsg.c ++++ b/net/rxrpc/sendmsg.c +@@ -66,15 +66,14 @@ static int rxrpc_wait_for_tx_window_waitall(struct rxrpc_sock *rx, + struct rxrpc_call *call) + { + rxrpc_seq_t tx_start, tx_win; +- signed long rtt2, timeout; +- u64 rtt; ++ signed long rtt, timeout; + +- rtt = READ_ONCE(call->peer->rtt); +- rtt2 = nsecs_to_jiffies64(rtt) * 2; +- if (rtt2 < 2) +- rtt2 = 2; ++ rtt = READ_ONCE(call->peer->srtt_us) >> 3; ++ rtt = usecs_to_jiffies(rtt) * 2; ++ if (rtt < 2) ++ rtt = 2; + +- timeout = rtt2; ++ timeout = rtt; + tx_start = READ_ONCE(call->tx_hard_ack); + + for (;;) { +@@ -92,7 +91,7 @@ static int rxrpc_wait_for_tx_window_waitall(struct rxrpc_sock *rx, + return -EINTR; + + if (tx_win != tx_start) { +- timeout = rtt2; ++ timeout = rtt; + tx_start = tx_win; + } + +@@ -271,16 +270,9 @@ static int rxrpc_queue_packet(struct rxrpc_sock *rx, struct rxrpc_call *call, + _debug("need instant resend %d", ret); + rxrpc_instant_resend(call, ix); + } else { +- unsigned long now = jiffies, resend_at; ++ unsigned long now = jiffies; ++ unsigned long resend_at = now + call->peer->rto_j; + +- if (call->peer->rtt_usage > 1) +- resend_at = nsecs_to_jiffies(call->peer->rtt * 3 / 2); +- else +- resend_at = rxrpc_resend_timeout; +- if (resend_at < 1) +- resend_at = 1; +- +- resend_at += now; + WRITE_ONCE(call->resend_at, resend_at); + rxrpc_reduce_call_timer(call, resend_at, now, + rxrpc_timer_set_for_send); +diff --git a/net/rxrpc/sysctl.c b/net/rxrpc/sysctl.c +index 2bbb38161851..18dade4e6f9a 100644 +--- a/net/rxrpc/sysctl.c ++++ b/net/rxrpc/sysctl.c +@@ -71,15 +71,6 @@ static struct ctl_table rxrpc_sysctl_table[] = { + .extra1 = (void *)&one_jiffy, + .extra2 = (void *)&max_jiffies, + }, +- { +- .procname = "resend_timeout", +- .data = &rxrpc_resend_timeout, +- .maxlen = sizeof(unsigned long), +- .mode = 0644, +- .proc_handler = proc_doulongvec_ms_jiffies_minmax, +- .extra1 = (void *)&one_jiffy, +- .extra2 = (void *)&max_jiffies, +- }, + + /* Non-time values */ + { +diff --git a/scripts/gcc-plugins/Makefile b/scripts/gcc-plugins/Makefile +index f2ee8bd7abc6..1d0b9382e759 100644 +--- a/scripts/gcc-plugins/Makefile ++++ b/scripts/gcc-plugins/Makefile +@@ -11,6 +11,7 @@ else + HOST_EXTRACXXFLAGS += -I$(GCC_PLUGINS_DIR)/include -I$(src) -std=gnu++98 -fno-rtti + HOST_EXTRACXXFLAGS += -fno-exceptions -fasynchronous-unwind-tables -ggdb + HOST_EXTRACXXFLAGS += -Wno-narrowing -Wno-unused-variable ++ HOST_EXTRACXXFLAGS += -Wno-format-diag + export HOST_EXTRACXXFLAGS + endif + +diff --git a/scripts/gcc-plugins/gcc-common.h b/scripts/gcc-plugins/gcc-common.h +index 17f06079a712..9ad76b7f3f10 100644 +--- a/scripts/gcc-plugins/gcc-common.h ++++ b/scripts/gcc-plugins/gcc-common.h +@@ -35,7 +35,9 @@ + #include "ggc.h" + #include "timevar.h" + ++#if BUILDING_GCC_VERSION < 10000 + #include "params.h" ++#endif + + #if BUILDING_GCC_VERSION <= 4009 + #include "pointer-set.h" +@@ -847,6 +849,7 @@ static inline gimple gimple_build_assign_with_ops(enum tree_code subcode, tree l + return gimple_build_assign(lhs, subcode, op1, op2 PASS_MEM_STAT); + } + ++#if BUILDING_GCC_VERSION < 10000 + template <> + template <> + inline bool is_a_helper::test(const_gimple gs) +@@ -860,6 +863,7 @@ inline bool is_a_helper::test(const_gimple gs) + { + return gs->code == GIMPLE_RETURN; + } ++#endif + + static inline gasm *as_a_gasm(gimple stmt) + { +diff --git a/scripts/gdb/linux/rbtree.py b/scripts/gdb/linux/rbtree.py +index 39db889b874c..c4b991607917 100644 +--- a/scripts/gdb/linux/rbtree.py ++++ b/scripts/gdb/linux/rbtree.py +@@ -12,7 +12,7 @@ rb_node_type = utils.CachedType("struct rb_node") + + def rb_first(root): + if root.type == rb_root_type.get_type(): +- node = node.address.cast(rb_root_type.get_type().pointer()) ++ node = root.address.cast(rb_root_type.get_type().pointer()) + elif root.type != rb_root_type.get_type().pointer(): + raise gdb.GdbError("Must be struct rb_root not {}".format(root.type)) + +@@ -28,7 +28,7 @@ def rb_first(root): + + def rb_last(root): + if root.type == rb_root_type.get_type(): +- node = node.address.cast(rb_root_type.get_type().pointer()) ++ node = root.address.cast(rb_root_type.get_type().pointer()) + elif root.type != rb_root_type.get_type().pointer(): + raise gdb.GdbError("Must be struct rb_root not {}".format(root.type)) + +diff --git a/scripts/link-vmlinux.sh b/scripts/link-vmlinux.sh +index dd484e92752e..ac569e197bfa 100755 +--- a/scripts/link-vmlinux.sh ++++ b/scripts/link-vmlinux.sh +@@ -63,12 +63,18 @@ vmlinux_link() + local lds="${objtree}/${KBUILD_LDS}" + local output=${1} + local objects ++ local strip_debug + + info LD ${output} + + # skip output file argument + shift + ++ # The kallsyms linking does not need debug symbols included. ++ if [ "$output" != "${output#.tmp_vmlinux.kallsyms}" ] ; then ++ strip_debug=-Wl,--strip-debug ++ fi ++ + if [ "${SRCARCH}" != "um" ]; then + objects="--whole-archive \ + ${KBUILD_VMLINUX_OBJS} \ +@@ -79,6 +85,7 @@ vmlinux_link() + ${@}" + + ${LD} ${KBUILD_LDFLAGS} ${LDFLAGS_vmlinux} \ ++ ${strip_debug#-Wl,} \ + -o ${output} \ + -T ${lds} ${objects} + else +@@ -91,6 +98,7 @@ vmlinux_link() + ${@}" + + ${CC} ${CFLAGS_vmlinux} \ ++ ${strip_debug} \ + -o ${output} \ + -Wl,-T,${lds} \ + ${objects} \ +@@ -106,6 +114,8 @@ gen_btf() + { + local pahole_ver + local bin_arch ++ local bin_format ++ local bin_file + + if ! [ -x "$(command -v ${PAHOLE})" ]; then + echo >&2 "BTF: ${1}: pahole (${PAHOLE}) is not available" +@@ -118,8 +128,9 @@ gen_btf() + return 1 + fi + +- info "BTF" ${2} + vmlinux_link ${1} ++ ++ info "BTF" ${2} + LLVM_OBJCOPY=${OBJCOPY} ${PAHOLE} -J ${1} + + # dump .BTF section into raw binary file to link with final vmlinux +@@ -127,11 +138,12 @@ gen_btf() + cut -d, -f1 | cut -d' ' -f2) + bin_format=$(LANG=C ${OBJDUMP} -f ${1} | grep 'file format' | \ + awk '{print $4}') ++ bin_file=.btf.vmlinux.bin + ${OBJCOPY} --change-section-address .BTF=0 \ + --set-section-flags .BTF=alloc -O binary \ +- --only-section=.BTF ${1} .btf.vmlinux.bin ++ --only-section=.BTF ${1} $bin_file + ${OBJCOPY} -I binary -O ${bin_format} -B ${bin_arch} \ +- --rename-section .data=.BTF .btf.vmlinux.bin ${2} ++ --rename-section .data=.BTF $bin_file ${2} + } + + # Create ${2} .o file with all symbols from the ${1} object file +@@ -166,8 +178,8 @@ kallsyms() + kallsyms_step() + { + kallsymso_prev=${kallsymso} +- kallsymso=.tmp_kallsyms${1}.o +- kallsyms_vmlinux=.tmp_vmlinux${1} ++ kallsyms_vmlinux=.tmp_vmlinux.kallsyms${1} ++ kallsymso=${kallsyms_vmlinux}.o + + vmlinux_link ${kallsyms_vmlinux} "${kallsymso_prev}" ${btf_vmlinux_bin_o} + kallsyms ${kallsyms_vmlinux} ${kallsymso} +@@ -190,7 +202,6 @@ cleanup() + { + rm -f .btf.* + rm -f .tmp_System.map +- rm -f .tmp_kallsyms* + rm -f .tmp_vmlinux* + rm -f System.map + rm -f vmlinux +@@ -257,9 +268,8 @@ tr '\0' '\n' < modules.builtin.modinfo | sed -n 's/^[[:alnum:]:_]*\.file=//p' | + + btf_vmlinux_bin_o="" + if [ -n "${CONFIG_DEBUG_INFO_BTF}" ]; then +- if gen_btf .tmp_vmlinux.btf .btf.vmlinux.bin.o ; then +- btf_vmlinux_bin_o=.btf.vmlinux.bin.o +- else ++ btf_vmlinux_bin_o=.btf.vmlinux.bin.o ++ if ! gen_btf .tmp_vmlinux.btf $btf_vmlinux_bin_o ; then + echo >&2 "Failed to generate BTF for vmlinux" + echo >&2 "Try to disable CONFIG_DEBUG_INFO_BTF" + exit 1 +diff --git a/security/apparmor/apparmorfs.c b/security/apparmor/apparmorfs.c +index 280741fc0f5f..f6a3ecfadf80 100644 +--- a/security/apparmor/apparmorfs.c ++++ b/security/apparmor/apparmorfs.c +@@ -454,7 +454,7 @@ static ssize_t policy_update(u32 mask, const char __user *buf, size_t size, + */ + error = aa_may_manage_policy(label, ns, mask); + if (error) +- return error; ++ goto end_section; + + data = aa_simple_write_to_buffer(buf, size, size, pos); + error = PTR_ERR(data); +@@ -462,6 +462,7 @@ static ssize_t policy_update(u32 mask, const char __user *buf, size_t size, + error = aa_replace_profiles(ns, label, mask, data); + aa_put_loaddata(data); + } ++end_section: + end_current_label_crit_section(label); + + return error; +diff --git a/security/apparmor/audit.c b/security/apparmor/audit.c +index 5a98661a8b46..597732503815 100644 +--- a/security/apparmor/audit.c ++++ b/security/apparmor/audit.c +@@ -197,8 +197,9 @@ int aa_audit_rule_init(u32 field, u32 op, char *rulestr, void **vrule) + rule->label = aa_label_parse(&root_ns->unconfined->label, rulestr, + GFP_KERNEL, true, false); + if (IS_ERR(rule->label)) { ++ int err = PTR_ERR(rule->label); + aa_audit_rule_free(rule); +- return PTR_ERR(rule->label); ++ return err; + } + + *vrule = rule; +diff --git a/security/apparmor/domain.c b/security/apparmor/domain.c +index 6ceb74e0f789..a84ef030fbd7 100644 +--- a/security/apparmor/domain.c ++++ b/security/apparmor/domain.c +@@ -1328,6 +1328,7 @@ int aa_change_profile(const char *fqname, int flags) + ctx->nnp = aa_get_label(label); + + if (!fqname || !*fqname) { ++ aa_put_label(label); + AA_DEBUG("no profile name"); + return -EINVAL; + } +@@ -1346,8 +1347,6 @@ int aa_change_profile(const char *fqname, int flags) + op = OP_CHANGE_PROFILE; + } + +- label = aa_get_current_label(); +- + if (*fqname == '&') { + stack = true; + /* don't have label_parse() do stacking */ +diff --git a/security/integrity/evm/evm_crypto.c b/security/integrity/evm/evm_crypto.c +index d485f6fc908e..cc826c2767a3 100644 +--- a/security/integrity/evm/evm_crypto.c ++++ b/security/integrity/evm/evm_crypto.c +@@ -75,7 +75,7 @@ static struct shash_desc *init_desc(char type, uint8_t hash_algo) + { + long rc; + const char *algo; +- struct crypto_shash **tfm; ++ struct crypto_shash **tfm, *tmp_tfm; + struct shash_desc *desc; + + if (type == EVM_XATTR_HMAC) { +@@ -93,31 +93,31 @@ static struct shash_desc *init_desc(char type, uint8_t hash_algo) + algo = hash_algo_name[hash_algo]; + } + +- if (*tfm == NULL) { +- mutex_lock(&mutex); +- if (*tfm) +- goto out; +- *tfm = crypto_alloc_shash(algo, 0, CRYPTO_NOLOAD); +- if (IS_ERR(*tfm)) { +- rc = PTR_ERR(*tfm); +- pr_err("Can not allocate %s (reason: %ld)\n", algo, rc); +- *tfm = NULL; ++ if (*tfm) ++ goto alloc; ++ mutex_lock(&mutex); ++ if (*tfm) ++ goto unlock; ++ ++ tmp_tfm = crypto_alloc_shash(algo, 0, CRYPTO_NOLOAD); ++ if (IS_ERR(tmp_tfm)) { ++ pr_err("Can not allocate %s (reason: %ld)\n", algo, ++ PTR_ERR(tmp_tfm)); ++ mutex_unlock(&mutex); ++ return ERR_CAST(tmp_tfm); ++ } ++ if (type == EVM_XATTR_HMAC) { ++ rc = crypto_shash_setkey(tmp_tfm, evmkey, evmkey_len); ++ if (rc) { ++ crypto_free_shash(tmp_tfm); + mutex_unlock(&mutex); + return ERR_PTR(rc); + } +- if (type == EVM_XATTR_HMAC) { +- rc = crypto_shash_setkey(*tfm, evmkey, evmkey_len); +- if (rc) { +- crypto_free_shash(*tfm); +- *tfm = NULL; +- mutex_unlock(&mutex); +- return ERR_PTR(rc); +- } +- } +-out: +- mutex_unlock(&mutex); + } +- ++ *tfm = tmp_tfm; ++unlock: ++ mutex_unlock(&mutex); ++alloc: + desc = kmalloc(sizeof(*desc) + crypto_shash_descsize(*tfm), + GFP_KERNEL); + if (!desc) +diff --git a/security/integrity/ima/ima_crypto.c b/security/integrity/ima/ima_crypto.c +index 7967a6904851..e8fa23cd4a6c 100644 +--- a/security/integrity/ima/ima_crypto.c ++++ b/security/integrity/ima/ima_crypto.c +@@ -413,7 +413,7 @@ int ima_calc_file_hash(struct file *file, struct ima_digest_data *hash) + loff_t i_size; + int rc; + struct file *f = file; +- bool new_file_instance = false, modified_flags = false; ++ bool new_file_instance = false, modified_mode = false; + + /* + * For consistency, fail file's opened with the O_DIRECT flag on +@@ -433,13 +433,13 @@ int ima_calc_file_hash(struct file *file, struct ima_digest_data *hash) + f = dentry_open(&file->f_path, flags, file->f_cred); + if (IS_ERR(f)) { + /* +- * Cannot open the file again, lets modify f_flags ++ * Cannot open the file again, lets modify f_mode + * of original and continue + */ + pr_info_ratelimited("Unable to reopen file for reading.\n"); + f = file; +- f->f_flags |= FMODE_READ; +- modified_flags = true; ++ f->f_mode |= FMODE_READ; ++ modified_mode = true; + } else { + new_file_instance = true; + } +@@ -457,8 +457,8 @@ int ima_calc_file_hash(struct file *file, struct ima_digest_data *hash) + out: + if (new_file_instance) + fput(f); +- else if (modified_flags) +- f->f_flags &= ~FMODE_READ; ++ else if (modified_mode) ++ f->f_mode &= ~FMODE_READ; + return rc; + } + +diff --git a/security/integrity/ima/ima_fs.c b/security/integrity/ima/ima_fs.c +index 2000e8df0301..68571c40d61f 100644 +--- a/security/integrity/ima/ima_fs.c ++++ b/security/integrity/ima/ima_fs.c +@@ -340,8 +340,7 @@ static ssize_t ima_write_policy(struct file *file, const char __user *buf, + integrity_audit_msg(AUDIT_INTEGRITY_STATUS, NULL, NULL, + "policy_update", "signed policy required", + 1, 0); +- if (ima_appraise & IMA_APPRAISE_ENFORCE) +- result = -EACCES; ++ result = -EACCES; + } else { + result = ima_parse_add_rule(data); + } +diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c +index 872a852de75c..d531e1bc2b81 100644 +--- a/sound/core/pcm_lib.c ++++ b/sound/core/pcm_lib.c +@@ -433,6 +433,7 @@ static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream *substream, + + no_delta_check: + if (runtime->status->hw_ptr == new_hw_ptr) { ++ runtime->hw_ptr_jiffies = curr_jiffies; + update_audio_tstamp(substream, &curr_tstamp, &audio_tstamp); + return 0; + } +diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c +index d73c814358bf..041d2a32059b 100644 +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -86,6 +86,14 @@ struct alc_spec { + + unsigned int gpio_mute_led_mask; + unsigned int gpio_mic_led_mask; ++ unsigned int mute_led_coef_idx; ++ unsigned int mute_led_coefbit_mask; ++ unsigned int mute_led_coefbit_on; ++ unsigned int mute_led_coefbit_off; ++ unsigned int mic_led_coef_idx; ++ unsigned int mic_led_coefbit_mask; ++ unsigned int mic_led_coefbit_on; ++ unsigned int mic_led_coefbit_off; + + hda_nid_t headset_mic_pin; + hda_nid_t headphone_mic_pin; +@@ -2449,6 +2457,7 @@ static const struct snd_pci_quirk alc882_fixup_tbl[] = { + SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE), + SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS), + SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_CLEVO_P950), ++ SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_CLEVO_P950), + SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950), + SND_PCI_QUIRK(0x1462, 0x1275, "MSI-GL63", ALC1220_FIXUP_CLEVO_P950), + SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950), +@@ -2464,6 +2473,9 @@ static const struct snd_pci_quirk alc882_fixup_tbl[] = { + SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950), + SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), + SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), ++ SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), ++ SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), ++ SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170", ALC1220_FIXUP_CLEVO_PB51ED_PINS), + SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD), + SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD), + SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530), +@@ -4182,6 +4194,111 @@ static void alc280_fixup_hp_gpio4(struct hda_codec *codec, + } + } + ++/* update mute-LED according to the speaker mute state via COEF bit */ ++static void alc_fixup_mute_led_coefbit_hook(void *private_data, int enabled) ++{ ++ struct hda_codec *codec = private_data; ++ struct alc_spec *spec = codec->spec; ++ ++ if (spec->mute_led_polarity) ++ enabled = !enabled; ++ ++ /* temporarily power up/down for setting COEF bit */ ++ enabled ? alc_update_coef_idx(codec, spec->mute_led_coef_idx, ++ spec->mute_led_coefbit_mask, spec->mute_led_coefbit_off) : ++ alc_update_coef_idx(codec, spec->mute_led_coef_idx, ++ spec->mute_led_coefbit_mask, spec->mute_led_coefbit_on); ++} ++ ++static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec, ++ const struct hda_fixup *fix, ++ int action) ++{ ++ struct alc_spec *spec = codec->spec; ++ ++ if (action == HDA_FIXUP_ACT_PRE_PROBE) { ++ spec->mute_led_polarity = 0; ++ spec->mute_led_coef_idx = 0x0b; ++ spec->mute_led_coefbit_mask = 1<<3; ++ spec->mute_led_coefbit_on = 1<<3; ++ spec->mute_led_coefbit_off = 0; ++ spec->gen.vmaster_mute.hook = alc_fixup_mute_led_coefbit_hook; ++ spec->gen.vmaster_mute_enum = 1; ++ } ++} ++ ++static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec, ++ const struct hda_fixup *fix, ++ int action) ++{ ++ struct alc_spec *spec = codec->spec; ++ ++ if (action == HDA_FIXUP_ACT_PRE_PROBE) { ++ spec->mute_led_polarity = 0; ++ spec->mute_led_coef_idx = 0x34; ++ spec->mute_led_coefbit_mask = 1<<5; ++ spec->mute_led_coefbit_on = 0; ++ spec->mute_led_coefbit_off = 1<<5; ++ spec->gen.vmaster_mute.hook = alc_fixup_mute_led_coefbit_hook; ++ spec->gen.vmaster_mute_enum = 1; ++ } ++} ++ ++/* turn on/off mic-mute LED per capture hook by coef bit */ ++static void alc_hp_cap_micmute_update(struct hda_codec *codec) ++{ ++ struct alc_spec *spec = codec->spec; ++ ++ if (spec->gen.micmute_led.led_value) ++ alc_update_coef_idx(codec, spec->mic_led_coef_idx, ++ spec->mic_led_coefbit_mask, spec->mic_led_coefbit_on); ++ else ++ alc_update_coef_idx(codec, spec->mic_led_coef_idx, ++ spec->mic_led_coefbit_mask, spec->mic_led_coefbit_off); ++} ++ ++static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec, ++ const struct hda_fixup *fix, int action) ++{ ++ struct alc_spec *spec = codec->spec; ++ ++ if (action == HDA_FIXUP_ACT_PRE_PROBE) { ++ spec->mic_led_coef_idx = 0x19; ++ spec->mic_led_coefbit_mask = 1<<13; ++ spec->mic_led_coefbit_on = 1<<13; ++ spec->mic_led_coefbit_off = 0; ++ snd_hda_gen_add_micmute_led(codec, alc_hp_cap_micmute_update); ++ } ++} ++ ++static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec, ++ const struct hda_fixup *fix, int action) ++{ ++ struct alc_spec *spec = codec->spec; ++ ++ if (action == HDA_FIXUP_ACT_PRE_PROBE) { ++ spec->mic_led_coef_idx = 0x35; ++ spec->mic_led_coefbit_mask = 3<<2; ++ spec->mic_led_coefbit_on = 2<<2; ++ spec->mic_led_coefbit_off = 1<<2; ++ snd_hda_gen_add_micmute_led(codec, alc_hp_cap_micmute_update); ++ } ++} ++ ++static void alc285_fixup_hp_mute_led(struct hda_codec *codec, ++ const struct hda_fixup *fix, int action) ++{ ++ alc285_fixup_hp_mute_led_coefbit(codec, fix, action); ++ alc285_fixup_hp_coef_micmute_led(codec, fix, action); ++} ++ ++static void alc236_fixup_hp_mute_led(struct hda_codec *codec, ++ const struct hda_fixup *fix, int action) ++{ ++ alc236_fixup_hp_mute_led_coefbit(codec, fix, action); ++ alc236_fixup_hp_coef_micmute_led(codec, fix, action); ++} ++ + #if IS_REACHABLE(CONFIG_INPUT) + static void gpio2_mic_hotkey_event(struct hda_codec *codec, + struct hda_jack_callback *event) +@@ -5980,6 +6097,10 @@ enum { + ALC294_FIXUP_ASUS_HPE, + ALC294_FIXUP_ASUS_COEF_1B, + ALC285_FIXUP_HP_GPIO_LED, ++ ALC285_FIXUP_HP_MUTE_LED, ++ ALC236_FIXUP_HP_MUTE_LED, ++ ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, ++ ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, + }; + + static const struct hda_fixup alc269_fixups[] = { +@@ -7128,6 +7249,30 @@ static const struct hda_fixup alc269_fixups[] = { + .type = HDA_FIXUP_FUNC, + .v.func = alc285_fixup_hp_gpio_led, + }, ++ [ALC285_FIXUP_HP_MUTE_LED] = { ++ .type = HDA_FIXUP_FUNC, ++ .v.func = alc285_fixup_hp_mute_led, ++ }, ++ [ALC236_FIXUP_HP_MUTE_LED] = { ++ .type = HDA_FIXUP_FUNC, ++ .v.func = alc236_fixup_hp_mute_led, ++ }, ++ [ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = { ++ .type = HDA_FIXUP_VERBS, ++ .v.verbs = (const struct hda_verb[]) { ++ { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 }, ++ { } ++ }, ++ }, ++ [ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = { ++ .type = HDA_FIXUP_PINS, ++ .v.pins = (const struct hda_pintbl[]) { ++ { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ ++ { } ++ }, ++ .chained = true, ++ .chain_id = ALC269_FIXUP_HEADSET_MODE ++ }, + }; + + static const struct snd_pci_quirk alc269_fixup_tbl[] = { +@@ -7273,6 +7418,8 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), + SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3), + SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_LED), ++ SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED), ++ SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED), + SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC), + SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300), + SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), +@@ -7293,6 +7440,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC), + SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC), + SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE), ++ SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW), + SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC), + SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B), +@@ -7321,6 +7469,8 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE), + SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_HEADSET_MODE), + SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC), ++ SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), ++ SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), + SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8), + SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC), + SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC), +@@ -7905,6 +8055,18 @@ static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = { + {0x12, 0x90a60130}, + {0x17, 0x90170110}, + {0x21, 0x03211020}), ++ SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, ++ {0x12, 0x90a60120}, ++ {0x17, 0x90170110}, ++ {0x21, 0x04211030}), ++ SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, ++ {0x12, 0x90a60130}, ++ {0x17, 0x90170110}, ++ {0x21, 0x03211020}), ++ SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, ++ {0x12, 0x90a60130}, ++ {0x17, 0x90170110}, ++ {0x21, 0x03211020}), + SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, + {0x14, 0x90170110}, + {0x21, 0x04211020}), +diff --git a/sound/pci/ice1712/ice1712.c b/sound/pci/ice1712/ice1712.c +index 884d0cdec08c..73e1e5400506 100644 +--- a/sound/pci/ice1712/ice1712.c ++++ b/sound/pci/ice1712/ice1712.c +@@ -2332,7 +2332,8 @@ static int snd_ice1712_chip_init(struct snd_ice1712 *ice) + pci_write_config_byte(ice->pci, 0x61, ice->eeprom.data[ICE_EEP1_ACLINK]); + pci_write_config_byte(ice->pci, 0x62, ice->eeprom.data[ICE_EEP1_I2SID]); + pci_write_config_byte(ice->pci, 0x63, ice->eeprom.data[ICE_EEP1_SPDIF]); +- if (ice->eeprom.subvendor != ICE1712_SUBDEVICE_STDSP24) { ++ if (ice->eeprom.subvendor != ICE1712_SUBDEVICE_STDSP24 && ++ ice->eeprom.subvendor != ICE1712_SUBDEVICE_STAUDIO_ADCIII) { + ice->gpio.write_mask = ice->eeprom.gpiomask; + ice->gpio.direction = ice->eeprom.gpiodir; + snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, +diff --git a/tools/bootconfig/main.c b/tools/bootconfig/main.c +index a9b97814d1a9..37fb2e85de12 100644 +--- a/tools/bootconfig/main.c ++++ b/tools/bootconfig/main.c +@@ -287,6 +287,7 @@ int apply_xbc(const char *path, const char *xbc_path) + ret = delete_xbc(path); + if (ret < 0) { + pr_err("Failed to delete previous boot config: %d\n", ret); ++ free(data); + return ret; + } + +@@ -294,24 +295,27 @@ int apply_xbc(const char *path, const char *xbc_path) + fd = open(path, O_RDWR | O_APPEND); + if (fd < 0) { + pr_err("Failed to open %s: %d\n", path, fd); ++ free(data); + return fd; + } + /* TODO: Ensure the @path is initramfs/initrd image */ + ret = write(fd, data, size + 8); + if (ret < 0) { + pr_err("Failed to apply a boot config: %d\n", ret); +- return ret; ++ goto out; + } + /* Write a magic word of the bootconfig */ + ret = write(fd, BOOTCONFIG_MAGIC, BOOTCONFIG_MAGIC_LEN); + if (ret < 0) { + pr_err("Failed to apply a boot config magic: %d\n", ret); +- return ret; ++ goto out; + } ++ ret = 0; ++out: + close(fd); + free(data); + +- return 0; ++ return ret; + } + + int usage(void) +diff --git a/tools/testing/selftests/bpf/prog_tests/mmap.c b/tools/testing/selftests/bpf/prog_tests/mmap.c +index b0e789678aa4..5495b669fccc 100644 +--- a/tools/testing/selftests/bpf/prog_tests/mmap.c ++++ b/tools/testing/selftests/bpf/prog_tests/mmap.c +@@ -19,7 +19,7 @@ void test_mmap(void) + const size_t map_sz = roundup_page(sizeof(struct map_data)); + const int zero = 0, one = 1, two = 2, far = 1500; + const long page_size = sysconf(_SC_PAGE_SIZE); +- int err, duration = 0, i, data_map_fd; ++ int err, duration = 0, i, data_map_fd, rdmap_fd; + struct bpf_map *data_map, *bss_map; + void *bss_mmaped = NULL, *map_mmaped = NULL, *tmp1, *tmp2; + struct test_mmap__bss *bss_data; +@@ -36,6 +36,17 @@ void test_mmap(void) + data_map = skel->maps.data_map; + data_map_fd = bpf_map__fd(data_map); + ++ rdmap_fd = bpf_map__fd(skel->maps.rdonly_map); ++ tmp1 = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, rdmap_fd, 0); ++ if (CHECK(tmp1 != MAP_FAILED, "rdonly_write_mmap", "unexpected success\n")) { ++ munmap(tmp1, 4096); ++ goto cleanup; ++ } ++ /* now double-check if it's mmap()'able at all */ ++ tmp1 = mmap(NULL, 4096, PROT_READ, MAP_SHARED, rdmap_fd, 0); ++ if (CHECK(tmp1 == MAP_FAILED, "rdonly_read_mmap", "failed: %d\n", errno)) ++ goto cleanup; ++ + bss_mmaped = mmap(NULL, bss_sz, PROT_READ | PROT_WRITE, MAP_SHARED, + bpf_map__fd(bss_map), 0); + if (CHECK(bss_mmaped == MAP_FAILED, "bss_mmap", +diff --git a/tools/testing/selftests/bpf/progs/test_mmap.c b/tools/testing/selftests/bpf/progs/test_mmap.c +index 6239596cd14e..4eb42cff5fe9 100644 +--- a/tools/testing/selftests/bpf/progs/test_mmap.c ++++ b/tools/testing/selftests/bpf/progs/test_mmap.c +@@ -7,6 +7,14 @@ + + char _license[] SEC("license") = "GPL"; + ++struct { ++ __uint(type, BPF_MAP_TYPE_ARRAY); ++ __uint(max_entries, 4096); ++ __uint(map_flags, BPF_F_MMAPABLE | BPF_F_RDONLY_PROG); ++ __type(key, __u32); ++ __type(value, char); ++} rdonly_map SEC(".maps"); ++ + struct { + __uint(type, BPF_MAP_TYPE_ARRAY); + __uint(max_entries, 512 * 4); /* at least 4 pages of data */ +diff --git a/tools/testing/selftests/ftrace/ftracetest b/tools/testing/selftests/ftrace/ftracetest +index 144308a757b7..19e9236dec5e 100755 +--- a/tools/testing/selftests/ftrace/ftracetest ++++ b/tools/testing/selftests/ftrace/ftracetest +@@ -17,6 +17,7 @@ echo " -v|--verbose Increase verbosity of test messages" + echo " -vv Alias of -v -v (Show all results in stdout)" + echo " -vvv Alias of -v -v -v (Show all commands immediately)" + echo " --fail-unsupported Treat UNSUPPORTED as a failure" ++echo " --fail-unresolved Treat UNRESOLVED as a failure" + echo " -d|--debug Debug mode (trace all shell commands)" + echo " -l|--logdir Save logs on the " + echo " If is -, all logs output in console only" +@@ -112,6 +113,10 @@ parse_opts() { # opts + UNSUPPORTED_RESULT=1 + shift 1 + ;; ++ --fail-unresolved) ++ UNRESOLVED_RESULT=1 ++ shift 1 ++ ;; + --logdir|-l) + LOG_DIR=$2 + shift 2 +@@ -176,6 +181,7 @@ KEEP_LOG=0 + DEBUG=0 + VERBOSE=0 + UNSUPPORTED_RESULT=0 ++UNRESOLVED_RESULT=0 + STOP_FAILURE=0 + # Parse command-line options + parse_opts $* +@@ -280,7 +286,7 @@ eval_result() { # sigval + $UNRESOLVED) + prlog " [${color_blue}UNRESOLVED${color_reset}]" + UNRESOLVED_CASES="$UNRESOLVED_CASES $CASENO" +- return 1 # this is a kind of bug.. something happened. ++ return $UNRESOLVED_RESULT # depends on use case + ;; + $UNTESTED) + prlog " [${color_blue}UNTESTED${color_reset}]" +diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile +index d91c53b726e6..75dec268787f 100644 +--- a/tools/testing/selftests/kvm/Makefile ++++ b/tools/testing/selftests/kvm/Makefile +@@ -5,8 +5,34 @@ all: + + top_srcdir = ../../../.. + KSFT_KHDR_INSTALL := 1 ++ ++# For cross-builds to work, UNAME_M has to map to ARCH and arch specific ++# directories and targets in this Makefile. "uname -m" doesn't map to ++# arch specific sub-directory names. ++# ++# UNAME_M variable to used to run the compiles pointing to the right arch ++# directories and build the right targets for these supported architectures. ++# ++# TEST_GEN_PROGS and LIBKVM are set using UNAME_M variable. ++# LINUX_TOOL_ARCH_INCLUDE is set using ARCH variable. ++# ++# x86_64 targets are named to include x86_64 as a suffix and directories ++# for includes are in x86_64 sub-directory. s390x and aarch64 follow the ++# same convention. "uname -m" doesn't result in the correct mapping for ++# s390x and aarch64. ++# ++# No change necessary for x86_64 + UNAME_M := $(shell uname -m) + ++# Set UNAME_M for arm64 compile/install to work ++ifeq ($(ARCH),arm64) ++ UNAME_M := aarch64 ++endif ++# Set UNAME_M s390x compile/install to work ++ifeq ($(ARCH),s390) ++ UNAME_M := s390x ++endif ++ + LIBKVM = lib/assert.c lib/elf.c lib/io.c lib/kvm_util.c lib/sparsebit.c + LIBKVM_x86_64 = lib/x86_64/processor.c lib/x86_64/vmx.c lib/x86_64/svm.c lib/x86_64/ucall.c + LIBKVM_aarch64 = lib/aarch64/processor.c lib/aarch64/ucall.c +@@ -47,7 +73,7 @@ LIBKVM += $(LIBKVM_$(UNAME_M)) + INSTALL_HDR_PATH = $(top_srcdir)/usr + LINUX_HDR_PATH = $(INSTALL_HDR_PATH)/include/ + LINUX_TOOL_INCLUDE = $(top_srcdir)/tools/include +-LINUX_TOOL_ARCH_INCLUDE = $(top_srcdir)/tools/arch/x86/include ++LINUX_TOOL_ARCH_INCLUDE = $(top_srcdir)/tools/arch/$(ARCH)/include + CFLAGS += -Wall -Wstrict-prototypes -Wuninitialized -O2 -g -std=gnu99 \ + -fno-stack-protector -fno-PIE -I$(LINUX_TOOL_INCLUDE) \ + -I$(LINUX_TOOL_ARCH_INCLUDE) -I$(LINUX_HDR_PATH) -Iinclude \ +@@ -78,6 +104,7 @@ $(LIBKVM_OBJ): $(OUTPUT)/%.o: %.c + $(OUTPUT)/libkvm.a: $(LIBKVM_OBJ) + $(AR) crs $@ $^ + ++x := $(shell mkdir -p $(sort $(dir $(TEST_GEN_PROGS)))) + all: $(STATIC_LIBS) + $(TEST_GEN_PROGS): $(STATIC_LIBS) + +diff --git a/tools/testing/selftests/kvm/include/evmcs.h b/tools/testing/selftests/kvm/include/evmcs.h +index 4912d23844bc..e31ac9c5ead0 100644 +--- a/tools/testing/selftests/kvm/include/evmcs.h ++++ b/tools/testing/selftests/kvm/include/evmcs.h +@@ -217,8 +217,8 @@ struct hv_enlightened_vmcs { + #define HV_X64_MSR_VP_ASSIST_PAGE_ADDRESS_MASK \ + (~((1ull << HV_X64_MSR_VP_ASSIST_PAGE_ADDRESS_SHIFT) - 1)) + +-struct hv_enlightened_vmcs *current_evmcs; +-struct hv_vp_assist_page *current_vp_assist; ++extern struct hv_enlightened_vmcs *current_evmcs; ++extern struct hv_vp_assist_page *current_vp_assist; + + int vcpu_enable_evmcs(struct kvm_vm *vm, int vcpu_id); + +diff --git a/tools/testing/selftests/kvm/lib/x86_64/vmx.c b/tools/testing/selftests/kvm/lib/x86_64/vmx.c +index 7aaa99ca4dbc..ce528f3cf093 100644 +--- a/tools/testing/selftests/kvm/lib/x86_64/vmx.c ++++ b/tools/testing/selftests/kvm/lib/x86_64/vmx.c +@@ -17,6 +17,9 @@ + + bool enable_evmcs; + ++struct hv_enlightened_vmcs *current_evmcs; ++struct hv_vp_assist_page *current_vp_assist; ++ + struct eptPageTableEntry { + uint64_t readable:1; + uint64_t writable:1;