diff options
author | Mike Pagano <mpagano@gentoo.org> | 2019-05-31 11:02:12 -0400 |
---|---|---|
committer | Mike Pagano <mpagano@gentoo.org> | 2019-05-31 11:02:12 -0400 |
commit | 598ad5bdcb5346e952e480a99a53f2b9157112d0 (patch) | |
tree | 393df5d7382f1bd3126b96cfdfd762ac409206c4 | |
parent | Linux patch 4.19.46 (diff) | |
download | linux-patches-598ad5bdcb5346e952e480a99a53f2b9157112d0.tar.gz linux-patches-598ad5bdcb5346e952e480a99a53f2b9157112d0.tar.bz2 linux-patches-598ad5bdcb5346e952e480a99a53f2b9157112d0.zip |
Linux patch 4.19.474.19-48
Signed-off-by: Mike Pagano <mpagano@gentoo.org>
-rw-r--r-- | 0000_README | 4 | ||||
-rw-r--r-- | 1046_linux-4.19.47.patch | 9410 |
2 files changed, 9414 insertions, 0 deletions
diff --git a/0000_README b/0000_README index 87c4eaf7..0c0cd1aa 100644 --- a/0000_README +++ b/0000_README @@ -227,6 +227,10 @@ Patch: 1045_linux-4.19.46.patch From: http://www.kernel.org Desc: Linux 4.19.46 +Patch: 1046_linux-4.19.47.patch +From: http://www.kernel.org +Desc: Linux 4.19.47 + Patch: 1500_XATTR_USER_PREFIX.patch From: https://bugs.gentoo.org/show_bug.cgi?id=470644 Desc: Support for namespace user.pax.* on tmpfs. diff --git a/1046_linux-4.19.47.patch b/1046_linux-4.19.47.patch new file mode 100644 index 00000000..645af41e --- /dev/null +++ b/1046_linux-4.19.47.patch @@ -0,0 +1,9410 @@ +diff --git a/Documentation/arm64/silicon-errata.txt b/Documentation/arm64/silicon-errata.txt +index 3c6fc2e08d04..eeb3fc9d777b 100644 +--- a/Documentation/arm64/silicon-errata.txt ++++ b/Documentation/arm64/silicon-errata.txt +@@ -58,6 +58,7 @@ stable kernels. + | ARM | Cortex-A72 | #853709 | N/A | + | ARM | Cortex-A73 | #858921 | ARM64_ERRATUM_858921 | + | ARM | Cortex-A55 | #1024718 | ARM64_ERRATUM_1024718 | ++| ARM | Cortex-A76 | #1463225 | ARM64_ERRATUM_1463225 | + | ARM | MMU-500 | #841119,#826419 | N/A | + | | | | | + | Cavium | ThunderX ITS | #22375, #24313 | CAVIUM_ERRATUM_22375 | +diff --git a/Documentation/sysctl/net.txt b/Documentation/sysctl/net.txt +index 9ecde517728c..2793d4eac55f 100644 +--- a/Documentation/sysctl/net.txt ++++ b/Documentation/sysctl/net.txt +@@ -92,6 +92,14 @@ Values : + 0 - disable JIT kallsyms export (default value) + 1 - enable JIT kallsyms export for privileged users only + ++bpf_jit_limit ++------------- ++ ++This enforces a global limit for memory allocations to the BPF JIT ++compiler in order to reject unprivileged JIT requests once it has ++been surpassed. bpf_jit_limit contains the value of the global limit ++in bytes. ++ + dev_weight + -------------- + +diff --git a/Makefile b/Makefile +index 5383dd317d59..b3ba28ff73d5 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 4 + PATCHLEVEL = 19 +-SUBLEVEL = 46 ++SUBLEVEL = 47 + EXTRAVERSION = + NAME = "People's Front" + +diff --git a/arch/arm/include/asm/cp15.h b/arch/arm/include/asm/cp15.h +index 07e27f212dc7..d2453e2d3f1f 100644 +--- a/arch/arm/include/asm/cp15.h ++++ b/arch/arm/include/asm/cp15.h +@@ -68,6 +68,8 @@ + #define BPIALL __ACCESS_CP15(c7, 0, c5, 6) + #define ICIALLU __ACCESS_CP15(c7, 0, c5, 0) + ++#define CNTVCT __ACCESS_CP15_64(1, c14) ++ + extern unsigned long cr_alignment; /* defined in entry-armv.S */ + + static inline unsigned long get_cr(void) +diff --git a/arch/arm/vdso/vgettimeofday.c b/arch/arm/vdso/vgettimeofday.c +index a9dd619c6c29..7bdbf5d5c47d 100644 +--- a/arch/arm/vdso/vgettimeofday.c ++++ b/arch/arm/vdso/vgettimeofday.c +@@ -18,9 +18,9 @@ + #include <linux/compiler.h> + #include <linux/hrtimer.h> + #include <linux/time.h> +-#include <asm/arch_timer.h> + #include <asm/barrier.h> + #include <asm/bug.h> ++#include <asm/cp15.h> + #include <asm/page.h> + #include <asm/unistd.h> + #include <asm/vdso_datapage.h> +@@ -123,7 +123,8 @@ static notrace u64 get_ns(struct vdso_data *vdata) + u64 cycle_now; + u64 nsec; + +- cycle_now = arch_counter_get_cntvct(); ++ isb(); ++ cycle_now = read_sysreg(CNTVCT); + + cycle_delta = (cycle_now - vdata->cs_cycle_last) & vdata->cs_mask; + +diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig +index 1b1a0e95c751..8790a29d0af4 100644 +--- a/arch/arm64/Kconfig ++++ b/arch/arm64/Kconfig +@@ -479,6 +479,24 @@ config ARM64_ERRATUM_1024718 + + If unsure, say Y. + ++config ARM64_ERRATUM_1463225 ++ bool "Cortex-A76: Software Step might prevent interrupt recognition" ++ default y ++ help ++ This option adds a workaround for Arm Cortex-A76 erratum 1463225. ++ ++ On the affected Cortex-A76 cores (r0p0 to r3p1), software stepping ++ of a system call instruction (SVC) can prevent recognition of ++ subsequent interrupts when software stepping is disabled in the ++ exception handler of the system call and either kernel debugging ++ is enabled or VHE is in use. ++ ++ Work around the erratum by triggering a dummy step exception ++ when handling a system call from a task that is being stepped ++ in a VHE configuration of the kernel. ++ ++ If unsure, say Y. ++ + config CAVIUM_ERRATUM_22375 + bool "Cavium erratum 22375, 24313" + default y +diff --git a/arch/arm64/include/asm/cpucaps.h b/arch/arm64/include/asm/cpucaps.h +index ae1f70450fb2..25ce9056cf64 100644 +--- a/arch/arm64/include/asm/cpucaps.h ++++ b/arch/arm64/include/asm/cpucaps.h +@@ -51,7 +51,8 @@ + #define ARM64_SSBD 30 + #define ARM64_MISMATCHED_CACHE_TYPE 31 + #define ARM64_HAS_STAGE2_FWB 32 ++#define ARM64_WORKAROUND_1463225 33 + +-#define ARM64_NCAPS 33 ++#define ARM64_NCAPS 34 + + #endif /* __ASM_CPUCAPS_H */ +diff --git a/arch/arm64/include/asm/cputype.h b/arch/arm64/include/asm/cputype.h +index ea690b3562af..b4a48419769f 100644 +--- a/arch/arm64/include/asm/cputype.h ++++ b/arch/arm64/include/asm/cputype.h +@@ -86,6 +86,7 @@ + #define ARM_CPU_PART_CORTEX_A75 0xD0A + #define ARM_CPU_PART_CORTEX_A35 0xD04 + #define ARM_CPU_PART_CORTEX_A55 0xD05 ++#define ARM_CPU_PART_CORTEX_A76 0xD0B + + #define APM_CPU_PART_POTENZA 0x000 + +@@ -110,6 +111,7 @@ + #define MIDR_CORTEX_A75 MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A75) + #define MIDR_CORTEX_A35 MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A35) + #define MIDR_CORTEX_A55 MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A55) ++#define MIDR_CORTEX_A76 MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A76) + #define MIDR_THUNDERX MIDR_CPU_MODEL(ARM_CPU_IMP_CAVIUM, CAVIUM_CPU_PART_THUNDERX) + #define MIDR_THUNDERX_81XX MIDR_CPU_MODEL(ARM_CPU_IMP_CAVIUM, CAVIUM_CPU_PART_THUNDERX_81XX) + #define MIDR_THUNDERX_83XX MIDR_CPU_MODEL(ARM_CPU_IMP_CAVIUM, CAVIUM_CPU_PART_THUNDERX_83XX) +diff --git a/arch/arm64/include/asm/pgtable.h b/arch/arm64/include/asm/pgtable.h +index 1bdeca8918a6..ea423db39364 100644 +--- a/arch/arm64/include/asm/pgtable.h ++++ b/arch/arm64/include/asm/pgtable.h +@@ -444,6 +444,8 @@ static inline phys_addr_t pmd_page_paddr(pmd_t pmd) + return __pmd_to_phys(pmd); + } + ++static inline void pte_unmap(pte_t *pte) { } ++ + /* Find an entry in the third-level page table. */ + #define pte_index(addr) (((addr) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1)) + +@@ -452,7 +454,6 @@ static inline phys_addr_t pmd_page_paddr(pmd_t pmd) + + #define pte_offset_map(dir,addr) pte_offset_kernel((dir), (addr)) + #define pte_offset_map_nested(dir,addr) pte_offset_kernel((dir), (addr)) +-#define pte_unmap(pte) do { } while (0) + #define pte_unmap_nested(pte) do { } while (0) + + #define pte_set_fixmap(addr) ((pte_t *)set_fixmap_offset(FIX_PTE, addr)) +diff --git a/arch/arm64/include/asm/vdso_datapage.h b/arch/arm64/include/asm/vdso_datapage.h +index 2b9a63771eda..f89263c8e11a 100644 +--- a/arch/arm64/include/asm/vdso_datapage.h ++++ b/arch/arm64/include/asm/vdso_datapage.h +@@ -38,6 +38,7 @@ struct vdso_data { + __u32 tz_minuteswest; /* Whacky timezone stuff */ + __u32 tz_dsttime; + __u32 use_syscall; ++ __u32 hrtimer_res; + }; + + #endif /* !__ASSEMBLY__ */ +diff --git a/arch/arm64/kernel/asm-offsets.c b/arch/arm64/kernel/asm-offsets.c +index 323aeb5f2fe6..92fba851ce53 100644 +--- a/arch/arm64/kernel/asm-offsets.c ++++ b/arch/arm64/kernel/asm-offsets.c +@@ -99,7 +99,7 @@ int main(void) + DEFINE(CLOCK_REALTIME, CLOCK_REALTIME); + DEFINE(CLOCK_MONOTONIC, CLOCK_MONOTONIC); + DEFINE(CLOCK_MONOTONIC_RAW, CLOCK_MONOTONIC_RAW); +- DEFINE(CLOCK_REALTIME_RES, MONOTONIC_RES_NSEC); ++ DEFINE(CLOCK_REALTIME_RES, offsetof(struct vdso_data, hrtimer_res)); + DEFINE(CLOCK_REALTIME_COARSE, CLOCK_REALTIME_COARSE); + DEFINE(CLOCK_MONOTONIC_COARSE,CLOCK_MONOTONIC_COARSE); + DEFINE(CLOCK_COARSE_RES, LOW_RES_NSEC); +diff --git a/arch/arm64/kernel/cpu_errata.c b/arch/arm64/kernel/cpu_errata.c +index dec10898d688..dc6c535cbd13 100644 +--- a/arch/arm64/kernel/cpu_errata.c ++++ b/arch/arm64/kernel/cpu_errata.c +@@ -411,6 +411,22 @@ static bool has_ssbd_mitigation(const struct arm64_cpu_capabilities *entry, + } + #endif /* CONFIG_ARM64_SSBD */ + ++#ifdef CONFIG_ARM64_ERRATUM_1463225 ++DEFINE_PER_CPU(int, __in_cortex_a76_erratum_1463225_wa); ++ ++static bool ++has_cortex_a76_erratum_1463225(const struct arm64_cpu_capabilities *entry, ++ int scope) ++{ ++ u32 midr = read_cpuid_id(); ++ /* Cortex-A76 r0p0 - r3p1 */ ++ struct midr_range range = MIDR_RANGE(MIDR_CORTEX_A76, 0, 0, 3, 1); ++ ++ WARN_ON(scope != SCOPE_LOCAL_CPU || preemptible()); ++ return is_midr_in_range(midr, &range) && is_kernel_in_hyp_mode(); ++} ++#endif ++ + #define CAP_MIDR_RANGE(model, v_min, r_min, v_max, r_max) \ + .matches = is_affected_midr_range, \ + .midr_range = MIDR_RANGE(model, v_min, r_min, v_max, r_max) +@@ -679,6 +695,14 @@ const struct arm64_cpu_capabilities arm64_errata[] = { + .type = ARM64_CPUCAP_LOCAL_CPU_ERRATUM, + .matches = has_ssbd_mitigation, + }, ++#endif ++#ifdef CONFIG_ARM64_ERRATUM_1463225 ++ { ++ .desc = "ARM erratum 1463225", ++ .capability = ARM64_WORKAROUND_1463225, ++ .type = ARM64_CPUCAP_LOCAL_CPU_ERRATUM, ++ .matches = has_cortex_a76_erratum_1463225, ++ }, + #endif + { + } +diff --git a/arch/arm64/kernel/cpu_ops.c b/arch/arm64/kernel/cpu_ops.c +index ea001241bdd4..00f8b8612b69 100644 +--- a/arch/arm64/kernel/cpu_ops.c ++++ b/arch/arm64/kernel/cpu_ops.c +@@ -85,6 +85,7 @@ static const char *__init cpu_read_enable_method(int cpu) + pr_err("%pOF: missing enable-method property\n", + dn); + } ++ of_node_put(dn); + } else { + enable_method = acpi_get_enable_method(cpu); + if (!enable_method) { +diff --git a/arch/arm64/kernel/kaslr.c b/arch/arm64/kernel/kaslr.c +index b09b6f75f759..06941c1fe418 100644 +--- a/arch/arm64/kernel/kaslr.c ++++ b/arch/arm64/kernel/kaslr.c +@@ -145,15 +145,15 @@ u64 __init kaslr_early_init(u64 dt_phys) + + if (IS_ENABLED(CONFIG_RANDOMIZE_MODULE_REGION_FULL)) { + /* +- * Randomize the module region over a 4 GB window covering the ++ * Randomize the module region over a 2 GB window covering the + * kernel. This reduces the risk of modules leaking information + * about the address of the kernel itself, but results in + * branches between modules and the core kernel that are + * resolved via PLTs. (Branches between modules will be + * resolved normally.) + */ +- module_range = SZ_4G - (u64)(_end - _stext); +- module_alloc_base = max((u64)_end + offset - SZ_4G, ++ module_range = SZ_2G - (u64)(_end - _stext); ++ module_alloc_base = max((u64)_end + offset - SZ_2G, + (u64)MODULES_VADDR); + } else { + /* +diff --git a/arch/arm64/kernel/module.c b/arch/arm64/kernel/module.c +index f0f27aeefb73..0b368ceccee4 100644 +--- a/arch/arm64/kernel/module.c ++++ b/arch/arm64/kernel/module.c +@@ -56,7 +56,7 @@ void *module_alloc(unsigned long size) + * can simply omit this fallback in that case. + */ + p = __vmalloc_node_range(size, MODULE_ALIGN, module_alloc_base, +- module_alloc_base + SZ_4G, GFP_KERNEL, ++ module_alloc_base + SZ_2G, GFP_KERNEL, + PAGE_KERNEL_EXEC, 0, NUMA_NO_NODE, + __builtin_return_address(0)); + +diff --git a/arch/arm64/kernel/syscall.c b/arch/arm64/kernel/syscall.c +index 5610ac01c1ec..871c739f060a 100644 +--- a/arch/arm64/kernel/syscall.c ++++ b/arch/arm64/kernel/syscall.c +@@ -8,6 +8,7 @@ + #include <linux/syscalls.h> + + #include <asm/daifflags.h> ++#include <asm/debug-monitors.h> + #include <asm/fpsimd.h> + #include <asm/syscall.h> + #include <asm/thread_info.h> +@@ -60,6 +61,35 @@ static inline bool has_syscall_work(unsigned long flags) + int syscall_trace_enter(struct pt_regs *regs); + void syscall_trace_exit(struct pt_regs *regs); + ++#ifdef CONFIG_ARM64_ERRATUM_1463225 ++DECLARE_PER_CPU(int, __in_cortex_a76_erratum_1463225_wa); ++ ++static void cortex_a76_erratum_1463225_svc_handler(void) ++{ ++ u32 reg, val; ++ ++ if (!unlikely(test_thread_flag(TIF_SINGLESTEP))) ++ return; ++ ++ if (!unlikely(this_cpu_has_cap(ARM64_WORKAROUND_1463225))) ++ return; ++ ++ __this_cpu_write(__in_cortex_a76_erratum_1463225_wa, 1); ++ reg = read_sysreg(mdscr_el1); ++ val = reg | DBG_MDSCR_SS | DBG_MDSCR_KDE; ++ write_sysreg(val, mdscr_el1); ++ asm volatile("msr daifclr, #8"); ++ isb(); ++ ++ /* We will have taken a single-step exception by this point */ ++ ++ write_sysreg(reg, mdscr_el1); ++ __this_cpu_write(__in_cortex_a76_erratum_1463225_wa, 0); ++} ++#else ++static void cortex_a76_erratum_1463225_svc_handler(void) { } ++#endif /* CONFIG_ARM64_ERRATUM_1463225 */ ++ + static void el0_svc_common(struct pt_regs *regs, int scno, int sc_nr, + const syscall_fn_t syscall_table[]) + { +@@ -68,6 +98,7 @@ static void el0_svc_common(struct pt_regs *regs, int scno, int sc_nr, + regs->orig_x0 = regs->regs[0]; + regs->syscallno = scno; + ++ cortex_a76_erratum_1463225_svc_handler(); + local_daif_restore(DAIF_PROCCTX); + user_exit(); + +diff --git a/arch/arm64/kernel/vdso.c b/arch/arm64/kernel/vdso.c +index 2d419006ad43..ec0bb588d755 100644 +--- a/arch/arm64/kernel/vdso.c ++++ b/arch/arm64/kernel/vdso.c +@@ -232,6 +232,9 @@ void update_vsyscall(struct timekeeper *tk) + vdso_data->wtm_clock_sec = tk->wall_to_monotonic.tv_sec; + vdso_data->wtm_clock_nsec = tk->wall_to_monotonic.tv_nsec; + ++ /* Read without the seqlock held by clock_getres() */ ++ WRITE_ONCE(vdso_data->hrtimer_res, hrtimer_resolution); ++ + if (!use_syscall) { + /* tkr_mono.cycle_last == tkr_raw.cycle_last */ + vdso_data->cs_cycle_last = tk->tkr_mono.cycle_last; +diff --git a/arch/arm64/kernel/vdso/gettimeofday.S b/arch/arm64/kernel/vdso/gettimeofday.S +index e8f60112818f..856fee6d3512 100644 +--- a/arch/arm64/kernel/vdso/gettimeofday.S ++++ b/arch/arm64/kernel/vdso/gettimeofday.S +@@ -308,13 +308,14 @@ ENTRY(__kernel_clock_getres) + ccmp w0, #CLOCK_MONOTONIC_RAW, #0x4, ne + b.ne 1f + +- ldr x2, 5f ++ adr vdso_data, _vdso_data ++ ldr w2, [vdso_data, #CLOCK_REALTIME_RES] + b 2f + 1: + cmp w0, #CLOCK_REALTIME_COARSE + ccmp w0, #CLOCK_MONOTONIC_COARSE, #0x4, ne + b.ne 4f +- ldr x2, 6f ++ ldr x2, 5f + 2: + cbz x1, 3f + stp xzr, x2, [x1] +@@ -328,8 +329,6 @@ ENTRY(__kernel_clock_getres) + svc #0 + ret + 5: +- .quad CLOCK_REALTIME_RES +-6: + .quad CLOCK_COARSE_RES + .cfi_endproc + ENDPROC(__kernel_clock_getres) +diff --git a/arch/arm64/mm/dma-mapping.c b/arch/arm64/mm/dma-mapping.c +index c389f2bef938..d3a5bb16f0b2 100644 +--- a/arch/arm64/mm/dma-mapping.c ++++ b/arch/arm64/mm/dma-mapping.c +@@ -664,6 +664,11 @@ static int __iommu_mmap_attrs(struct device *dev, struct vm_area_struct *vma, + if (dma_mmap_from_dev_coherent(dev, vma, cpu_addr, size, &ret)) + return ret; + ++ if (!is_vmalloc_addr(cpu_addr)) { ++ unsigned long pfn = page_to_pfn(virt_to_page(cpu_addr)); ++ return __swiotlb_mmap_pfn(vma, pfn, size); ++ } ++ + if (attrs & DMA_ATTR_FORCE_CONTIGUOUS) { + /* + * DMA_ATTR_FORCE_CONTIGUOUS allocations are always remapped, +@@ -687,6 +692,11 @@ static int __iommu_get_sgtable(struct device *dev, struct sg_table *sgt, + unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT; + struct vm_struct *area = find_vm_area(cpu_addr); + ++ if (!is_vmalloc_addr(cpu_addr)) { ++ struct page *page = virt_to_page(cpu_addr); ++ return __swiotlb_get_sgtable_page(sgt, page, size); ++ } ++ + if (attrs & DMA_ATTR_FORCE_CONTIGUOUS) { + /* + * DMA_ATTR_FORCE_CONTIGUOUS allocations are always remapped, +diff --git a/arch/arm64/mm/fault.c b/arch/arm64/mm/fault.c +index a4c134677285..88cf0a0cb616 100644 +--- a/arch/arm64/mm/fault.c ++++ b/arch/arm64/mm/fault.c +@@ -827,14 +827,47 @@ void __init hook_debug_fault_code(int nr, + debug_fault_info[nr].name = name; + } + ++#ifdef CONFIG_ARM64_ERRATUM_1463225 ++DECLARE_PER_CPU(int, __in_cortex_a76_erratum_1463225_wa); ++ ++static int __exception ++cortex_a76_erratum_1463225_debug_handler(struct pt_regs *regs) ++{ ++ if (user_mode(regs)) ++ return 0; ++ ++ if (!__this_cpu_read(__in_cortex_a76_erratum_1463225_wa)) ++ return 0; ++ ++ /* ++ * We've taken a dummy step exception from the kernel to ensure ++ * that interrupts are re-enabled on the syscall path. Return back ++ * to cortex_a76_erratum_1463225_svc_handler() with debug exceptions ++ * masked so that we can safely restore the mdscr and get on with ++ * handling the syscall. ++ */ ++ regs->pstate |= PSR_D_BIT; ++ return 1; ++} ++#else ++static int __exception ++cortex_a76_erratum_1463225_debug_handler(struct pt_regs *regs) ++{ ++ return 0; ++} ++#endif /* CONFIG_ARM64_ERRATUM_1463225 */ ++ + asmlinkage int __exception do_debug_exception(unsigned long addr_if_watchpoint, +- unsigned int esr, +- struct pt_regs *regs) ++ unsigned int esr, ++ struct pt_regs *regs) + { + const struct fault_info *inf = debug_fault_info + DBG_ESR_EVT(esr); + unsigned long pc = instruction_pointer(regs); + int rv; + ++ if (cortex_a76_erratum_1463225_debug_handler(regs)) ++ return 0; ++ + /* + * Tell lockdep we disabled irqs in entry.S. Do nothing if they were + * already disabled to preserve the last enabled/disabled addresses. +diff --git a/arch/powerpc/boot/addnote.c b/arch/powerpc/boot/addnote.c +index 9d9f6f334d3c..3da3e2b1b51b 100644 +--- a/arch/powerpc/boot/addnote.c ++++ b/arch/powerpc/boot/addnote.c +@@ -223,7 +223,11 @@ main(int ac, char **av) + PUT_16(E_PHNUM, np + 2); + + /* write back */ +- lseek(fd, (long) 0, SEEK_SET); ++ i = lseek(fd, (long) 0, SEEK_SET); ++ if (i < 0) { ++ perror("lseek"); ++ exit(1); ++ } + i = write(fd, buf, n); + if (i < 0) { + perror("write"); +diff --git a/arch/powerpc/kernel/head_64.S b/arch/powerpc/kernel/head_64.S +index 4898e9491a1c..9168a247e24f 100644 +--- a/arch/powerpc/kernel/head_64.S ++++ b/arch/powerpc/kernel/head_64.S +@@ -970,7 +970,9 @@ start_here_multiplatform: + + /* Restore parameters passed from prom_init/kexec */ + mr r3,r31 +- bl early_setup /* also sets r13 and SPRG_PACA */ ++ LOAD_REG_ADDR(r12, DOTSYM(early_setup)) ++ mtctr r12 ++ bctrl /* also sets r13 and SPRG_PACA */ + + LOAD_REG_ADDR(r3, start_here_common) + ld r4,PACAKMSR(r13) +diff --git a/arch/powerpc/kernel/watchdog.c b/arch/powerpc/kernel/watchdog.c +index 3c6ab22a0c4e..af3c15a1d41e 100644 +--- a/arch/powerpc/kernel/watchdog.c ++++ b/arch/powerpc/kernel/watchdog.c +@@ -77,7 +77,7 @@ static u64 wd_smp_panic_timeout_tb __read_mostly; /* panic other CPUs */ + + static u64 wd_timer_period_ms __read_mostly; /* interval between heartbeat */ + +-static DEFINE_PER_CPU(struct timer_list, wd_timer); ++static DEFINE_PER_CPU(struct hrtimer, wd_hrtimer); + static DEFINE_PER_CPU(u64, wd_timer_tb); + + /* SMP checker bits */ +@@ -293,21 +293,21 @@ out: + nmi_exit(); + } + +-static void wd_timer_reset(unsigned int cpu, struct timer_list *t) +-{ +- t->expires = jiffies + msecs_to_jiffies(wd_timer_period_ms); +- if (wd_timer_period_ms > 1000) +- t->expires = __round_jiffies_up(t->expires, cpu); +- add_timer_on(t, cpu); +-} +- +-static void wd_timer_fn(struct timer_list *t) ++static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer) + { + int cpu = smp_processor_id(); + ++ if (!(watchdog_enabled & NMI_WATCHDOG_ENABLED)) ++ return HRTIMER_NORESTART; ++ ++ if (!cpumask_test_cpu(cpu, &watchdog_cpumask)) ++ return HRTIMER_NORESTART; ++ + watchdog_timer_interrupt(cpu); + +- wd_timer_reset(cpu, t); ++ hrtimer_forward_now(hrtimer, ms_to_ktime(wd_timer_period_ms)); ++ ++ return HRTIMER_RESTART; + } + + void arch_touch_nmi_watchdog(void) +@@ -323,37 +323,22 @@ void arch_touch_nmi_watchdog(void) + } + EXPORT_SYMBOL(arch_touch_nmi_watchdog); + +-static void start_watchdog_timer_on(unsigned int cpu) +-{ +- struct timer_list *t = per_cpu_ptr(&wd_timer, cpu); +- +- per_cpu(wd_timer_tb, cpu) = get_tb(); +- +- timer_setup(t, wd_timer_fn, TIMER_PINNED); +- wd_timer_reset(cpu, t); +-} +- +-static void stop_watchdog_timer_on(unsigned int cpu) +-{ +- struct timer_list *t = per_cpu_ptr(&wd_timer, cpu); +- +- del_timer_sync(t); +-} +- +-static int start_wd_on_cpu(unsigned int cpu) ++static void start_watchdog(void *arg) + { ++ struct hrtimer *hrtimer = this_cpu_ptr(&wd_hrtimer); ++ int cpu = smp_processor_id(); + unsigned long flags; + + if (cpumask_test_cpu(cpu, &wd_cpus_enabled)) { + WARN_ON(1); +- return 0; ++ return; + } + + if (!(watchdog_enabled & NMI_WATCHDOG_ENABLED)) +- return 0; ++ return; + + if (!cpumask_test_cpu(cpu, &watchdog_cpumask)) +- return 0; ++ return; + + wd_smp_lock(&flags); + cpumask_set_cpu(cpu, &wd_cpus_enabled); +@@ -363,27 +348,40 @@ static int start_wd_on_cpu(unsigned int cpu) + } + wd_smp_unlock(&flags); + +- start_watchdog_timer_on(cpu); ++ *this_cpu_ptr(&wd_timer_tb) = get_tb(); + +- return 0; ++ hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); ++ hrtimer->function = watchdog_timer_fn; ++ hrtimer_start(hrtimer, ms_to_ktime(wd_timer_period_ms), ++ HRTIMER_MODE_REL_PINNED); + } + +-static int stop_wd_on_cpu(unsigned int cpu) ++static int start_watchdog_on_cpu(unsigned int cpu) + { ++ return smp_call_function_single(cpu, start_watchdog, NULL, true); ++} ++ ++static void stop_watchdog(void *arg) ++{ ++ struct hrtimer *hrtimer = this_cpu_ptr(&wd_hrtimer); ++ int cpu = smp_processor_id(); + unsigned long flags; + + if (!cpumask_test_cpu(cpu, &wd_cpus_enabled)) +- return 0; /* Can happen in CPU unplug case */ ++ return; /* Can happen in CPU unplug case */ + +- stop_watchdog_timer_on(cpu); ++ hrtimer_cancel(hrtimer); + + wd_smp_lock(&flags); + cpumask_clear_cpu(cpu, &wd_cpus_enabled); + wd_smp_unlock(&flags); + + wd_smp_clear_cpu_pending(cpu, get_tb()); ++} + +- return 0; ++static int stop_watchdog_on_cpu(unsigned int cpu) ++{ ++ return smp_call_function_single(cpu, stop_watchdog, NULL, true); + } + + static void watchdog_calc_timeouts(void) +@@ -402,7 +400,7 @@ void watchdog_nmi_stop(void) + int cpu; + + for_each_cpu(cpu, &wd_cpus_enabled) +- stop_wd_on_cpu(cpu); ++ stop_watchdog_on_cpu(cpu); + } + + void watchdog_nmi_start(void) +@@ -411,7 +409,7 @@ void watchdog_nmi_start(void) + + watchdog_calc_timeouts(); + for_each_cpu_and(cpu, cpu_online_mask, &watchdog_cpumask) +- start_wd_on_cpu(cpu); ++ start_watchdog_on_cpu(cpu); + } + + /* +@@ -423,7 +421,8 @@ int __init watchdog_nmi_probe(void) + + err = cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN, + "powerpc/watchdog:online", +- start_wd_on_cpu, stop_wd_on_cpu); ++ start_watchdog_on_cpu, ++ stop_watchdog_on_cpu); + if (err < 0) { + pr_warn("could not be initialized"); + return err; +diff --git a/arch/powerpc/mm/numa.c b/arch/powerpc/mm/numa.c +index 10fb43efef50..f473c05e9649 100644 +--- a/arch/powerpc/mm/numa.c ++++ b/arch/powerpc/mm/numa.c +@@ -1495,6 +1495,9 @@ int start_topology_update(void) + { + int rc = 0; + ++ if (!topology_updates_enabled) ++ return 0; ++ + if (firmware_has_feature(FW_FEATURE_PRRN)) { + if (!prrn_enabled) { + prrn_enabled = 1; +@@ -1524,6 +1527,9 @@ int stop_topology_update(void) + { + int rc = 0; + ++ if (!topology_updates_enabled) ++ return 0; ++ + if (prrn_enabled) { + prrn_enabled = 0; + #ifdef CONFIG_SMP +@@ -1579,11 +1585,13 @@ static ssize_t topology_write(struct file *file, const char __user *buf, + + kbuf[read_len] = '\0'; + +- if (!strncmp(kbuf, "on", 2)) ++ if (!strncmp(kbuf, "on", 2)) { ++ topology_updates_enabled = true; + start_topology_update(); +- else if (!strncmp(kbuf, "off", 3)) ++ } else if (!strncmp(kbuf, "off", 3)) { + stop_topology_update(); +- else ++ topology_updates_enabled = false; ++ } else + return -EINVAL; + + return count; +@@ -1598,9 +1606,7 @@ static const struct file_operations topology_ops = { + + static int topology_update_init(void) + { +- /* Do not poll for changes if disabled at boot */ +- if (topology_updates_enabled) +- start_topology_update(); ++ start_topology_update(); + + if (vphn_enabled) + topology_schedule_update(); +diff --git a/arch/powerpc/perf/imc-pmu.c b/arch/powerpc/perf/imc-pmu.c +index 1fafc32b12a0..555322677074 100644 +--- a/arch/powerpc/perf/imc-pmu.c ++++ b/arch/powerpc/perf/imc-pmu.c +@@ -496,6 +496,11 @@ static int nest_imc_event_init(struct perf_event *event) + * Get the base memory addresss for this cpu. + */ + chip_id = cpu_to_chip_id(event->cpu); ++ ++ /* Return, if chip_id is not valid */ ++ if (chip_id < 0) ++ return -ENODEV; ++ + pcni = pmu->mem_info; + do { + if (pcni->id == chip_id) { +@@ -503,7 +508,7 @@ static int nest_imc_event_init(struct perf_event *event) + break; + } + pcni++; +- } while (pcni); ++ } while (pcni->vbase != 0); + + if (!flag) + return -ENODEV; +diff --git a/arch/powerpc/platforms/powernv/opal-imc.c b/arch/powerpc/platforms/powernv/opal-imc.c +index 58a07948c76e..3d27f02695e4 100644 +--- a/arch/powerpc/platforms/powernv/opal-imc.c ++++ b/arch/powerpc/platforms/powernv/opal-imc.c +@@ -127,7 +127,7 @@ static int imc_get_mem_addr_nest(struct device_node *node, + nr_chips)) + goto error; + +- pmu_ptr->mem_info = kcalloc(nr_chips, sizeof(*pmu_ptr->mem_info), ++ pmu_ptr->mem_info = kcalloc(nr_chips + 1, sizeof(*pmu_ptr->mem_info), + GFP_KERNEL); + if (!pmu_ptr->mem_info) + goto error; +diff --git a/arch/s390/kernel/kexec_elf.c b/arch/s390/kernel/kexec_elf.c +index 5a286b012043..602e7cc26d11 100644 +--- a/arch/s390/kernel/kexec_elf.c ++++ b/arch/s390/kernel/kexec_elf.c +@@ -19,10 +19,15 @@ static int kexec_file_add_elf_kernel(struct kimage *image, + struct kexec_buf buf; + const Elf_Ehdr *ehdr; + const Elf_Phdr *phdr; ++ Elf_Addr entry; + int i, ret; + + ehdr = (Elf_Ehdr *)kernel; + buf.image = image; ++ if (image->type == KEXEC_TYPE_CRASH) ++ entry = STARTUP_KDUMP_OFFSET; ++ else ++ entry = ehdr->e_entry; + + phdr = (void *)ehdr + ehdr->e_phoff; + for (i = 0; i < ehdr->e_phnum; i++, phdr++) { +@@ -35,7 +40,7 @@ static int kexec_file_add_elf_kernel(struct kimage *image, + buf.mem = ALIGN(phdr->p_paddr, phdr->p_align); + buf.memsz = phdr->p_memsz; + +- if (phdr->p_paddr == 0) { ++ if (entry - phdr->p_paddr < phdr->p_memsz) { + data->kernel_buf = buf.buffer; + data->memsz += STARTUP_NORMAL_OFFSET; + +diff --git a/arch/s390/mm/pgtable.c b/arch/s390/mm/pgtable.c +index f2cc7da473e4..ae894ac83fd6 100644 +--- a/arch/s390/mm/pgtable.c ++++ b/arch/s390/mm/pgtable.c +@@ -410,6 +410,7 @@ static inline pmd_t pmdp_flush_lazy(struct mm_struct *mm, + return old; + } + ++#ifdef CONFIG_PGSTE + static pmd_t *pmd_alloc_map(struct mm_struct *mm, unsigned long addr) + { + pgd_t *pgd; +@@ -427,6 +428,7 @@ static pmd_t *pmd_alloc_map(struct mm_struct *mm, unsigned long addr) + pmd = pmd_alloc(mm, pud, addr); + return pmd; + } ++#endif + + pmd_t pmdp_xchg_direct(struct mm_struct *mm, unsigned long addr, + pmd_t *pmdp, pmd_t new) +diff --git a/arch/sh/include/cpu-sh4/cpu/sh7786.h b/arch/sh/include/cpu-sh4/cpu/sh7786.h +index 96b8cb1f754a..029bbadaf7ab 100644 +--- a/arch/sh/include/cpu-sh4/cpu/sh7786.h ++++ b/arch/sh/include/cpu-sh4/cpu/sh7786.h +@@ -135,7 +135,7 @@ enum { + + static inline u32 sh7786_mm_sel(void) + { +- return __raw_readl(0xFC400020) & 0x7; ++ return __raw_readl((const volatile void __iomem *)0xFC400020) & 0x7; + } + + #endif /* __CPU_SH7786_H__ */ +diff --git a/arch/x86/Makefile b/arch/x86/Makefile +index ffc823a8312f..ab2071e40efe 100644 +--- a/arch/x86/Makefile ++++ b/arch/x86/Makefile +@@ -47,7 +47,7 @@ export REALMODE_CFLAGS + export BITS + + ifdef CONFIG_X86_NEED_RELOCS +- LDFLAGS_vmlinux := --emit-relocs ++ LDFLAGS_vmlinux := --emit-relocs --discard-none + endif + + # +diff --git a/arch/x86/events/intel/cstate.c b/arch/x86/events/intel/cstate.c +index 56194c571299..4a650eb3d94a 100644 +--- a/arch/x86/events/intel/cstate.c ++++ b/arch/x86/events/intel/cstate.c +@@ -584,6 +584,8 @@ static const struct x86_cpu_id intel_cstates_match[] __initconst = { + X86_CSTATES_MODEL(INTEL_FAM6_ATOM_GOLDMONT_X, glm_cstates), + + X86_CSTATES_MODEL(INTEL_FAM6_ATOM_GOLDMONT_PLUS, glm_cstates), ++ ++ X86_CSTATES_MODEL(INTEL_FAM6_ICELAKE_MOBILE, snb_cstates), + { }, + }; + MODULE_DEVICE_TABLE(x86cpu, intel_cstates_match); +diff --git a/arch/x86/events/intel/rapl.c b/arch/x86/events/intel/rapl.c +index 91039ffed633..2413169ce362 100644 +--- a/arch/x86/events/intel/rapl.c ++++ b/arch/x86/events/intel/rapl.c +@@ -780,6 +780,8 @@ static const struct x86_cpu_id rapl_cpu_match[] __initconst = { + X86_RAPL_MODEL_MATCH(INTEL_FAM6_ATOM_GOLDMONT_X, hsw_rapl_init), + + X86_RAPL_MODEL_MATCH(INTEL_FAM6_ATOM_GOLDMONT_PLUS, hsw_rapl_init), ++ ++ X86_RAPL_MODEL_MATCH(INTEL_FAM6_ICELAKE_MOBILE, skl_rapl_init), + {}, + }; + +diff --git a/arch/x86/events/msr.c b/arch/x86/events/msr.c +index 1b9f85abf9bc..ace6c1e752fb 100644 +--- a/arch/x86/events/msr.c ++++ b/arch/x86/events/msr.c +@@ -89,6 +89,7 @@ static bool test_intel(int idx) + case INTEL_FAM6_SKYLAKE_X: + case INTEL_FAM6_KABYLAKE_MOBILE: + case INTEL_FAM6_KABYLAKE_DESKTOP: ++ case INTEL_FAM6_ICELAKE_MOBILE: + if (idx == PERF_MSR_SMI || idx == PERF_MSR_PPERF) + return true; + break; +diff --git a/arch/x86/ia32/ia32_signal.c b/arch/x86/ia32/ia32_signal.c +index 86b1341cba9a..513ba49c204f 100644 +--- a/arch/x86/ia32/ia32_signal.c ++++ b/arch/x86/ia32/ia32_signal.c +@@ -61,9 +61,8 @@ + } while (0) + + #define RELOAD_SEG(seg) { \ +- unsigned int pre = GET_SEG(seg); \ ++ unsigned int pre = (seg) | 3; \ + unsigned int cur = get_user_seg(seg); \ +- pre |= 3; \ + if (pre != cur) \ + set_user_seg(seg, pre); \ + } +@@ -72,6 +71,7 @@ static int ia32_restore_sigcontext(struct pt_regs *regs, + struct sigcontext_32 __user *sc) + { + unsigned int tmpflags, err = 0; ++ u16 gs, fs, es, ds; + void __user *buf; + u32 tmp; + +@@ -79,16 +79,10 @@ static int ia32_restore_sigcontext(struct pt_regs *regs, + current->restart_block.fn = do_no_restart_syscall; + + get_user_try { +- /* +- * Reload fs and gs if they have changed in the signal +- * handler. This does not handle long fs/gs base changes in +- * the handler, but does not clobber them at least in the +- * normal case. +- */ +- RELOAD_SEG(gs); +- RELOAD_SEG(fs); +- RELOAD_SEG(ds); +- RELOAD_SEG(es); ++ gs = GET_SEG(gs); ++ fs = GET_SEG(fs); ++ ds = GET_SEG(ds); ++ es = GET_SEG(es); + + COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx); + COPY(dx); COPY(cx); COPY(ip); COPY(ax); +@@ -106,6 +100,17 @@ static int ia32_restore_sigcontext(struct pt_regs *regs, + buf = compat_ptr(tmp); + } get_user_catch(err); + ++ /* ++ * Reload fs and gs if they have changed in the signal ++ * handler. This does not handle long fs/gs base changes in ++ * the handler, but does not clobber them at least in the ++ * normal case. ++ */ ++ RELOAD_SEG(gs); ++ RELOAD_SEG(fs); ++ RELOAD_SEG(ds); ++ RELOAD_SEG(es); ++ + err |= fpu__restore_sig(buf, 1); + + force_iret(); +diff --git a/arch/x86/include/asm/text-patching.h b/arch/x86/include/asm/text-patching.h +index 05861cc08787..0bbb07eaed6b 100644 +--- a/arch/x86/include/asm/text-patching.h ++++ b/arch/x86/include/asm/text-patching.h +@@ -39,6 +39,7 @@ extern int poke_int3_handler(struct pt_regs *regs); + extern void *text_poke_bp(void *addr, const void *opcode, size_t len, void *handler); + extern int after_bootmem; + ++#ifndef CONFIG_UML_X86 + static inline void int3_emulate_jmp(struct pt_regs *regs, unsigned long ip) + { + regs->ip = ip; +@@ -65,6 +66,7 @@ static inline void int3_emulate_call(struct pt_regs *regs, unsigned long func) + int3_emulate_push(regs, regs->ip - INT3_INSN_SIZE + CALL_INSN_SIZE); + int3_emulate_jmp(regs, func); + } +-#endif ++#endif /* CONFIG_X86_64 */ ++#endif /* !CONFIG_UML_X86 */ + + #endif /* _ASM_X86_TEXT_PATCHING_H */ +diff --git a/arch/x86/kernel/alternative.c b/arch/x86/kernel/alternative.c +index b9d5e7c9ef43..918a23704c0c 100644 +--- a/arch/x86/kernel/alternative.c ++++ b/arch/x86/kernel/alternative.c +@@ -662,15 +662,29 @@ void __init alternative_instructions(void) + * handlers seeing an inconsistent instruction while you patch. + */ + void *__init_or_module text_poke_early(void *addr, const void *opcode, +- size_t len) ++ size_t len) + { + unsigned long flags; +- local_irq_save(flags); +- memcpy(addr, opcode, len); +- local_irq_restore(flags); +- sync_core(); +- /* Could also do a CLFLUSH here to speed up CPU recovery; but +- that causes hangs on some VIA CPUs. */ ++ ++ if (boot_cpu_has(X86_FEATURE_NX) && ++ is_module_text_address((unsigned long)addr)) { ++ /* ++ * Modules text is marked initially as non-executable, so the ++ * code cannot be running and speculative code-fetches are ++ * prevented. Just change the code. ++ */ ++ memcpy(addr, opcode, len); ++ } else { ++ local_irq_save(flags); ++ memcpy(addr, opcode, len); ++ local_irq_restore(flags); ++ sync_core(); ++ ++ /* ++ * Could also do a CLFLUSH here to speed up CPU recovery; but ++ * that causes hangs on some VIA CPUs. ++ */ ++ } + return addr; + } + +diff --git a/arch/x86/kernel/cpu/mcheck/mce-inject.c b/arch/x86/kernel/cpu/mcheck/mce-inject.c +index c805a06e14c3..ff1c00b695ae 100644 +--- a/arch/x86/kernel/cpu/mcheck/mce-inject.c ++++ b/arch/x86/kernel/cpu/mcheck/mce-inject.c +@@ -46,8 +46,6 @@ + static struct mce i_mce; + static struct dentry *dfs_inj; + +-static u8 n_banks; +- + #define MAX_FLAG_OPT_SIZE 4 + #define NBCFG 0x44 + +@@ -567,9 +565,15 @@ err: + static int inj_bank_set(void *data, u64 val) + { + struct mce *m = (struct mce *)data; ++ u8 n_banks; ++ u64 cap; ++ ++ /* Get bank count on target CPU so we can handle non-uniform values. */ ++ rdmsrl_on_cpu(m->extcpu, MSR_IA32_MCG_CAP, &cap); ++ n_banks = cap & MCG_BANKCNT_MASK; + + if (val >= n_banks) { +- pr_err("Non-existent MCE bank: %llu\n", val); ++ pr_err("MCA bank %llu non-existent on CPU%d\n", val, m->extcpu); + return -EINVAL; + } + +@@ -659,10 +663,6 @@ static struct dfs_node { + static int __init debugfs_init(void) + { + unsigned int i; +- u64 cap; +- +- rdmsrl(MSR_IA32_MCG_CAP, cap); +- n_banks = cap & MCG_BANKCNT_MASK; + + dfs_inj = debugfs_create_dir("mce-inject", NULL); + if (!dfs_inj) +diff --git a/arch/x86/kernel/cpu/mcheck/mce.c b/arch/x86/kernel/cpu/mcheck/mce.c +index f9e7096b1804..fee118b3b69f 100644 +--- a/arch/x86/kernel/cpu/mcheck/mce.c ++++ b/arch/x86/kernel/cpu/mcheck/mce.c +@@ -711,19 +711,49 @@ bool machine_check_poll(enum mcp_flags flags, mce_banks_t *b) + + barrier(); + m.status = mce_rdmsrl(msr_ops.status(i)); ++ ++ /* If this entry is not valid, ignore it */ + if (!(m.status & MCI_STATUS_VAL)) + continue; + + /* +- * Uncorrected or signalled events are handled by the exception +- * handler when it is enabled, so don't process those here. +- * +- * TBD do the same check for MCI_STATUS_EN here? ++ * If we are logging everything (at CPU online) or this ++ * is a corrected error, then we must log it. + */ +- if (!(flags & MCP_UC) && +- (m.status & (mca_cfg.ser ? MCI_STATUS_S : MCI_STATUS_UC))) +- continue; ++ if ((flags & MCP_UC) || !(m.status & MCI_STATUS_UC)) ++ goto log_it; ++ ++ /* ++ * Newer Intel systems that support software error ++ * recovery need to make additional checks. Other ++ * CPUs should skip over uncorrected errors, but log ++ * everything else. ++ */ ++ if (!mca_cfg.ser) { ++ if (m.status & MCI_STATUS_UC) ++ continue; ++ goto log_it; ++ } ++ ++ /* Log "not enabled" (speculative) errors */ ++ if (!(m.status & MCI_STATUS_EN)) ++ goto log_it; ++ ++ /* ++ * Log UCNA (SDM: 15.6.3 "UCR Error Classification") ++ * UC == 1 && PCC == 0 && S == 0 ++ */ ++ if (!(m.status & MCI_STATUS_PCC) && !(m.status & MCI_STATUS_S)) ++ goto log_it; ++ ++ /* ++ * Skip anything else. Presumption is that our read of this ++ * bank is racing with a machine check. Leave the log alone ++ * for do_machine_check() to deal with it. ++ */ ++ continue; + ++log_it: + error_seen = true; + + mce_read_aux(&m, i); +@@ -1450,13 +1480,12 @@ EXPORT_SYMBOL_GPL(mce_notify_irq); + static int __mcheck_cpu_mce_banks_init(void) + { + int i; +- u8 num_banks = mca_cfg.banks; + +- mce_banks = kcalloc(num_banks, sizeof(struct mce_bank), GFP_KERNEL); ++ mce_banks = kcalloc(MAX_NR_BANKS, sizeof(struct mce_bank), GFP_KERNEL); + if (!mce_banks) + return -ENOMEM; + +- for (i = 0; i < num_banks; i++) { ++ for (i = 0; i < MAX_NR_BANKS; i++) { + struct mce_bank *b = &mce_banks[i]; + + b->ctl = -1ULL; +@@ -1470,28 +1499,19 @@ static int __mcheck_cpu_mce_banks_init(void) + */ + static int __mcheck_cpu_cap_init(void) + { +- unsigned b; + u64 cap; ++ u8 b; + + rdmsrl(MSR_IA32_MCG_CAP, cap); + + b = cap & MCG_BANKCNT_MASK; +- if (!mca_cfg.banks) +- pr_info("CPU supports %d MCE banks\n", b); +- +- if (b > MAX_NR_BANKS) { +- pr_warn("Using only %u machine check banks out of %u\n", +- MAX_NR_BANKS, b); ++ if (WARN_ON_ONCE(b > MAX_NR_BANKS)) + b = MAX_NR_BANKS; +- } + +- /* Don't support asymmetric configurations today */ +- WARN_ON(mca_cfg.banks != 0 && b != mca_cfg.banks); +- mca_cfg.banks = b; ++ mca_cfg.banks = max(mca_cfg.banks, b); + + if (!mce_banks) { + int err = __mcheck_cpu_mce_banks_init(); +- + if (err) + return err; + } +@@ -2473,6 +2493,8 @@ EXPORT_SYMBOL_GPL(mcsafe_key); + + static int __init mcheck_late_init(void) + { ++ pr_info("Using %d MCE banks\n", mca_cfg.banks); ++ + if (mca_cfg.recovery) + static_branch_inc(&mcsafe_key); + +diff --git a/arch/x86/kernel/cpu/microcode/core.c b/arch/x86/kernel/cpu/microcode/core.c +index b9bc8a1a584e..b43ddefd77f4 100644 +--- a/arch/x86/kernel/cpu/microcode/core.c ++++ b/arch/x86/kernel/cpu/microcode/core.c +@@ -418,8 +418,9 @@ static int do_microcode_update(const void __user *buf, size_t size) + if (ustate == UCODE_ERROR) { + error = -1; + break; +- } else if (ustate == UCODE_OK) ++ } else if (ustate == UCODE_NEW) { + apply_microcode_on_target(cpu); ++ } + } + + return error; +diff --git a/arch/x86/kernel/irq_64.c b/arch/x86/kernel/irq_64.c +index 0469cd078db1..b50ac9c7397b 100644 +--- a/arch/x86/kernel/irq_64.c ++++ b/arch/x86/kernel/irq_64.c +@@ -26,9 +26,18 @@ int sysctl_panic_on_stackoverflow; + /* + * Probabilistic stack overflow check: + * +- * Only check the stack in process context, because everything else +- * runs on the big interrupt stacks. Checking reliably is too expensive, +- * so we just check from interrupts. ++ * Regular device interrupts can enter on the following stacks: ++ * ++ * - User stack ++ * ++ * - Kernel task stack ++ * ++ * - Interrupt stack if a device driver reenables interrupts ++ * which should only happen in really old drivers. ++ * ++ * - Debug IST stack ++ * ++ * All other contexts are invalid. + */ + static inline void stack_overflow_check(struct pt_regs *regs) + { +@@ -53,8 +62,8 @@ static inline void stack_overflow_check(struct pt_regs *regs) + return; + + oist = this_cpu_ptr(&orig_ist); +- estack_top = (u64)oist->ist[0] - EXCEPTION_STKSZ + STACK_TOP_MARGIN; +- estack_bottom = (u64)oist->ist[N_EXCEPTION_STACKS - 1]; ++ estack_bottom = (u64)oist->ist[DEBUG_STACK]; ++ estack_top = estack_bottom - DEBUG_STKSZ + STACK_TOP_MARGIN; + if (regs->sp >= estack_top && regs->sp <= estack_bottom) + return; + +diff --git a/arch/x86/kernel/module.c b/arch/x86/kernel/module.c +index f58336af095c..6645f123419c 100644 +--- a/arch/x86/kernel/module.c ++++ b/arch/x86/kernel/module.c +@@ -87,7 +87,7 @@ void *module_alloc(unsigned long size) + p = __vmalloc_node_range(size, MODULE_ALIGN, + MODULES_VADDR + get_module_load_offset(), + MODULES_END, GFP_KERNEL, +- PAGE_KERNEL_EXEC, 0, NUMA_NO_NODE, ++ PAGE_KERNEL, 0, NUMA_NO_NODE, + __builtin_return_address(0)); + if (p && (kasan_module_alloc(p, size) < 0)) { + vfree(p); +diff --git a/arch/x86/kernel/signal.c b/arch/x86/kernel/signal.c +index 92a3b312a53c..44e647a65de8 100644 +--- a/arch/x86/kernel/signal.c ++++ b/arch/x86/kernel/signal.c +@@ -132,16 +132,6 @@ static int restore_sigcontext(struct pt_regs *regs, + COPY_SEG_CPL3(cs); + COPY_SEG_CPL3(ss); + +-#ifdef CONFIG_X86_64 +- /* +- * Fix up SS if needed for the benefit of old DOSEMU and +- * CRIU. +- */ +- if (unlikely(!(uc_flags & UC_STRICT_RESTORE_SS) && +- user_64bit_mode(regs))) +- force_valid_ss(regs); +-#endif +- + get_user_ex(tmpflags, &sc->flags); + regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS); + regs->orig_ax = -1; /* disable syscall checks */ +@@ -150,6 +140,15 @@ static int restore_sigcontext(struct pt_regs *regs, + buf = (void __user *)buf_val; + } get_user_catch(err); + ++#ifdef CONFIG_X86_64 ++ /* ++ * Fix up SS if needed for the benefit of old DOSEMU and ++ * CRIU. ++ */ ++ if (unlikely(!(uc_flags & UC_STRICT_RESTORE_SS) && user_64bit_mode(regs))) ++ force_valid_ss(regs); ++#endif ++ + err |= fpu__restore_sig(buf, IS_ENABLED(CONFIG_X86_32)); + + force_iret(); +@@ -461,6 +460,7 @@ static int __setup_rt_frame(int sig, struct ksignal *ksig, + { + struct rt_sigframe __user *frame; + void __user *fp = NULL; ++ unsigned long uc_flags; + int err = 0; + + frame = get_sigframe(&ksig->ka, regs, sizeof(struct rt_sigframe), &fp); +@@ -473,9 +473,11 @@ static int __setup_rt_frame(int sig, struct ksignal *ksig, + return -EFAULT; + } + ++ uc_flags = frame_uc_flags(regs); ++ + put_user_try { + /* Create the ucontext. */ +- put_user_ex(frame_uc_flags(regs), &frame->uc.uc_flags); ++ put_user_ex(uc_flags, &frame->uc.uc_flags); + put_user_ex(0, &frame->uc.uc_link); + save_altstack_ex(&frame->uc.uc_stack, regs->sp); + +@@ -541,6 +543,7 @@ static int x32_setup_rt_frame(struct ksignal *ksig, + { + #ifdef CONFIG_X86_X32_ABI + struct rt_sigframe_x32 __user *frame; ++ unsigned long uc_flags; + void __user *restorer; + int err = 0; + void __user *fpstate = NULL; +@@ -555,9 +558,11 @@ static int x32_setup_rt_frame(struct ksignal *ksig, + return -EFAULT; + } + ++ uc_flags = frame_uc_flags(regs); ++ + put_user_try { + /* Create the ucontext. */ +- put_user_ex(frame_uc_flags(regs), &frame->uc.uc_flags); ++ put_user_ex(uc_flags, &frame->uc.uc_flags); + put_user_ex(0, &frame->uc.uc_link); + compat_save_altstack_ex(&frame->uc.uc_stack, regs->sp); + put_user_ex(0, &frame->uc.uc__pad0); +diff --git a/arch/x86/kernel/vmlinux.lds.S b/arch/x86/kernel/vmlinux.lds.S +index 85e6d5620188..2fb152d813c1 100644 +--- a/arch/x86/kernel/vmlinux.lds.S ++++ b/arch/x86/kernel/vmlinux.lds.S +@@ -151,11 +151,11 @@ SECTIONS + *(.text.__x86.indirect_thunk) + __indirect_thunk_end = .; + #endif +- +- /* End of text section */ +- _etext = .; + } :text = 0x9090 + ++ /* End of text section */ ++ _etext = .; ++ + NOTES :text :note + + EXCEPTION_TABLE(16) :text = 0x9090 +diff --git a/arch/x86/kvm/svm.c b/arch/x86/kvm/svm.c +index 8dd9208ae4de..ea454d3f7763 100644 +--- a/arch/x86/kvm/svm.c ++++ b/arch/x86/kvm/svm.c +@@ -2022,7 +2022,11 @@ static void avic_vcpu_load(struct kvm_vcpu *vcpu, int cpu) + if (!kvm_vcpu_apicv_active(vcpu)) + return; + +- if (WARN_ON(h_physical_id >= AVIC_MAX_PHYSICAL_ID_COUNT)) ++ /* ++ * Since the host physical APIC id is 8 bits, ++ * we can support host APIC ID upto 255. ++ */ ++ if (WARN_ON(h_physical_id > AVIC_PHYSICAL_ID_ENTRY_HOST_PHYSICAL_ID_MASK)) + return; + + entry = READ_ONCE(*(svm->avic_physical_id_cache)); +diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c +index d0eb37c069b8..be4ba0975a0f 100644 +--- a/arch/x86/kvm/x86.c ++++ b/arch/x86/kvm/x86.c +@@ -1188,7 +1188,7 @@ static int set_efer(struct kvm_vcpu *vcpu, struct msr_data *msr_info) + u64 efer = msr_info->data; + + if (efer & efer_reserved_bits) +- return false; ++ return 1; + + if (!msr_info->host_initiated) { + if (!__kvm_valid_efer(vcpu, efer)) +diff --git a/arch/x86/lib/memcpy_64.S b/arch/x86/lib/memcpy_64.S +index 3b24dc05251c..9d05572370ed 100644 +--- a/arch/x86/lib/memcpy_64.S ++++ b/arch/x86/lib/memcpy_64.S +@@ -257,6 +257,7 @@ ENTRY(__memcpy_mcsafe) + /* Copy successful. Return zero */ + .L_done_memcpy_trap: + xorl %eax, %eax ++.L_done: + ret + ENDPROC(__memcpy_mcsafe) + EXPORT_SYMBOL_GPL(__memcpy_mcsafe) +@@ -273,7 +274,7 @@ EXPORT_SYMBOL_GPL(__memcpy_mcsafe) + addl %edx, %ecx + .E_trailing_bytes: + mov %ecx, %eax +- ret ++ jmp .L_done + + /* + * For write fault handling, given the destination is unaligned, +diff --git a/arch/x86/mm/fault.c b/arch/x86/mm/fault.c +index 47bebfe6efa7..9d9765e4d1ef 100644 +--- a/arch/x86/mm/fault.c ++++ b/arch/x86/mm/fault.c +@@ -427,8 +427,6 @@ static noinline int vmalloc_fault(unsigned long address) + if (!(address >= VMALLOC_START && address < VMALLOC_END)) + return -1; + +- WARN_ON_ONCE(in_nmi()); +- + /* + * Copy kernel mappings over when needed. This can also + * happen within a race in page table update. In the later +diff --git a/block/genhd.c b/block/genhd.c +index be5bab20b2ab..2b2a936cf848 100644 +--- a/block/genhd.c ++++ b/block/genhd.c +@@ -518,6 +518,18 @@ void blk_free_devt(dev_t devt) + } + } + ++/** ++ * We invalidate devt by assigning NULL pointer for devt in idr. ++ */ ++void blk_invalidate_devt(dev_t devt) ++{ ++ if (MAJOR(devt) == BLOCK_EXT_MAJOR) { ++ spin_lock_bh(&ext_devt_lock); ++ idr_replace(&ext_devt_idr, NULL, blk_mangle_minor(MINOR(devt))); ++ spin_unlock_bh(&ext_devt_lock); ++ } ++} ++ + static char *bdevt_str(dev_t devt, char *buf) + { + if (MAJOR(devt) <= 0xff && MINOR(devt) <= 0xff) { +@@ -769,6 +781,13 @@ void del_gendisk(struct gendisk *disk) + + if (!(disk->flags & GENHD_FL_HIDDEN)) + blk_unregister_region(disk_devt(disk), disk->minors); ++ /* ++ * Remove gendisk pointer from idr so that it cannot be looked up ++ * while RCU period before freeing gendisk is running to prevent ++ * use-after-free issues. Note that the device number stays ++ * "in-use" until we really free the gendisk. ++ */ ++ blk_invalidate_devt(disk_devt(disk)); + + kobject_put(disk->part0.holder_dir); + kobject_put(disk->slave_dir); +diff --git a/block/partition-generic.c b/block/partition-generic.c +index 5f8db5c5140f..98d60a59b843 100644 +--- a/block/partition-generic.c ++++ b/block/partition-generic.c +@@ -289,6 +289,13 @@ void delete_partition(struct gendisk *disk, int partno) + kobject_put(part->holder_dir); + device_del(part_to_dev(part)); + ++ /* ++ * Remove gendisk pointer from idr so that it cannot be looked up ++ * while RCU period before freeing gendisk is running to prevent ++ * use-after-free issues. Note that the device number stays ++ * "in-use" until we really free the gendisk. ++ */ ++ blk_invalidate_devt(part_devt(part)); + hd_struct_kill(part); + } + +diff --git a/block/sed-opal.c b/block/sed-opal.c +index e0de4dd448b3..119640897293 100644 +--- a/block/sed-opal.c ++++ b/block/sed-opal.c +@@ -2095,13 +2095,16 @@ static int opal_erase_locking_range(struct opal_dev *dev, + static int opal_enable_disable_shadow_mbr(struct opal_dev *dev, + struct opal_mbr_data *opal_mbr) + { ++ u8 enable_disable = opal_mbr->enable_disable == OPAL_MBR_ENABLE ? ++ OPAL_TRUE : OPAL_FALSE; ++ + const struct opal_step mbr_steps[] = { + { opal_discovery0, }, + { start_admin1LSP_opal_session, &opal_mbr->key }, +- { set_mbr_done, &opal_mbr->enable_disable }, ++ { set_mbr_done, &enable_disable }, + { end_opal_session, }, + { start_admin1LSP_opal_session, &opal_mbr->key }, +- { set_mbr_enable_disable, &opal_mbr->enable_disable }, ++ { set_mbr_enable_disable, &enable_disable }, + { end_opal_session, }, + { NULL, } + }; +@@ -2221,7 +2224,7 @@ static int __opal_lock_unlock(struct opal_dev *dev, + + static int __opal_set_mbr_done(struct opal_dev *dev, struct opal_key *key) + { +- u8 mbr_done_tf = 1; ++ u8 mbr_done_tf = OPAL_TRUE; + const struct opal_step mbrdone_step [] = { + { opal_discovery0, }, + { start_admin1LSP_opal_session, key }, +diff --git a/drivers/acpi/arm64/iort.c b/drivers/acpi/arm64/iort.c +index e48eebc27b81..43c2615434b4 100644 +--- a/drivers/acpi/arm64/iort.c ++++ b/drivers/acpi/arm64/iort.c +@@ -1231,18 +1231,24 @@ static bool __init arm_smmu_v3_is_coherent(struct acpi_iort_node *node) + /* + * set numa proximity domain for smmuv3 device + */ +-static void __init arm_smmu_v3_set_proximity(struct device *dev, ++static int __init arm_smmu_v3_set_proximity(struct device *dev, + struct acpi_iort_node *node) + { + struct acpi_iort_smmu_v3 *smmu; + + smmu = (struct acpi_iort_smmu_v3 *)node->node_data; + if (smmu->flags & ACPI_IORT_SMMU_V3_PXM_VALID) { +- set_dev_node(dev, acpi_map_pxm_to_node(smmu->pxm)); ++ int node = acpi_map_pxm_to_node(smmu->pxm); ++ ++ if (node != NUMA_NO_NODE && !node_online(node)) ++ return -EINVAL; ++ ++ set_dev_node(dev, node); + pr_info("SMMU-v3[%llx] Mapped to Proximity domain %d\n", + smmu->base_address, + smmu->pxm); + } ++ return 0; + } + #else + #define arm_smmu_v3_set_proximity NULL +@@ -1317,7 +1323,7 @@ struct iort_dev_config { + int (*dev_count_resources)(struct acpi_iort_node *node); + void (*dev_init_resources)(struct resource *res, + struct acpi_iort_node *node); +- void (*dev_set_proximity)(struct device *dev, ++ int (*dev_set_proximity)(struct device *dev, + struct acpi_iort_node *node); + }; + +@@ -1368,8 +1374,11 @@ static int __init iort_add_platform_device(struct acpi_iort_node *node, + if (!pdev) + return -ENOMEM; + +- if (ops->dev_set_proximity) +- ops->dev_set_proximity(&pdev->dev, node); ++ if (ops->dev_set_proximity) { ++ ret = ops->dev_set_proximity(&pdev->dev, node); ++ if (ret) ++ goto dev_put; ++ } + + count = ops->dev_count_resources(node); + +diff --git a/drivers/acpi/property.c b/drivers/acpi/property.c +index 693cf05b0cc4..288673cff85e 100644 +--- a/drivers/acpi/property.c ++++ b/drivers/acpi/property.c +@@ -975,6 +975,14 @@ struct fwnode_handle *acpi_get_next_subnode(const struct fwnode_handle *fwnode, + const struct acpi_data_node *data = to_acpi_data_node(fwnode); + struct acpi_data_node *dn; + ++ /* ++ * We can have a combination of device and data nodes, e.g. with ++ * hierarchical _DSD properties. Make sure the adev pointer is ++ * restored before going through data nodes, otherwise we will ++ * be looking for data_nodes below the last device found instead ++ * of the common fwnode shared by device_nodes and data_nodes. ++ */ ++ adev = to_acpi_device_node(fwnode); + if (adev) + head = &adev->data.subnodes; + else if (data) +diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c +index a690fd400260..4abd7c6531d9 100644 +--- a/drivers/base/power/main.c ++++ b/drivers/base/power/main.c +@@ -1736,6 +1736,10 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async) + if (dev->power.syscore) + goto Complete; + ++ /* Avoid direct_complete to let wakeup_path propagate. */ ++ if (device_may_wakeup(dev) || dev->power.wakeup_path) ++ dev->power.direct_complete = false; ++ + if (dev->power.direct_complete) { + if (pm_runtime_status_suspended(dev)) { + pm_runtime_disable(dev); +diff --git a/drivers/bluetooth/hci_qca.c b/drivers/bluetooth/hci_qca.c +index f0d593c3fa72..77004c29da08 100644 +--- a/drivers/bluetooth/hci_qca.c ++++ b/drivers/bluetooth/hci_qca.c +@@ -504,6 +504,8 @@ static int qca_open(struct hci_uart *hu) + qcadev = serdev_device_get_drvdata(hu->serdev); + if (qcadev->btsoc_type != QCA_WCN3990) { + gpiod_set_value_cansleep(qcadev->bt_en, 1); ++ /* Controller needs time to bootup. */ ++ msleep(150); + } else { + hu->init_speed = qcadev->init_speed; + hu->oper_speed = qcadev->oper_speed; +diff --git a/drivers/char/hw_random/omap-rng.c b/drivers/char/hw_random/omap-rng.c +index b65ff6962899..e9b6ac61fb7f 100644 +--- a/drivers/char/hw_random/omap-rng.c ++++ b/drivers/char/hw_random/omap-rng.c +@@ -443,6 +443,7 @@ static int omap_rng_probe(struct platform_device *pdev) + priv->rng.read = omap_rng_do_read; + priv->rng.init = omap_rng_init; + priv->rng.cleanup = omap_rng_cleanup; ++ priv->rng.quality = 900; + + priv->rng.priv = (unsigned long)priv; + platform_set_drvdata(pdev, priv); +diff --git a/drivers/char/random.c b/drivers/char/random.c +index c75b6cdf0053..0a84b7f468ad 100644 +--- a/drivers/char/random.c ++++ b/drivers/char/random.c +@@ -778,6 +778,7 @@ static struct crng_state **crng_node_pool __read_mostly; + #endif + + static void invalidate_batched_entropy(void); ++static void numa_crng_init(void); + + static bool trust_cpu __ro_after_init = IS_ENABLED(CONFIG_RANDOM_TRUST_CPU); + static int __init parse_trust_cpu(char *arg) +@@ -806,7 +807,9 @@ static void crng_initialize(struct crng_state *crng) + } + crng->state[i] ^= rv; + } +- if (trust_cpu && arch_init) { ++ if (trust_cpu && arch_init && crng == &primary_crng) { ++ invalidate_batched_entropy(); ++ numa_crng_init(); + crng_init = 2; + pr_notice("random: crng done (trusting CPU's manufacturer)\n"); + } +@@ -2212,8 +2215,8 @@ struct batched_entropy { + u32 entropy_u32[CHACHA20_BLOCK_SIZE / sizeof(u32)]; + }; + unsigned int position; ++ spinlock_t batch_lock; + }; +-static rwlock_t batched_entropy_reset_lock = __RW_LOCK_UNLOCKED(batched_entropy_reset_lock); + + /* + * Get a random word for internal kernel use only. The quality of the random +@@ -2223,12 +2226,14 @@ static rwlock_t batched_entropy_reset_lock = __RW_LOCK_UNLOCKED(batched_entropy_ + * wait_for_random_bytes() should be called and return 0 at least once + * at any point prior. + */ +-static DEFINE_PER_CPU(struct batched_entropy, batched_entropy_u64); ++static DEFINE_PER_CPU(struct batched_entropy, batched_entropy_u64) = { ++ .batch_lock = __SPIN_LOCK_UNLOCKED(batched_entropy_u64.lock), ++}; ++ + u64 get_random_u64(void) + { + u64 ret; +- bool use_lock; +- unsigned long flags = 0; ++ unsigned long flags; + struct batched_entropy *batch; + static void *previous; + +@@ -2243,28 +2248,25 @@ u64 get_random_u64(void) + + warn_unseeded_randomness(&previous); + +- use_lock = READ_ONCE(crng_init) < 2; +- batch = &get_cpu_var(batched_entropy_u64); +- if (use_lock) +- read_lock_irqsave(&batched_entropy_reset_lock, flags); ++ batch = raw_cpu_ptr(&batched_entropy_u64); ++ spin_lock_irqsave(&batch->batch_lock, flags); + if (batch->position % ARRAY_SIZE(batch->entropy_u64) == 0) { + extract_crng((__u32 *)batch->entropy_u64); + batch->position = 0; + } + ret = batch->entropy_u64[batch->position++]; +- if (use_lock) +- read_unlock_irqrestore(&batched_entropy_reset_lock, flags); +- put_cpu_var(batched_entropy_u64); ++ spin_unlock_irqrestore(&batch->batch_lock, flags); + return ret; + } + EXPORT_SYMBOL(get_random_u64); + +-static DEFINE_PER_CPU(struct batched_entropy, batched_entropy_u32); ++static DEFINE_PER_CPU(struct batched_entropy, batched_entropy_u32) = { ++ .batch_lock = __SPIN_LOCK_UNLOCKED(batched_entropy_u32.lock), ++}; + u32 get_random_u32(void) + { + u32 ret; +- bool use_lock; +- unsigned long flags = 0; ++ unsigned long flags; + struct batched_entropy *batch; + static void *previous; + +@@ -2273,18 +2275,14 @@ u32 get_random_u32(void) + + warn_unseeded_randomness(&previous); + +- use_lock = READ_ONCE(crng_init) < 2; +- batch = &get_cpu_var(batched_entropy_u32); +- if (use_lock) +- read_lock_irqsave(&batched_entropy_reset_lock, flags); ++ batch = raw_cpu_ptr(&batched_entropy_u32); ++ spin_lock_irqsave(&batch->batch_lock, flags); + if (batch->position % ARRAY_SIZE(batch->entropy_u32) == 0) { + extract_crng(batch->entropy_u32); + batch->position = 0; + } + ret = batch->entropy_u32[batch->position++]; +- if (use_lock) +- read_unlock_irqrestore(&batched_entropy_reset_lock, flags); +- put_cpu_var(batched_entropy_u32); ++ spin_unlock_irqrestore(&batch->batch_lock, flags); + return ret; + } + EXPORT_SYMBOL(get_random_u32); +@@ -2298,12 +2296,19 @@ static void invalidate_batched_entropy(void) + int cpu; + unsigned long flags; + +- write_lock_irqsave(&batched_entropy_reset_lock, flags); + for_each_possible_cpu (cpu) { +- per_cpu_ptr(&batched_entropy_u32, cpu)->position = 0; +- per_cpu_ptr(&batched_entropy_u64, cpu)->position = 0; ++ struct batched_entropy *batched_entropy; ++ ++ batched_entropy = per_cpu_ptr(&batched_entropy_u32, cpu); ++ spin_lock_irqsave(&batched_entropy->batch_lock, flags); ++ batched_entropy->position = 0; ++ spin_unlock(&batched_entropy->batch_lock); ++ ++ batched_entropy = per_cpu_ptr(&batched_entropy_u64, cpu); ++ spin_lock(&batched_entropy->batch_lock); ++ batched_entropy->position = 0; ++ spin_unlock_irqrestore(&batched_entropy->batch_lock, flags); + } +- write_unlock_irqrestore(&batched_entropy_reset_lock, flags); + } + + /** +diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c +index 5b5b5d72eab7..c55f6aeb4227 100644 +--- a/drivers/char/virtio_console.c ++++ b/drivers/char/virtio_console.c +@@ -75,7 +75,7 @@ struct ports_driver_data { + /* All the console devices handled by this driver */ + struct list_head consoles; + }; +-static struct ports_driver_data pdrvdata; ++static struct ports_driver_data pdrvdata = { .next_vtermno = 1}; + + static DEFINE_SPINLOCK(pdrvdata_lock); + static DECLARE_COMPLETION(early_console_added); +@@ -1405,6 +1405,7 @@ static int add_port(struct ports_device *portdev, u32 id) + port->async_queue = NULL; + + port->cons.ws.ws_row = port->cons.ws.ws_col = 0; ++ port->cons.vtermno = 0; + + port->host_connected = port->guest_connected = false; + port->stats = (struct port_stats) { 0 }; +diff --git a/drivers/clk/rockchip/clk-rk3288.c b/drivers/clk/rockchip/clk-rk3288.c +index 450de24a1b42..64191694ff6e 100644 +--- a/drivers/clk/rockchip/clk-rk3288.c ++++ b/drivers/clk/rockchip/clk-rk3288.c +@@ -198,7 +198,7 @@ PNAME(mux_hsadcout_p) = { "hsadc_src", "ext_hsadc" }; + PNAME(mux_edp_24m_p) = { "ext_edp_24m", "xin24m" }; + PNAME(mux_tspout_p) = { "cpll", "gpll", "npll", "xin27m" }; + +-PNAME(mux_aclk_vcodec_pre_p) = { "aclk_vepu", "aclk_vdpu" }; ++PNAME(mux_aclk_vcodec_pre_p) = { "aclk_vdpu", "aclk_vepu" }; + PNAME(mux_usbphy480m_p) = { "sclk_otgphy1_480m", "sclk_otgphy2_480m", + "sclk_otgphy0_480m" }; + PNAME(mux_hsicphy480m_p) = { "cpll", "gpll", "usbphy480m_src" }; +@@ -292,13 +292,13 @@ static struct rockchip_clk_branch rk3288_clk_branches[] __initdata = { + COMPOSITE_NOMUX(0, "aclk_core_mp", "armclk", CLK_IGNORE_UNUSED, + RK3288_CLKSEL_CON(0), 4, 4, DFLAGS | CLK_DIVIDER_READ_ONLY, + RK3288_CLKGATE_CON(12), 6, GFLAGS), +- COMPOSITE_NOMUX(0, "atclk", "armclk", CLK_IGNORE_UNUSED, ++ COMPOSITE_NOMUX(0, "atclk", "armclk", 0, + RK3288_CLKSEL_CON(37), 4, 5, DFLAGS | CLK_DIVIDER_READ_ONLY, + RK3288_CLKGATE_CON(12), 7, GFLAGS), + COMPOSITE_NOMUX(0, "pclk_dbg_pre", "armclk", CLK_IGNORE_UNUSED, + RK3288_CLKSEL_CON(37), 9, 5, DFLAGS | CLK_DIVIDER_READ_ONLY, + RK3288_CLKGATE_CON(12), 8, GFLAGS), +- GATE(0, "pclk_dbg", "pclk_dbg_pre", CLK_IGNORE_UNUSED, ++ GATE(0, "pclk_dbg", "pclk_dbg_pre", 0, + RK3288_CLKGATE_CON(12), 9, GFLAGS), + GATE(0, "cs_dbg", "pclk_dbg_pre", CLK_IGNORE_UNUSED, + RK3288_CLKGATE_CON(12), 10, GFLAGS), +@@ -399,7 +399,7 @@ static struct rockchip_clk_branch rk3288_clk_branches[] __initdata = { + COMPOSITE(0, "aclk_vdpu", mux_pll_src_cpll_gpll_usb480m_p, 0, + RK3288_CLKSEL_CON(32), 14, 2, MFLAGS, 8, 5, DFLAGS, + RK3288_CLKGATE_CON(3), 11, GFLAGS), +- MUXGRF(0, "aclk_vcodec_pre", mux_aclk_vcodec_pre_p, 0, ++ MUXGRF(0, "aclk_vcodec_pre", mux_aclk_vcodec_pre_p, CLK_SET_RATE_PARENT, + RK3288_GRF_SOC_CON(0), 7, 1, MFLAGS), + GATE(ACLK_VCODEC, "aclk_vcodec", "aclk_vcodec_pre", 0, + RK3288_CLKGATE_CON(9), 0, GFLAGS), +@@ -626,7 +626,7 @@ static struct rockchip_clk_branch rk3288_clk_branches[] __initdata = { + INVERTER(SCLK_HSADC, "sclk_hsadc", "sclk_hsadc_out", + RK3288_CLKSEL_CON(22), 7, IFLAGS), + +- GATE(0, "jtag", "ext_jtag", CLK_IGNORE_UNUSED, ++ GATE(0, "jtag", "ext_jtag", 0, + RK3288_CLKGATE_CON(4), 14, GFLAGS), + + COMPOSITE_NODIV(SCLK_USBPHY480M_SRC, "usbphy480m_src", mux_usbphy480m_p, 0, +@@ -635,7 +635,7 @@ static struct rockchip_clk_branch rk3288_clk_branches[] __initdata = { + COMPOSITE_NODIV(SCLK_HSICPHY480M, "sclk_hsicphy480m", mux_hsicphy480m_p, 0, + RK3288_CLKSEL_CON(29), 0, 2, MFLAGS, + RK3288_CLKGATE_CON(3), 6, GFLAGS), +- GATE(0, "hsicphy12m_xin12m", "xin12m", CLK_IGNORE_UNUSED, ++ GATE(0, "hsicphy12m_xin12m", "xin12m", 0, + RK3288_CLKGATE_CON(13), 9, GFLAGS), + DIV(0, "hsicphy12m_usbphy", "sclk_hsicphy480m", 0, + RK3288_CLKSEL_CON(11), 8, 6, DFLAGS), +@@ -676,7 +676,7 @@ static struct rockchip_clk_branch rk3288_clk_branches[] __initdata = { + GATE(PCLK_TZPC, "pclk_tzpc", "pclk_cpu", 0, RK3288_CLKGATE_CON(11), 3, GFLAGS), + GATE(PCLK_UART2, "pclk_uart2", "pclk_cpu", 0, RK3288_CLKGATE_CON(11), 9, GFLAGS), + GATE(PCLK_EFUSE256, "pclk_efuse_256", "pclk_cpu", 0, RK3288_CLKGATE_CON(11), 10, GFLAGS), +- GATE(PCLK_RKPWM, "pclk_rkpwm", "pclk_cpu", CLK_IGNORE_UNUSED, RK3288_CLKGATE_CON(11), 11, GFLAGS), ++ GATE(PCLK_RKPWM, "pclk_rkpwm", "pclk_cpu", 0, RK3288_CLKGATE_CON(11), 11, GFLAGS), + + /* ddrctrl [DDR Controller PHY clock] gates */ + GATE(0, "nclk_ddrupctl0", "ddrphy", CLK_IGNORE_UNUSED, RK3288_CLKGATE_CON(11), 4, GFLAGS), +@@ -816,12 +816,9 @@ static const char *const rk3288_critical_clocks[] __initconst = { + "pclk_alive_niu", + "pclk_pd_pmu", + "pclk_pmu_niu", +- "pclk_core_niu", +- "pclk_ddrupctl0", +- "pclk_publ0", +- "pclk_ddrupctl1", +- "pclk_publ1", + "pmu_hclk_otg0", ++ /* pwm-regulators on some boards, so handoff-critical later */ ++ "pclk_rkpwm", + }; + + static void __iomem *rk3288_cru_base; +diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c +index 505c9a55d555..d3213594d1a7 100644 +--- a/drivers/cpufreq/cpufreq.c ++++ b/drivers/cpufreq/cpufreq.c +@@ -1103,6 +1103,7 @@ static struct cpufreq_policy *cpufreq_policy_alloc(unsigned int cpu) + cpufreq_global_kobject, "policy%u", cpu); + if (ret) { + pr_err("%s: failed to init policy->kobj: %d\n", __func__, ret); ++ kobject_put(&policy->kobj); + goto err_free_real_cpus; + } + +diff --git a/drivers/cpufreq/cpufreq_governor.c b/drivers/cpufreq/cpufreq_governor.c +index 6d53f7d9fc7a..69fc5cf4782f 100644 +--- a/drivers/cpufreq/cpufreq_governor.c ++++ b/drivers/cpufreq/cpufreq_governor.c +@@ -459,6 +459,8 @@ int cpufreq_dbs_governor_init(struct cpufreq_policy *policy) + /* Failure, so roll back. */ + pr_err("initialization failed (dbs_data kobject init error %d)\n", ret); + ++ kobject_put(&dbs_data->attr_set.kobj); ++ + policy->governor_data = NULL; + + if (!have_governor_per_policy()) +diff --git a/drivers/cpufreq/kirkwood-cpufreq.c b/drivers/cpufreq/kirkwood-cpufreq.c +index c2dd43f3f5d8..8d63a6dc8383 100644 +--- a/drivers/cpufreq/kirkwood-cpufreq.c ++++ b/drivers/cpufreq/kirkwood-cpufreq.c +@@ -124,13 +124,14 @@ static int kirkwood_cpufreq_probe(struct platform_device *pdev) + priv.cpu_clk = of_clk_get_by_name(np, "cpu_clk"); + if (IS_ERR(priv.cpu_clk)) { + dev_err(priv.dev, "Unable to get cpuclk\n"); +- return PTR_ERR(priv.cpu_clk); ++ err = PTR_ERR(priv.cpu_clk); ++ goto out_node; + } + + err = clk_prepare_enable(priv.cpu_clk); + if (err) { + dev_err(priv.dev, "Unable to prepare cpuclk\n"); +- return err; ++ goto out_node; + } + + kirkwood_freq_table[0].frequency = clk_get_rate(priv.cpu_clk) / 1000; +@@ -161,20 +162,22 @@ static int kirkwood_cpufreq_probe(struct platform_device *pdev) + goto out_ddr; + } + +- of_node_put(np); +- np = NULL; +- + err = cpufreq_register_driver(&kirkwood_cpufreq_driver); +- if (!err) +- return 0; ++ if (err) { ++ dev_err(priv.dev, "Failed to register cpufreq driver\n"); ++ goto out_powersave; ++ } + +- dev_err(priv.dev, "Failed to register cpufreq driver\n"); ++ of_node_put(np); ++ return 0; + ++out_powersave: + clk_disable_unprepare(priv.powersave_clk); + out_ddr: + clk_disable_unprepare(priv.ddr_clk); + out_cpu: + clk_disable_unprepare(priv.cpu_clk); ++out_node: + of_node_put(np); + + return err; +diff --git a/drivers/cpufreq/pasemi-cpufreq.c b/drivers/cpufreq/pasemi-cpufreq.c +index 75dfbd2a58ea..c7710c149de8 100644 +--- a/drivers/cpufreq/pasemi-cpufreq.c ++++ b/drivers/cpufreq/pasemi-cpufreq.c +@@ -146,6 +146,7 @@ static int pas_cpufreq_cpu_init(struct cpufreq_policy *policy) + + cpu = of_get_cpu_node(policy->cpu, NULL); + ++ of_node_put(cpu); + if (!cpu) + goto out; + +diff --git a/drivers/cpufreq/pmac32-cpufreq.c b/drivers/cpufreq/pmac32-cpufreq.c +index 61ae06ca008e..e225edb5c359 100644 +--- a/drivers/cpufreq/pmac32-cpufreq.c ++++ b/drivers/cpufreq/pmac32-cpufreq.c +@@ -552,6 +552,7 @@ static int pmac_cpufreq_init_7447A(struct device_node *cpunode) + volt_gpio_np = of_find_node_by_name(NULL, "cpu-vcore-select"); + if (volt_gpio_np) + voltage_gpio = read_gpio(volt_gpio_np); ++ of_node_put(volt_gpio_np); + if (!voltage_gpio){ + pr_err("missing cpu-vcore-select gpio\n"); + return 1; +@@ -588,6 +589,7 @@ static int pmac_cpufreq_init_750FX(struct device_node *cpunode) + if (volt_gpio_np) + voltage_gpio = read_gpio(volt_gpio_np); + ++ of_node_put(volt_gpio_np); + pvr = mfspr(SPRN_PVR); + has_cpu_l2lve = !((pvr & 0xf00) == 0x100); + +diff --git a/drivers/cpufreq/ppc_cbe_cpufreq.c b/drivers/cpufreq/ppc_cbe_cpufreq.c +index 41a0f0be3f9f..8414c3a4ea08 100644 +--- a/drivers/cpufreq/ppc_cbe_cpufreq.c ++++ b/drivers/cpufreq/ppc_cbe_cpufreq.c +@@ -86,6 +86,7 @@ static int cbe_cpufreq_cpu_init(struct cpufreq_policy *policy) + if (!cbe_get_cpu_pmd_regs(policy->cpu) || + !cbe_get_cpu_mic_tm_regs(policy->cpu)) { + pr_info("invalid CBE regs pointers for cpufreq\n"); ++ of_node_put(cpu); + return -EINVAL; + } + +diff --git a/drivers/crypto/sunxi-ss/sun4i-ss-hash.c b/drivers/crypto/sunxi-ss/sun4i-ss-hash.c +index a4b5ff2b72f8..f6936bb3b7be 100644 +--- a/drivers/crypto/sunxi-ss/sun4i-ss-hash.c ++++ b/drivers/crypto/sunxi-ss/sun4i-ss-hash.c +@@ -240,7 +240,10 @@ static int sun4i_hash(struct ahash_request *areq) + } + } else { + /* Since we have the flag final, we can go up to modulo 4 */ +- end = ((areq->nbytes + op->len) / 4) * 4 - op->len; ++ if (areq->nbytes < 4) ++ end = 0; ++ else ++ end = ((areq->nbytes + op->len) / 4) * 4 - op->len; + } + + /* TODO if SGlen % 4 and !op->len then DMA */ +diff --git a/drivers/crypto/vmx/aesp8-ppc.pl b/drivers/crypto/vmx/aesp8-ppc.pl +index de78282b8f44..9c6b5c1d6a1a 100644 +--- a/drivers/crypto/vmx/aesp8-ppc.pl ++++ b/drivers/crypto/vmx/aesp8-ppc.pl +@@ -1357,7 +1357,7 @@ Loop_ctr32_enc: + addi $idx,$idx,16 + bdnz Loop_ctr32_enc + +- vadduwm $ivec,$ivec,$one ++ vadduqm $ivec,$ivec,$one + vmr $dat,$inptail + lvx $inptail,0,$inp + addi $inp,$inp,16 +diff --git a/drivers/dma/at_xdmac.c b/drivers/dma/at_xdmac.c +index a75b95fac3bd..db5b8fe1dd4a 100644 +--- a/drivers/dma/at_xdmac.c ++++ b/drivers/dma/at_xdmac.c +@@ -1606,7 +1606,11 @@ static void at_xdmac_tasklet(unsigned long data) + struct at_xdmac_desc, + xfer_node); + dev_vdbg(chan2dev(&atchan->chan), "%s: desc 0x%p\n", __func__, desc); +- BUG_ON(!desc->active_xfer); ++ if (!desc->active_xfer) { ++ dev_err(chan2dev(&atchan->chan), "Xfer not active: exiting"); ++ spin_unlock_bh(&atchan->lock); ++ return; ++ } + + txd = &desc->tx_dma_desc; + +diff --git a/drivers/dma/pl330.c b/drivers/dma/pl330.c +index 88750a34e859..bc8050c025b7 100644 +--- a/drivers/dma/pl330.c ++++ b/drivers/dma/pl330.c +@@ -961,6 +961,7 @@ static void _stop(struct pl330_thread *thrd) + { + void __iomem *regs = thrd->dmac->base; + u8 insn[6] = {0, 0, 0, 0, 0, 0}; ++ u32 inten = readl(regs + INTEN); + + if (_state(thrd) == PL330_STATE_FAULT_COMPLETING) + UNTIL(thrd, PL330_STATE_FAULTING | PL330_STATE_KILLING); +@@ -973,10 +974,13 @@ static void _stop(struct pl330_thread *thrd) + + _emit_KILL(0, insn); + +- /* Stop generating interrupts for SEV */ +- writel(readl(regs + INTEN) & ~(1 << thrd->ev), regs + INTEN); +- + _execute_DBGINSN(thrd, insn, is_manager(thrd)); ++ ++ /* clear the event */ ++ if (inten & (1 << thrd->ev)) ++ writel(1 << thrd->ev, regs + INTCLR); ++ /* Stop generating interrupts for SEV */ ++ writel(inten & ~(1 << thrd->ev), regs + INTEN); + } + + /* Start doing req 'idx' of thread 'thrd' */ +diff --git a/drivers/dma/tegra210-adma.c b/drivers/dma/tegra210-adma.c +index b26256f23d67..09b6756366c3 100644 +--- a/drivers/dma/tegra210-adma.c ++++ b/drivers/dma/tegra210-adma.c +@@ -22,7 +22,6 @@ + #include <linux/of_device.h> + #include <linux/of_dma.h> + #include <linux/of_irq.h> +-#include <linux/pm_clock.h> + #include <linux/pm_runtime.h> + #include <linux/slab.h> + +@@ -141,6 +140,7 @@ struct tegra_adma { + struct dma_device dma_dev; + struct device *dev; + void __iomem *base_addr; ++ struct clk *ahub_clk; + unsigned int nr_channels; + unsigned long rx_requests_reserved; + unsigned long tx_requests_reserved; +@@ -637,8 +637,9 @@ static int tegra_adma_runtime_suspend(struct device *dev) + struct tegra_adma *tdma = dev_get_drvdata(dev); + + tdma->global_cmd = tdma_read(tdma, ADMA_GLOBAL_CMD); ++ clk_disable_unprepare(tdma->ahub_clk); + +- return pm_clk_suspend(dev); ++ return 0; + } + + static int tegra_adma_runtime_resume(struct device *dev) +@@ -646,10 +647,11 @@ static int tegra_adma_runtime_resume(struct device *dev) + struct tegra_adma *tdma = dev_get_drvdata(dev); + int ret; + +- ret = pm_clk_resume(dev); +- if (ret) ++ ret = clk_prepare_enable(tdma->ahub_clk); ++ if (ret) { ++ dev_err(dev, "ahub clk_enable failed: %d\n", ret); + return ret; +- ++ } + tdma_write(tdma, ADMA_GLOBAL_CMD, tdma->global_cmd); + + return 0; +@@ -692,13 +694,11 @@ static int tegra_adma_probe(struct platform_device *pdev) + if (IS_ERR(tdma->base_addr)) + return PTR_ERR(tdma->base_addr); + +- ret = pm_clk_create(&pdev->dev); +- if (ret) +- return ret; +- +- ret = of_pm_clk_add_clk(&pdev->dev, "d_audio"); +- if (ret) +- goto clk_destroy; ++ tdma->ahub_clk = devm_clk_get(&pdev->dev, "d_audio"); ++ if (IS_ERR(tdma->ahub_clk)) { ++ dev_err(&pdev->dev, "Error: Missing ahub controller clock\n"); ++ return PTR_ERR(tdma->ahub_clk); ++ } + + pm_runtime_enable(&pdev->dev); + +@@ -775,8 +775,6 @@ rpm_put: + pm_runtime_put_sync(&pdev->dev); + rpm_disable: + pm_runtime_disable(&pdev->dev); +-clk_destroy: +- pm_clk_destroy(&pdev->dev); + + return ret; + } +@@ -786,6 +784,7 @@ static int tegra_adma_remove(struct platform_device *pdev) + struct tegra_adma *tdma = platform_get_drvdata(pdev); + int i; + ++ of_dma_controller_free(pdev->dev.of_node); + dma_async_device_unregister(&tdma->dma_dev); + + for (i = 0; i < tdma->nr_channels; ++i) +@@ -793,7 +792,6 @@ static int tegra_adma_remove(struct platform_device *pdev) + + pm_runtime_put_sync(&pdev->dev); + pm_runtime_disable(&pdev->dev); +- pm_clk_destroy(&pdev->dev); + + return 0; + } +diff --git a/drivers/extcon/extcon-arizona.c b/drivers/extcon/extcon-arizona.c +index da0e9bc4262f..9327479c719c 100644 +--- a/drivers/extcon/extcon-arizona.c ++++ b/drivers/extcon/extcon-arizona.c +@@ -1726,6 +1726,16 @@ static int arizona_extcon_remove(struct platform_device *pdev) + struct arizona_extcon_info *info = platform_get_drvdata(pdev); + struct arizona *arizona = info->arizona; + int jack_irq_rise, jack_irq_fall; ++ bool change; ++ ++ regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1, ++ ARIZONA_MICD_ENA, 0, ++ &change); ++ ++ if (change) { ++ regulator_disable(info->micvdd); ++ pm_runtime_put(info->dev); ++ } + + gpiod_put(info->micd_pol_gpio); + +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c +index 7056925eb386..869ff624b108 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c +@@ -136,8 +136,9 @@ int amdgpu_fence_emit(struct amdgpu_ring *ring, struct dma_fence **f, + { + struct amdgpu_device *adev = ring->adev; + struct amdgpu_fence *fence; +- struct dma_fence *old, **ptr; ++ struct dma_fence __rcu **ptr; + uint32_t seq; ++ int r; + + fence = kmem_cache_alloc(amdgpu_fence_slab, GFP_KERNEL); + if (fence == NULL) +@@ -153,15 +154,24 @@ int amdgpu_fence_emit(struct amdgpu_ring *ring, struct dma_fence **f, + seq, flags | AMDGPU_FENCE_FLAG_INT); + + ptr = &ring->fence_drv.fences[seq & ring->fence_drv.num_fences_mask]; ++ if (unlikely(rcu_dereference_protected(*ptr, 1))) { ++ struct dma_fence *old; ++ ++ rcu_read_lock(); ++ old = dma_fence_get_rcu_safe(ptr); ++ rcu_read_unlock(); ++ ++ if (old) { ++ r = dma_fence_wait(old, false); ++ dma_fence_put(old); ++ if (r) ++ return r; ++ } ++ } ++ + /* This function can't be called concurrently anyway, otherwise + * emitting the fence would mess up the hardware ring buffer. + */ +- old = rcu_dereference_protected(*ptr, 1); +- if (old && !dma_fence_is_signaled(old)) { +- DRM_INFO("rcu slot is busy\n"); +- dma_fence_wait(old, false); +- } +- + rcu_assign_pointer(*ptr, dma_fence_get(&fence->base)); + + *f = &fence->base; +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 76ee2de43ea6..dac7978f5ee1 100644 +--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c ++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +@@ -4369,8 +4369,7 @@ static void amdgpu_dm_commit_planes(struct drm_atomic_state *state, + static void amdgpu_dm_crtc_copy_transient_flags(struct drm_crtc_state *crtc_state, + struct dc_stream_state *stream_state) + { +- stream_state->mode_changed = +- crtc_state->mode_changed || crtc_state->active_changed; ++ stream_state->mode_changed = drm_atomic_crtc_needs_modeset(crtc_state); + } + + static int amdgpu_dm_atomic_commit(struct drm_device *dev, +diff --git a/drivers/gpu/drm/amd/display/dc/core/dc_resource.c b/drivers/gpu/drm/amd/display/dc/core/dc_resource.c +index 87bf422f16be..e0a96abb3c46 100644 +--- a/drivers/gpu/drm/amd/display/dc/core/dc_resource.c ++++ b/drivers/gpu/drm/amd/display/dc/core/dc_resource.c +@@ -1401,10 +1401,12 @@ bool dc_remove_plane_from_context( + * For head pipe detach surfaces from pipe for tail + * pipe just zero it out + */ +- if (!pipe_ctx->top_pipe) { ++ if (!pipe_ctx->top_pipe || ++ (!pipe_ctx->top_pipe->top_pipe && ++ pipe_ctx->top_pipe->stream_res.opp != pipe_ctx->stream_res.opp)) { + pipe_ctx->plane_state = NULL; + pipe_ctx->bottom_pipe = NULL; +- } else { ++ } else { + memset(pipe_ctx, 0, sizeof(*pipe_ctx)); + } + } +diff --git a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp_dscl.c b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp_dscl.c +index 4a863a5dab41..321af9af95e8 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp_dscl.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp_dscl.c +@@ -406,15 +406,25 @@ void dpp1_dscl_calc_lb_num_partitions( + int *num_part_y, + int *num_part_c) + { ++ int lb_memory_size, lb_memory_size_c, lb_memory_size_a, num_partitions_a, ++ lb_bpc, memory_line_size_y, memory_line_size_c, memory_line_size_a; ++ + int line_size = scl_data->viewport.width < scl_data->recout.width ? + scl_data->viewport.width : scl_data->recout.width; + int line_size_c = scl_data->viewport_c.width < scl_data->recout.width ? + scl_data->viewport_c.width : scl_data->recout.width; +- int lb_bpc = dpp1_dscl_get_lb_depth_bpc(scl_data->lb_params.depth); +- int memory_line_size_y = (line_size * lb_bpc + 71) / 72; /* +71 to ceil */ +- int memory_line_size_c = (line_size_c * lb_bpc + 71) / 72; /* +71 to ceil */ +- int memory_line_size_a = (line_size + 5) / 6; /* +5 to ceil */ +- int lb_memory_size, lb_memory_size_c, lb_memory_size_a, num_partitions_a; ++ ++ if (line_size == 0) ++ line_size = 1; ++ ++ if (line_size_c == 0) ++ line_size_c = 1; ++ ++ ++ lb_bpc = dpp1_dscl_get_lb_depth_bpc(scl_data->lb_params.depth); ++ memory_line_size_y = (line_size * lb_bpc + 71) / 72; /* +71 to ceil */ ++ memory_line_size_c = (line_size_c * lb_bpc + 71) / 72; /* +71 to ceil */ ++ memory_line_size_a = (line_size + 5) / 6; /* +5 to ceil */ + + if (lb_config == LB_MEMORY_CONFIG_1) { + lb_memory_size = 816; +diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c +index 0201ccb22f4c..d8ae4ca129c7 100644 +--- a/drivers/gpu/drm/drm_drv.c ++++ b/drivers/gpu/drm/drm_drv.c +@@ -499,7 +499,7 @@ int drm_dev_init(struct drm_device *dev, + } + + kref_init(&dev->ref); +- dev->dev = parent; ++ dev->dev = get_device(parent); + dev->driver = driver; + + INIT_LIST_HEAD(&dev->filelist); +@@ -568,6 +568,7 @@ err_minors: + drm_minor_free(dev, DRM_MINOR_RENDER); + drm_fs_inode_free(dev->anon_inode); + err_free: ++ put_device(dev->dev); + mutex_destroy(&dev->master_mutex); + mutex_destroy(&dev->ctxlist_mutex); + mutex_destroy(&dev->clientlist_mutex); +@@ -603,6 +604,8 @@ void drm_dev_fini(struct drm_device *dev) + drm_minor_free(dev, DRM_MINOR_PRIMARY); + drm_minor_free(dev, DRM_MINOR_RENDER); + ++ put_device(dev->dev); ++ + mutex_destroy(&dev->master_mutex); + mutex_destroy(&dev->ctxlist_mutex); + mutex_destroy(&dev->clientlist_mutex); +diff --git a/drivers/gpu/drm/drm_file.c b/drivers/gpu/drm/drm_file.c +index e4ccb52c67ea..334addaca9c5 100644 +--- a/drivers/gpu/drm/drm_file.c ++++ b/drivers/gpu/drm/drm_file.c +@@ -567,6 +567,7 @@ put_back_event: + file_priv->event_space -= length; + list_add(&e->link, &file_priv->event_list); + spin_unlock_irq(&dev->event_lock); ++ wake_up_interruptible(&file_priv->event_wait); + break; + } + +diff --git a/drivers/gpu/drm/etnaviv/etnaviv_drv.c b/drivers/gpu/drm/etnaviv/etnaviv_drv.c +index 83c1f46670bf..00675fcbffa2 100644 +--- a/drivers/gpu/drm/etnaviv/etnaviv_drv.c ++++ b/drivers/gpu/drm/etnaviv/etnaviv_drv.c +@@ -527,6 +527,9 @@ static int etnaviv_bind(struct device *dev) + } + drm->dev_private = priv; + ++ dev->dma_parms = &priv->dma_parms; ++ dma_set_max_seg_size(dev, SZ_2G); ++ + mutex_init(&priv->gem_lock); + INIT_LIST_HEAD(&priv->gem_list); + priv->num_gpus = 0; +@@ -564,6 +567,8 @@ static void etnaviv_unbind(struct device *dev) + + component_unbind_all(dev, drm); + ++ dev->dma_parms = NULL; ++ + drm->dev_private = NULL; + kfree(priv); + +diff --git a/drivers/gpu/drm/etnaviv/etnaviv_drv.h b/drivers/gpu/drm/etnaviv/etnaviv_drv.h +index 8d02d1b7dcf5..b2930d1fe97c 100644 +--- a/drivers/gpu/drm/etnaviv/etnaviv_drv.h ++++ b/drivers/gpu/drm/etnaviv/etnaviv_drv.h +@@ -43,6 +43,7 @@ struct etnaviv_file_private { + + struct etnaviv_drm_private { + int num_gpus; ++ struct device_dma_parameters dma_parms; + struct etnaviv_gpu *gpu[ETNA_MAX_PIPES]; + + /* list of GEM objects: */ +diff --git a/drivers/gpu/drm/msm/adreno/a5xx_gpu.c b/drivers/gpu/drm/msm/adreno/a5xx_gpu.c +index ab1d9308c311..ba6f3c14495c 100644 +--- a/drivers/gpu/drm/msm/adreno/a5xx_gpu.c ++++ b/drivers/gpu/drm/msm/adreno/a5xx_gpu.c +@@ -35,7 +35,7 @@ static int zap_shader_load_mdt(struct msm_gpu *gpu, const char *fwname) + { + struct device *dev = &gpu->pdev->dev; + const struct firmware *fw; +- struct device_node *np; ++ struct device_node *np, *mem_np; + struct resource r; + phys_addr_t mem_phys; + ssize_t mem_size; +@@ -49,11 +49,13 @@ static int zap_shader_load_mdt(struct msm_gpu *gpu, const char *fwname) + if (!np) + return -ENODEV; + +- np = of_parse_phandle(np, "memory-region", 0); +- if (!np) ++ mem_np = of_parse_phandle(np, "memory-region", 0); ++ of_node_put(np); ++ if (!mem_np) + return -EINVAL; + +- ret = of_address_to_resource(np, 0, &r); ++ ret = of_address_to_resource(mem_np, 0, &r); ++ of_node_put(mem_np); + if (ret) + return ret; + +diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/bar/nv50.c b/drivers/gpu/drm/nouveau/nvkm/subdev/bar/nv50.c +index 157b076a1272..38c9c086754b 100644 +--- a/drivers/gpu/drm/nouveau/nvkm/subdev/bar/nv50.c ++++ b/drivers/gpu/drm/nouveau/nvkm/subdev/bar/nv50.c +@@ -109,7 +109,7 @@ nv50_bar_oneinit(struct nvkm_bar *base) + struct nvkm_device *device = bar->base.subdev.device; + static struct lock_class_key bar1_lock; + static struct lock_class_key bar2_lock; +- u64 start, limit; ++ u64 start, limit, size; + int ret; + + ret = nvkm_gpuobj_new(device, 0x20000, 0, false, NULL, &bar->mem); +@@ -127,7 +127,10 @@ nv50_bar_oneinit(struct nvkm_bar *base) + + /* BAR2 */ + start = 0x0100000000ULL; +- limit = start + device->func->resource_size(device, 3); ++ size = device->func->resource_size(device, 3); ++ if (!size) ++ return -ENOMEM; ++ limit = start + size; + + ret = nvkm_vmm_new(device, start, limit-- - start, NULL, 0, + &bar2_lock, "bar2", &bar->bar2_vmm); +@@ -164,7 +167,10 @@ nv50_bar_oneinit(struct nvkm_bar *base) + + /* BAR1 */ + start = 0x0000000000ULL; +- limit = start + device->func->resource_size(device, 1); ++ size = device->func->resource_size(device, 1); ++ if (!size) ++ return -ENOMEM; ++ limit = start + size; + + ret = nvkm_vmm_new(device, start, limit-- - start, NULL, 0, + &bar1_lock, "bar1", &bar->bar1_vmm); +diff --git a/drivers/gpu/drm/omapdrm/dss/dsi.c b/drivers/gpu/drm/omapdrm/dss/dsi.c +index 74467b308721..8160954ebc25 100644 +--- a/drivers/gpu/drm/omapdrm/dss/dsi.c ++++ b/drivers/gpu/drm/omapdrm/dss/dsi.c +@@ -1386,12 +1386,9 @@ static int dsi_pll_enable(struct dss_pll *pll) + */ + dsi_enable_scp_clk(dsi); + +- if (!dsi->vdds_dsi_enabled) { +- r = regulator_enable(dsi->vdds_dsi_reg); +- if (r) +- goto err0; +- dsi->vdds_dsi_enabled = true; +- } ++ r = regulator_enable(dsi->vdds_dsi_reg); ++ if (r) ++ goto err0; + + /* XXX PLL does not come out of reset without this... */ + dispc_pck_free_enable(dsi->dss->dispc, 1); +@@ -1416,36 +1413,25 @@ static int dsi_pll_enable(struct dss_pll *pll) + + return 0; + err1: +- if (dsi->vdds_dsi_enabled) { +- regulator_disable(dsi->vdds_dsi_reg); +- dsi->vdds_dsi_enabled = false; +- } ++ regulator_disable(dsi->vdds_dsi_reg); + err0: + dsi_disable_scp_clk(dsi); + dsi_runtime_put(dsi); + return r; + } + +-static void dsi_pll_uninit(struct dsi_data *dsi, bool disconnect_lanes) ++static void dsi_pll_disable(struct dss_pll *pll) + { ++ struct dsi_data *dsi = container_of(pll, struct dsi_data, pll); ++ + dsi_pll_power(dsi, DSI_PLL_POWER_OFF); +- if (disconnect_lanes) { +- WARN_ON(!dsi->vdds_dsi_enabled); +- regulator_disable(dsi->vdds_dsi_reg); +- dsi->vdds_dsi_enabled = false; +- } ++ ++ regulator_disable(dsi->vdds_dsi_reg); + + dsi_disable_scp_clk(dsi); + dsi_runtime_put(dsi); + +- DSSDBG("PLL uninit done\n"); +-} +- +-static void dsi_pll_disable(struct dss_pll *pll) +-{ +- struct dsi_data *dsi = container_of(pll, struct dsi_data, pll); +- +- dsi_pll_uninit(dsi, true); ++ DSSDBG("PLL disable done\n"); + } + + static void dsi_dump_dsi_clocks(struct dsi_data *dsi, struct seq_file *s) +@@ -4195,11 +4181,11 @@ static int dsi_display_init_dsi(struct dsi_data *dsi) + + r = dss_pll_enable(&dsi->pll); + if (r) +- goto err0; ++ return r; + + r = dsi_configure_dsi_clocks(dsi); + if (r) +- goto err1; ++ goto err0; + + dss_select_dsi_clk_source(dsi->dss, dsi->module_id, + dsi->module_id == 0 ? +@@ -4207,6 +4193,14 @@ static int dsi_display_init_dsi(struct dsi_data *dsi) + + DSSDBG("PLL OK\n"); + ++ if (!dsi->vdds_dsi_enabled) { ++ r = regulator_enable(dsi->vdds_dsi_reg); ++ if (r) ++ goto err1; ++ ++ dsi->vdds_dsi_enabled = true; ++ } ++ + r = dsi_cio_init(dsi); + if (r) + goto err2; +@@ -4235,10 +4229,13 @@ static int dsi_display_init_dsi(struct dsi_data *dsi) + err3: + dsi_cio_uninit(dsi); + err2: +- dss_select_dsi_clk_source(dsi->dss, dsi->module_id, DSS_CLK_SRC_FCK); ++ regulator_disable(dsi->vdds_dsi_reg); ++ dsi->vdds_dsi_enabled = false; + err1: +- dss_pll_disable(&dsi->pll); ++ dss_select_dsi_clk_source(dsi->dss, dsi->module_id, DSS_CLK_SRC_FCK); + err0: ++ dss_pll_disable(&dsi->pll); ++ + return r; + } + +@@ -4257,7 +4254,12 @@ static void dsi_display_uninit_dsi(struct dsi_data *dsi, bool disconnect_lanes, + + dss_select_dsi_clk_source(dsi->dss, dsi->module_id, DSS_CLK_SRC_FCK); + dsi_cio_uninit(dsi); +- dsi_pll_uninit(dsi, disconnect_lanes); ++ dss_pll_disable(&dsi->pll); ++ ++ if (disconnect_lanes) { ++ regulator_disable(dsi->vdds_dsi_reg); ++ dsi->vdds_dsi_enabled = false; ++ } + } + + static int dsi_display_enable(struct omap_dss_device *dssdev) +diff --git a/drivers/gpu/drm/panel/panel-orisetech-otm8009a.c b/drivers/gpu/drm/panel/panel-orisetech-otm8009a.c +index 87fa316e1d7b..58ccf648b70f 100644 +--- a/drivers/gpu/drm/panel/panel-orisetech-otm8009a.c ++++ b/drivers/gpu/drm/panel/panel-orisetech-otm8009a.c +@@ -248,6 +248,9 @@ static int otm8009a_init_sequence(struct otm8009a *ctx) + /* Send Command GRAM memory write (no parameters) */ + dcs_write_seq(ctx, MIPI_DCS_WRITE_MEMORY_START); + ++ /* Wait a short while to let the panel be ready before the 1st frame */ ++ mdelay(10); ++ + return 0; + } + +diff --git a/drivers/gpu/drm/pl111/pl111_versatile.c b/drivers/gpu/drm/pl111/pl111_versatile.c +index b9baefdba38a..1c318ad32a8c 100644 +--- a/drivers/gpu/drm/pl111/pl111_versatile.c ++++ b/drivers/gpu/drm/pl111/pl111_versatile.c +@@ -330,6 +330,7 @@ int pl111_versatile_init(struct device *dev, struct pl111_drm_dev_private *priv) + ret = vexpress_muxfpga_init(); + if (ret) { + dev_err(dev, "unable to initialize muxfpga driver\n"); ++ of_node_put(np); + return ret; + } + +@@ -337,17 +338,20 @@ int pl111_versatile_init(struct device *dev, struct pl111_drm_dev_private *priv) + pdev = of_find_device_by_node(np); + if (!pdev) { + dev_err(dev, "can't find the sysreg device, deferring\n"); ++ of_node_put(np); + return -EPROBE_DEFER; + } + map = dev_get_drvdata(&pdev->dev); + if (!map) { + dev_err(dev, "sysreg has not yet probed\n"); + platform_device_put(pdev); ++ of_node_put(np); + return -EPROBE_DEFER; + } + } else { + map = syscon_node_to_regmap(np); + } ++ of_node_put(np); + + if (IS_ERR(map)) { + dev_err(dev, "no Versatile syscon regmap\n"); +diff --git a/drivers/gpu/drm/sun4i/sun6i_mipi_dsi.c b/drivers/gpu/drm/sun4i/sun6i_mipi_dsi.c +index e3b34a345546..97a0573cc514 100644 +--- a/drivers/gpu/drm/sun4i/sun6i_mipi_dsi.c ++++ b/drivers/gpu/drm/sun4i/sun6i_mipi_dsi.c +@@ -357,7 +357,13 @@ static void sun6i_dsi_inst_init(struct sun6i_dsi *dsi, + static u16 sun6i_dsi_get_video_start_delay(struct sun6i_dsi *dsi, + struct drm_display_mode *mode) + { +- return mode->vtotal - (mode->vsync_end - mode->vdisplay) + 1; ++ u16 start = clamp(mode->vtotal - mode->vdisplay - 10, 8, 100); ++ u16 delay = mode->vtotal - (mode->vsync_end - mode->vdisplay) + start; ++ ++ if (delay > mode->vtotal) ++ delay = delay % mode->vtotal; ++ ++ return max_t(u16, delay, 1); + } + + static void sun6i_dsi_setup_burst(struct sun6i_dsi *dsi, +diff --git a/drivers/gpu/drm/tinydrm/ili9225.c b/drivers/gpu/drm/tinydrm/ili9225.c +index 455fefe012f5..6044a01069ce 100644 +--- a/drivers/gpu/drm/tinydrm/ili9225.c ++++ b/drivers/gpu/drm/tinydrm/ili9225.c +@@ -278,7 +278,7 @@ static void ili9225_pipe_disable(struct drm_simple_display_pipe *pipe) + mipi->enabled = false; + } + +-static int ili9225_dbi_command(struct mipi_dbi *mipi, u8 cmd, u8 *par, ++static int ili9225_dbi_command(struct mipi_dbi *mipi, u8 *cmd, u8 *par, + size_t num) + { + struct spi_device *spi = mipi->spi; +@@ -288,11 +288,11 @@ static int ili9225_dbi_command(struct mipi_dbi *mipi, u8 cmd, u8 *par, + + gpiod_set_value_cansleep(mipi->dc, 0); + speed_hz = mipi_dbi_spi_cmd_max_speed(spi, 1); +- ret = tinydrm_spi_transfer(spi, speed_hz, NULL, 8, &cmd, 1); ++ ret = tinydrm_spi_transfer(spi, speed_hz, NULL, 8, cmd, 1); + if (ret || !num) + return ret; + +- if (cmd == ILI9225_WRITE_DATA_TO_GRAM && !mipi->swap_bytes) ++ if (*cmd == ILI9225_WRITE_DATA_TO_GRAM && !mipi->swap_bytes) + bpw = 16; + + gpiod_set_value_cansleep(mipi->dc, 1); +diff --git a/drivers/gpu/drm/tinydrm/mipi-dbi.c b/drivers/gpu/drm/tinydrm/mipi-dbi.c +index cb3441e51d5f..e772a8a9da80 100644 +--- a/drivers/gpu/drm/tinydrm/mipi-dbi.c ++++ b/drivers/gpu/drm/tinydrm/mipi-dbi.c +@@ -144,16 +144,42 @@ EXPORT_SYMBOL(mipi_dbi_command_read); + */ + int mipi_dbi_command_buf(struct mipi_dbi *mipi, u8 cmd, u8 *data, size_t len) + { ++ u8 *cmdbuf; + int ret; + ++ /* SPI requires dma-safe buffers */ ++ cmdbuf = kmemdup(&cmd, 1, GFP_KERNEL); ++ if (!cmdbuf) ++ return -ENOMEM; ++ + mutex_lock(&mipi->cmdlock); +- ret = mipi->command(mipi, cmd, data, len); ++ ret = mipi->command(mipi, cmdbuf, data, len); + mutex_unlock(&mipi->cmdlock); + ++ kfree(cmdbuf); ++ + return ret; + } + EXPORT_SYMBOL(mipi_dbi_command_buf); + ++/* This should only be used by mipi_dbi_command() */ ++int mipi_dbi_command_stackbuf(struct mipi_dbi *mipi, u8 cmd, u8 *data, size_t len) ++{ ++ u8 *buf; ++ int ret; ++ ++ buf = kmemdup(data, len, GFP_KERNEL); ++ if (!buf) ++ return -ENOMEM; ++ ++ ret = mipi_dbi_command_buf(mipi, cmd, buf, len); ++ ++ kfree(buf); ++ ++ return ret; ++} ++EXPORT_SYMBOL(mipi_dbi_command_stackbuf); ++ + /** + * mipi_dbi_buf_copy - Copy a framebuffer, transforming it if necessary + * @dst: The destination buffer +@@ -741,18 +767,18 @@ static int mipi_dbi_spi1_transfer(struct mipi_dbi *mipi, int dc, + return 0; + } + +-static int mipi_dbi_typec1_command(struct mipi_dbi *mipi, u8 cmd, ++static int mipi_dbi_typec1_command(struct mipi_dbi *mipi, u8 *cmd, + u8 *parameters, size_t num) + { +- unsigned int bpw = (cmd == MIPI_DCS_WRITE_MEMORY_START) ? 16 : 8; ++ unsigned int bpw = (*cmd == MIPI_DCS_WRITE_MEMORY_START) ? 16 : 8; + int ret; + +- if (mipi_dbi_command_is_read(mipi, cmd)) ++ if (mipi_dbi_command_is_read(mipi, *cmd)) + return -ENOTSUPP; + +- MIPI_DBI_DEBUG_COMMAND(cmd, parameters, num); ++ MIPI_DBI_DEBUG_COMMAND(*cmd, parameters, num); + +- ret = mipi_dbi_spi1_transfer(mipi, 0, &cmd, 1, 8); ++ ret = mipi_dbi_spi1_transfer(mipi, 0, cmd, 1, 8); + if (ret || !num) + return ret; + +@@ -761,7 +787,7 @@ static int mipi_dbi_typec1_command(struct mipi_dbi *mipi, u8 cmd, + + /* MIPI DBI Type C Option 3 */ + +-static int mipi_dbi_typec3_command_read(struct mipi_dbi *mipi, u8 cmd, ++static int mipi_dbi_typec3_command_read(struct mipi_dbi *mipi, u8 *cmd, + u8 *data, size_t len) + { + struct spi_device *spi = mipi->spi; +@@ -770,7 +796,7 @@ static int mipi_dbi_typec3_command_read(struct mipi_dbi *mipi, u8 cmd, + struct spi_transfer tr[2] = { + { + .speed_hz = speed_hz, +- .tx_buf = &cmd, ++ .tx_buf = cmd, + .len = 1, + }, { + .speed_hz = speed_hz, +@@ -788,8 +814,8 @@ static int mipi_dbi_typec3_command_read(struct mipi_dbi *mipi, u8 cmd, + * Support non-standard 24-bit and 32-bit Nokia read commands which + * start with a dummy clock, so we need to read an extra byte. + */ +- if (cmd == MIPI_DCS_GET_DISPLAY_ID || +- cmd == MIPI_DCS_GET_DISPLAY_STATUS) { ++ if (*cmd == MIPI_DCS_GET_DISPLAY_ID || ++ *cmd == MIPI_DCS_GET_DISPLAY_STATUS) { + if (!(len == 3 || len == 4)) + return -EINVAL; + +@@ -819,7 +845,7 @@ static int mipi_dbi_typec3_command_read(struct mipi_dbi *mipi, u8 cmd, + data[i] = (buf[i] << 1) | !!(buf[i + 1] & BIT(7)); + } + +- MIPI_DBI_DEBUG_COMMAND(cmd, data, len); ++ MIPI_DBI_DEBUG_COMMAND(*cmd, data, len); + + err_free: + kfree(buf); +@@ -827,7 +853,7 @@ err_free: + return ret; + } + +-static int mipi_dbi_typec3_command(struct mipi_dbi *mipi, u8 cmd, ++static int mipi_dbi_typec3_command(struct mipi_dbi *mipi, u8 *cmd, + u8 *par, size_t num) + { + struct spi_device *spi = mipi->spi; +@@ -835,18 +861,18 @@ static int mipi_dbi_typec3_command(struct mipi_dbi *mipi, u8 cmd, + u32 speed_hz; + int ret; + +- if (mipi_dbi_command_is_read(mipi, cmd)) ++ if (mipi_dbi_command_is_read(mipi, *cmd)) + return mipi_dbi_typec3_command_read(mipi, cmd, par, num); + +- MIPI_DBI_DEBUG_COMMAND(cmd, par, num); ++ MIPI_DBI_DEBUG_COMMAND(*cmd, par, num); + + gpiod_set_value_cansleep(mipi->dc, 0); + speed_hz = mipi_dbi_spi_cmd_max_speed(spi, 1); +- ret = tinydrm_spi_transfer(spi, speed_hz, NULL, 8, &cmd, 1); ++ ret = tinydrm_spi_transfer(spi, speed_hz, NULL, 8, cmd, 1); + if (ret || !num) + return ret; + +- if (cmd == MIPI_DCS_WRITE_MEMORY_START && !mipi->swap_bytes) ++ if (*cmd == MIPI_DCS_WRITE_MEMORY_START && !mipi->swap_bytes) + bpw = 16; + + gpiod_set_value_cansleep(mipi->dc, 1); +diff --git a/drivers/gpu/drm/v3d/v3d_drv.c b/drivers/gpu/drm/v3d/v3d_drv.c +index 2a85fa68ffea..2a4c6187e675 100644 +--- a/drivers/gpu/drm/v3d/v3d_drv.c ++++ b/drivers/gpu/drm/v3d/v3d_drv.c +@@ -305,14 +305,18 @@ static int v3d_platform_drm_probe(struct platform_device *pdev) + if (ret) + goto dev_destroy; + +- v3d_irq_init(v3d); ++ ret = v3d_irq_init(v3d); ++ if (ret) ++ goto gem_destroy; + + ret = drm_dev_register(drm, 0); + if (ret) +- goto gem_destroy; ++ goto irq_disable; + + return 0; + ++irq_disable: ++ v3d_irq_disable(v3d); + gem_destroy: + v3d_gem_destroy(drm); + dev_destroy: +diff --git a/drivers/gpu/drm/v3d/v3d_drv.h b/drivers/gpu/drm/v3d/v3d_drv.h +index e6fed696ad86..0ad73f4b7509 100644 +--- a/drivers/gpu/drm/v3d/v3d_drv.h ++++ b/drivers/gpu/drm/v3d/v3d_drv.h +@@ -284,7 +284,7 @@ void v3d_invalidate_caches(struct v3d_dev *v3d); + void v3d_flush_caches(struct v3d_dev *v3d); + + /* v3d_irq.c */ +-void v3d_irq_init(struct v3d_dev *v3d); ++int v3d_irq_init(struct v3d_dev *v3d); + void v3d_irq_enable(struct v3d_dev *v3d); + void v3d_irq_disable(struct v3d_dev *v3d); + void v3d_irq_reset(struct v3d_dev *v3d); +diff --git a/drivers/gpu/drm/v3d/v3d_irq.c b/drivers/gpu/drm/v3d/v3d_irq.c +index e07514eb11b5..22be0f2dff99 100644 +--- a/drivers/gpu/drm/v3d/v3d_irq.c ++++ b/drivers/gpu/drm/v3d/v3d_irq.c +@@ -137,7 +137,7 @@ v3d_hub_irq(int irq, void *arg) + return status; + } + +-void ++int + v3d_irq_init(struct v3d_dev *v3d) + { + int ret, core; +@@ -154,13 +154,22 @@ v3d_irq_init(struct v3d_dev *v3d) + ret = devm_request_irq(v3d->dev, platform_get_irq(v3d->pdev, 0), + v3d_hub_irq, IRQF_SHARED, + "v3d_hub", v3d); ++ if (ret) ++ goto fail; ++ + ret = devm_request_irq(v3d->dev, platform_get_irq(v3d->pdev, 1), + v3d_irq, IRQF_SHARED, + "v3d_core0", v3d); + if (ret) +- dev_err(v3d->dev, "IRQ setup failed: %d\n", ret); ++ goto fail; + + v3d_irq_enable(v3d); ++ return 0; ++ ++fail: ++ if (ret != -EPROBE_DEFER) ++ dev_err(v3d->dev, "IRQ setup failed: %d\n", ret); ++ return ret; + } + + void +diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c +index 44564f61e9cc..861375561156 100644 +--- a/drivers/hid/hid-core.c ++++ b/drivers/hid/hid-core.c +@@ -215,13 +215,14 @@ static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type) + * Add a usage to the temporary parser table. + */ + +-static int hid_add_usage(struct hid_parser *parser, unsigned usage) ++static int hid_add_usage(struct hid_parser *parser, unsigned usage, u8 size) + { + if (parser->local.usage_index >= HID_MAX_USAGES) { + hid_err(parser->device, "usage index exceeded\n"); + return -1; + } + parser->local.usage[parser->local.usage_index] = usage; ++ parser->local.usage_size[parser->local.usage_index] = size; + parser->local.collection_index[parser->local.usage_index] = + parser->collection_stack_ptr ? + parser->collection_stack[parser->collection_stack_ptr - 1] : 0; +@@ -482,10 +483,7 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item) + return 0; + } + +- if (item->size <= 2) +- data = (parser->global.usage_page << 16) + data; +- +- return hid_add_usage(parser, data); ++ return hid_add_usage(parser, data, item->size); + + case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM: + +@@ -494,9 +492,6 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item) + return 0; + } + +- if (item->size <= 2) +- data = (parser->global.usage_page << 16) + data; +- + parser->local.usage_minimum = data; + return 0; + +@@ -507,9 +502,6 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item) + return 0; + } + +- if (item->size <= 2) +- data = (parser->global.usage_page << 16) + data; +- + count = data - parser->local.usage_minimum; + if (count + parser->local.usage_index >= HID_MAX_USAGES) { + /* +@@ -529,7 +521,7 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item) + } + + for (n = parser->local.usage_minimum; n <= data; n++) +- if (hid_add_usage(parser, n)) { ++ if (hid_add_usage(parser, n, item->size)) { + dbg_hid("hid_add_usage failed\n"); + return -1; + } +@@ -543,6 +535,22 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item) + return 0; + } + ++/* ++ * Concatenate Usage Pages into Usages where relevant: ++ * As per specification, 6.2.2.8: "When the parser encounters a main item it ++ * concatenates the last declared Usage Page with a Usage to form a complete ++ * usage value." ++ */ ++ ++static void hid_concatenate_usage_page(struct hid_parser *parser) ++{ ++ int i; ++ ++ for (i = 0; i < parser->local.usage_index; i++) ++ if (parser->local.usage_size[i] <= 2) ++ parser->local.usage[i] += parser->global.usage_page << 16; ++} ++ + /* + * Process a main item. + */ +@@ -552,6 +560,8 @@ static int hid_parser_main(struct hid_parser *parser, struct hid_item *item) + __u32 data; + int ret; + ++ hid_concatenate_usage_page(parser); ++ + data = item_udata(item); + + switch (item->tag) { +@@ -761,6 +771,8 @@ static int hid_scan_main(struct hid_parser *parser, struct hid_item *item) + __u32 data; + int i; + ++ hid_concatenate_usage_page(parser); ++ + data = item_udata(item); + + switch (item->tag) { +diff --git a/drivers/hid/hid-logitech-hidpp.c b/drivers/hid/hid-logitech-hidpp.c +index 8425d3548a41..e642cfaf303b 100644 +--- a/drivers/hid/hid-logitech-hidpp.c ++++ b/drivers/hid/hid-logitech-hidpp.c +@@ -725,13 +725,16 @@ static int hidpp_root_get_feature(struct hidpp_device *hidpp, u16 feature, + + static int hidpp_root_get_protocol_version(struct hidpp_device *hidpp) + { ++ const u8 ping_byte = 0x5a; ++ u8 ping_data[3] = { 0, 0, ping_byte }; + struct hidpp_report response; + int ret; + +- ret = hidpp_send_fap_command_sync(hidpp, ++ ret = hidpp_send_rap_command_sync(hidpp, ++ REPORT_ID_HIDPP_SHORT, + HIDPP_PAGE_ROOT_IDX, + CMD_ROOT_GET_PROTOCOL_VERSION, +- NULL, 0, &response); ++ ping_data, sizeof(ping_data), &response); + + if (ret == HIDPP_ERROR_INVALID_SUBID) { + hidpp->protocol_major = 1; +@@ -751,8 +754,14 @@ static int hidpp_root_get_protocol_version(struct hidpp_device *hidpp) + if (ret) + return ret; + +- hidpp->protocol_major = response.fap.params[0]; +- hidpp->protocol_minor = response.fap.params[1]; ++ if (response.rap.params[2] != ping_byte) { ++ hid_err(hidpp->hid_dev, "%s: ping mismatch 0x%02x != 0x%02x\n", ++ __func__, response.rap.params[2], ping_byte); ++ return -EPROTO; ++ } ++ ++ hidpp->protocol_major = response.rap.params[0]; ++ hidpp->protocol_minor = response.rap.params[1]; + + return ret; + } +@@ -901,7 +910,11 @@ static int hidpp_map_battery_level(int capacity) + { + if (capacity < 11) + return POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL; +- else if (capacity < 31) ++ /* ++ * The spec says this should be < 31 but some devices report 30 ++ * with brand new batteries and Windows reports 30 as "Good". ++ */ ++ else if (capacity < 30) + return POWER_SUPPLY_CAPACITY_LEVEL_LOW; + else if (capacity < 81) + return POWER_SUPPLY_CAPACITY_LEVEL_NORMAL; +diff --git a/drivers/hwmon/f71805f.c b/drivers/hwmon/f71805f.c +index 73c681162653..623736d2a7c1 100644 +--- a/drivers/hwmon/f71805f.c ++++ b/drivers/hwmon/f71805f.c +@@ -96,17 +96,23 @@ superio_select(int base, int ld) + outb(ld, base + 1); + } + +-static inline void ++static inline int + superio_enter(int base) + { ++ if (!request_muxed_region(base, 2, DRVNAME)) ++ return -EBUSY; ++ + outb(0x87, base); + outb(0x87, base); ++ ++ return 0; + } + + static inline void + superio_exit(int base) + { + outb(0xaa, base); ++ release_region(base, 2); + } + + /* +@@ -1561,7 +1567,7 @@ exit: + static int __init f71805f_find(int sioaddr, unsigned short *address, + struct f71805f_sio_data *sio_data) + { +- int err = -ENODEV; ++ int err; + u16 devid; + + static const char * const names[] = { +@@ -1569,8 +1575,11 @@ static int __init f71805f_find(int sioaddr, unsigned short *address, + "F71872F/FG or F71806F/FG", + }; + +- superio_enter(sioaddr); ++ err = superio_enter(sioaddr); ++ if (err) ++ return err; + ++ err = -ENODEV; + devid = superio_inw(sioaddr, SIO_REG_MANID); + if (devid != SIO_FINTEK_ID) + goto exit; +diff --git a/drivers/hwmon/pc87427.c b/drivers/hwmon/pc87427.c +index dc5a9d5ada51..81a05cd1a512 100644 +--- a/drivers/hwmon/pc87427.c ++++ b/drivers/hwmon/pc87427.c +@@ -106,6 +106,13 @@ static const char *logdev_str[2] = { DRVNAME " FMC", DRVNAME " HMC" }; + #define LD_IN 1 + #define LD_TEMP 1 + ++static inline int superio_enter(int sioaddr) ++{ ++ if (!request_muxed_region(sioaddr, 2, DRVNAME)) ++ return -EBUSY; ++ return 0; ++} ++ + static inline void superio_outb(int sioaddr, int reg, int val) + { + outb(reg, sioaddr); +@@ -122,6 +129,7 @@ static inline void superio_exit(int sioaddr) + { + outb(0x02, sioaddr); + outb(0x02, sioaddr + 1); ++ release_region(sioaddr, 2); + } + + /* +@@ -1220,7 +1228,11 @@ static int __init pc87427_find(int sioaddr, struct pc87427_sio_data *sio_data) + { + u16 val; + u8 cfg, cfg_b; +- int i, err = 0; ++ int i, err; ++ ++ err = superio_enter(sioaddr); ++ if (err) ++ return err; + + /* Identify device */ + val = force_id ? force_id : superio_inb(sioaddr, SIOREG_DEVID); +diff --git a/drivers/hwmon/smsc47b397.c b/drivers/hwmon/smsc47b397.c +index 6bd200756560..cbdb5c4991ae 100644 +--- a/drivers/hwmon/smsc47b397.c ++++ b/drivers/hwmon/smsc47b397.c +@@ -72,14 +72,19 @@ static inline void superio_select(int ld) + superio_outb(0x07, ld); + } + +-static inline void superio_enter(void) ++static inline int superio_enter(void) + { ++ if (!request_muxed_region(REG, 2, DRVNAME)) ++ return -EBUSY; ++ + outb(0x55, REG); ++ return 0; + } + + static inline void superio_exit(void) + { + outb(0xAA, REG); ++ release_region(REG, 2); + } + + #define SUPERIO_REG_DEVID 0x20 +@@ -300,8 +305,12 @@ static int __init smsc47b397_find(void) + u8 id, rev; + char *name; + unsigned short addr; ++ int err; ++ ++ err = superio_enter(); ++ if (err) ++ return err; + +- superio_enter(); + id = force_id ? force_id : superio_inb(SUPERIO_REG_DEVID); + + switch (id) { +diff --git a/drivers/hwmon/smsc47m1.c b/drivers/hwmon/smsc47m1.c +index c7b6a425e2c0..5eeac9853d0a 100644 +--- a/drivers/hwmon/smsc47m1.c ++++ b/drivers/hwmon/smsc47m1.c +@@ -73,16 +73,21 @@ superio_inb(int reg) + /* logical device for fans is 0x0A */ + #define superio_select() superio_outb(0x07, 0x0A) + +-static inline void ++static inline int + superio_enter(void) + { ++ if (!request_muxed_region(REG, 2, DRVNAME)) ++ return -EBUSY; ++ + outb(0x55, REG); ++ return 0; + } + + static inline void + superio_exit(void) + { + outb(0xAA, REG); ++ release_region(REG, 2); + } + + #define SUPERIO_REG_ACT 0x30 +@@ -531,8 +536,12 @@ static int __init smsc47m1_find(struct smsc47m1_sio_data *sio_data) + { + u8 val; + unsigned short addr; ++ int err; ++ ++ err = superio_enter(); ++ if (err) ++ return err; + +- superio_enter(); + val = force_id ? force_id : superio_inb(SUPERIO_REG_DEVID); + + /* +@@ -608,13 +617,14 @@ static int __init smsc47m1_find(struct smsc47m1_sio_data *sio_data) + static void smsc47m1_restore(const struct smsc47m1_sio_data *sio_data) + { + if ((sio_data->activate & 0x01) == 0) { +- superio_enter(); +- superio_select(); +- +- pr_info("Disabling device\n"); +- superio_outb(SUPERIO_REG_ACT, sio_data->activate); +- +- superio_exit(); ++ if (!superio_enter()) { ++ superio_select(); ++ pr_info("Disabling device\n"); ++ superio_outb(SUPERIO_REG_ACT, sio_data->activate); ++ superio_exit(); ++ } else { ++ pr_warn("Failed to disable device\n"); ++ } + } + } + +diff --git a/drivers/hwmon/vt1211.c b/drivers/hwmon/vt1211.c +index 3a6bfa51cb94..95d5e8ec8b7f 100644 +--- a/drivers/hwmon/vt1211.c ++++ b/drivers/hwmon/vt1211.c +@@ -226,15 +226,21 @@ static inline void superio_select(int sio_cip, int ldn) + outb(ldn, sio_cip + 1); + } + +-static inline void superio_enter(int sio_cip) ++static inline int superio_enter(int sio_cip) + { ++ if (!request_muxed_region(sio_cip, 2, DRVNAME)) ++ return -EBUSY; ++ + outb(0x87, sio_cip); + outb(0x87, sio_cip); ++ ++ return 0; + } + + static inline void superio_exit(int sio_cip) + { + outb(0xaa, sio_cip); ++ release_region(sio_cip, 2); + } + + /* --------------------------------------------------------------------- +@@ -1282,11 +1288,14 @@ EXIT: + + static int __init vt1211_find(int sio_cip, unsigned short *address) + { +- int err = -ENODEV; ++ int err; + int devid; + +- superio_enter(sio_cip); ++ err = superio_enter(sio_cip); ++ if (err) ++ return err; + ++ err = -ENODEV; + devid = force_id ? force_id : superio_inb(sio_cip, SIO_VT1211_DEVID); + if (devid != SIO_VT1211_ID) + goto EXIT; +diff --git a/drivers/iio/adc/Kconfig b/drivers/iio/adc/Kconfig +index 4a754921fb6f..9421c1ec86f7 100644 +--- a/drivers/iio/adc/Kconfig ++++ b/drivers/iio/adc/Kconfig +@@ -696,6 +696,7 @@ config STM32_DFSDM_ADC + depends on (ARCH_STM32 && OF) || COMPILE_TEST + select STM32_DFSDM_CORE + select REGMAP_MMIO ++ select IIO_BUFFER + select IIO_BUFFER_HW_CONSUMER + help + Select this option to support ADCSigma delta modulator for +diff --git a/drivers/iio/adc/ad_sigma_delta.c b/drivers/iio/adc/ad_sigma_delta.c +index ae2a5097f449..25af4c76b57f 100644 +--- a/drivers/iio/adc/ad_sigma_delta.c ++++ b/drivers/iio/adc/ad_sigma_delta.c +@@ -62,7 +62,7 @@ int ad_sd_write_reg(struct ad_sigma_delta *sigma_delta, unsigned int reg, + struct spi_transfer t = { + .tx_buf = data, + .len = size + 1, +- .cs_change = sigma_delta->bus_locked, ++ .cs_change = sigma_delta->keep_cs_asserted, + }; + struct spi_message m; + int ret; +@@ -218,6 +218,7 @@ static int ad_sd_calibrate(struct ad_sigma_delta *sigma_delta, + + spi_bus_lock(sigma_delta->spi->master); + sigma_delta->bus_locked = true; ++ sigma_delta->keep_cs_asserted = true; + reinit_completion(&sigma_delta->completion); + + ret = ad_sigma_delta_set_mode(sigma_delta, mode); +@@ -235,9 +236,10 @@ static int ad_sd_calibrate(struct ad_sigma_delta *sigma_delta, + ret = 0; + } + out: ++ sigma_delta->keep_cs_asserted = false; ++ ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE); + sigma_delta->bus_locked = false; + spi_bus_unlock(sigma_delta->spi->master); +- ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE); + + return ret; + } +@@ -289,6 +291,7 @@ int ad_sigma_delta_single_conversion(struct iio_dev *indio_dev, + + spi_bus_lock(sigma_delta->spi->master); + sigma_delta->bus_locked = true; ++ sigma_delta->keep_cs_asserted = true; + reinit_completion(&sigma_delta->completion); + + ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_SINGLE); +@@ -298,9 +301,6 @@ int ad_sigma_delta_single_conversion(struct iio_dev *indio_dev, + ret = wait_for_completion_interruptible_timeout( + &sigma_delta->completion, HZ); + +- sigma_delta->bus_locked = false; +- spi_bus_unlock(sigma_delta->spi->master); +- + if (ret == 0) + ret = -EIO; + if (ret < 0) +@@ -316,7 +316,10 @@ out: + sigma_delta->irq_dis = true; + } + ++ sigma_delta->keep_cs_asserted = false; + ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE); ++ sigma_delta->bus_locked = false; ++ spi_bus_unlock(sigma_delta->spi->master); + mutex_unlock(&indio_dev->mlock); + + if (ret) +@@ -353,6 +356,8 @@ static int ad_sd_buffer_postenable(struct iio_dev *indio_dev) + + spi_bus_lock(sigma_delta->spi->master); + sigma_delta->bus_locked = true; ++ sigma_delta->keep_cs_asserted = true; ++ + ret = ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_CONTINUOUS); + if (ret) + goto err_unlock; +@@ -381,6 +386,7 @@ static int ad_sd_buffer_postdisable(struct iio_dev *indio_dev) + sigma_delta->irq_dis = true; + } + ++ sigma_delta->keep_cs_asserted = false; + ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE); + + sigma_delta->bus_locked = false; +diff --git a/drivers/iio/adc/ti-ads7950.c b/drivers/iio/adc/ti-ads7950.c +index a5bd5944bc66..c9cd7e5c1b61 100644 +--- a/drivers/iio/adc/ti-ads7950.c ++++ b/drivers/iio/adc/ti-ads7950.c +@@ -56,6 +56,9 @@ struct ti_ads7950_state { + struct spi_message ring_msg; + struct spi_message scan_single_msg; + ++ /* Lock to protect the spi xfer buffers */ ++ struct mutex slock; ++ + struct regulator *reg; + unsigned int vref_mv; + +@@ -277,6 +280,7 @@ static irqreturn_t ti_ads7950_trigger_handler(int irq, void *p) + struct ti_ads7950_state *st = iio_priv(indio_dev); + int ret; + ++ mutex_lock(&st->slock); + ret = spi_sync(st->spi, &st->ring_msg); + if (ret < 0) + goto out; +@@ -285,6 +289,7 @@ static irqreturn_t ti_ads7950_trigger_handler(int irq, void *p) + iio_get_time_ns(indio_dev)); + + out: ++ mutex_unlock(&st->slock); + iio_trigger_notify_done(indio_dev->trig); + + return IRQ_HANDLED; +@@ -295,7 +300,7 @@ static int ti_ads7950_scan_direct(struct iio_dev *indio_dev, unsigned int ch) + struct ti_ads7950_state *st = iio_priv(indio_dev); + int ret, cmd; + +- mutex_lock(&indio_dev->mlock); ++ mutex_lock(&st->slock); + + cmd = TI_ADS7950_CR_WRITE | TI_ADS7950_CR_CHAN(ch) | st->settings; + st->single_tx = cpu_to_be16(cmd); +@@ -307,7 +312,7 @@ static int ti_ads7950_scan_direct(struct iio_dev *indio_dev, unsigned int ch) + ret = be16_to_cpu(st->single_rx); + + out: +- mutex_unlock(&indio_dev->mlock); ++ mutex_unlock(&st->slock); + + return ret; + } +@@ -423,16 +428,19 @@ static int ti_ads7950_probe(struct spi_device *spi) + if (ACPI_COMPANION(&spi->dev)) + st->vref_mv = TI_ADS7950_VA_MV_ACPI_DEFAULT; + ++ mutex_init(&st->slock); ++ + st->reg = devm_regulator_get(&spi->dev, "vref"); + if (IS_ERR(st->reg)) { + dev_err(&spi->dev, "Failed get get regulator \"vref\"\n"); +- return PTR_ERR(st->reg); ++ ret = PTR_ERR(st->reg); ++ goto error_destroy_mutex; + } + + ret = regulator_enable(st->reg); + if (ret) { + dev_err(&spi->dev, "Failed to enable regulator \"vref\"\n"); +- return ret; ++ goto error_destroy_mutex; + } + + ret = iio_triggered_buffer_setup(indio_dev, NULL, +@@ -454,6 +462,8 @@ error_cleanup_ring: + iio_triggered_buffer_cleanup(indio_dev); + error_disable_reg: + regulator_disable(st->reg); ++error_destroy_mutex: ++ mutex_destroy(&st->slock); + + return ret; + } +@@ -466,6 +476,7 @@ static int ti_ads7950_remove(struct spi_device *spi) + iio_device_unregister(indio_dev); + iio_triggered_buffer_cleanup(indio_dev); + regulator_disable(st->reg); ++ mutex_destroy(&st->slock); + + return 0; + } +diff --git a/drivers/iio/common/ssp_sensors/ssp_iio.c b/drivers/iio/common/ssp_sensors/ssp_iio.c +index 645f2e3975db..e38f704d88b7 100644 +--- a/drivers/iio/common/ssp_sensors/ssp_iio.c ++++ b/drivers/iio/common/ssp_sensors/ssp_iio.c +@@ -81,7 +81,7 @@ int ssp_common_process_data(struct iio_dev *indio_dev, void *buf, + unsigned int len, int64_t timestamp) + { + __le32 time; +- int64_t calculated_time; ++ int64_t calculated_time = 0; + struct ssp_sensor_data *spd = iio_priv(indio_dev); + + if (indio_dev->scan_bytes == 0) +diff --git a/drivers/iio/magnetometer/hmc5843_i2c.c b/drivers/iio/magnetometer/hmc5843_i2c.c +index 3de7f4426ac4..86abba5827a2 100644 +--- a/drivers/iio/magnetometer/hmc5843_i2c.c ++++ b/drivers/iio/magnetometer/hmc5843_i2c.c +@@ -58,8 +58,13 @@ static const struct regmap_config hmc5843_i2c_regmap_config = { + static int hmc5843_i2c_probe(struct i2c_client *cli, + const struct i2c_device_id *id) + { ++ struct regmap *regmap = devm_regmap_init_i2c(cli, ++ &hmc5843_i2c_regmap_config); ++ if (IS_ERR(regmap)) ++ return PTR_ERR(regmap); ++ + return hmc5843_common_probe(&cli->dev, +- devm_regmap_init_i2c(cli, &hmc5843_i2c_regmap_config), ++ regmap, + id->driver_data, id->name); + } + +diff --git a/drivers/iio/magnetometer/hmc5843_spi.c b/drivers/iio/magnetometer/hmc5843_spi.c +index 535f03a70d63..79b2b707f90e 100644 +--- a/drivers/iio/magnetometer/hmc5843_spi.c ++++ b/drivers/iio/magnetometer/hmc5843_spi.c +@@ -58,6 +58,7 @@ static const struct regmap_config hmc5843_spi_regmap_config = { + static int hmc5843_spi_probe(struct spi_device *spi) + { + int ret; ++ struct regmap *regmap; + const struct spi_device_id *id = spi_get_device_id(spi); + + spi->mode = SPI_MODE_3; +@@ -67,8 +68,12 @@ static int hmc5843_spi_probe(struct spi_device *spi) + if (ret) + return ret; + ++ regmap = devm_regmap_init_spi(spi, &hmc5843_spi_regmap_config); ++ if (IS_ERR(regmap)) ++ return PTR_ERR(regmap); ++ + return hmc5843_common_probe(&spi->dev, +- devm_regmap_init_spi(spi, &hmc5843_spi_regmap_config), ++ regmap, + id->driver_data, id->name); + } + +diff --git a/drivers/infiniband/core/cma.c b/drivers/infiniband/core/cma.c +index 6f5be7802476..39dc7be56884 100644 +--- a/drivers/infiniband/core/cma.c ++++ b/drivers/infiniband/core/cma.c +@@ -1078,18 +1078,31 @@ static inline bool cma_any_addr(const struct sockaddr *addr) + return cma_zero_addr(addr) || cma_loopback_addr(addr); + } + +-static int cma_addr_cmp(struct sockaddr *src, struct sockaddr *dst) ++static int cma_addr_cmp(const struct sockaddr *src, const struct sockaddr *dst) + { + if (src->sa_family != dst->sa_family) + return -1; + + switch (src->sa_family) { + case AF_INET: +- return ((struct sockaddr_in *) src)->sin_addr.s_addr != +- ((struct sockaddr_in *) dst)->sin_addr.s_addr; +- case AF_INET6: +- return ipv6_addr_cmp(&((struct sockaddr_in6 *) src)->sin6_addr, +- &((struct sockaddr_in6 *) dst)->sin6_addr); ++ return ((struct sockaddr_in *)src)->sin_addr.s_addr != ++ ((struct sockaddr_in *)dst)->sin_addr.s_addr; ++ case AF_INET6: { ++ struct sockaddr_in6 *src_addr6 = (struct sockaddr_in6 *)src; ++ struct sockaddr_in6 *dst_addr6 = (struct sockaddr_in6 *)dst; ++ bool link_local; ++ ++ if (ipv6_addr_cmp(&src_addr6->sin6_addr, ++ &dst_addr6->sin6_addr)) ++ return 1; ++ link_local = ipv6_addr_type(&dst_addr6->sin6_addr) & ++ IPV6_ADDR_LINKLOCAL; ++ /* Link local must match their scope_ids */ ++ return link_local ? (src_addr6->sin6_scope_id != ++ dst_addr6->sin6_scope_id) : ++ 0; ++ } ++ + default: + return ib_addr_cmp(&((struct sockaddr_ib *) src)->sib_addr, + &((struct sockaddr_ib *) dst)->sib_addr); +diff --git a/drivers/infiniband/hw/cxgb4/cm.c b/drivers/infiniband/hw/cxgb4/cm.c +index a68569ec86bf..3be6405d9855 100644 +--- a/drivers/infiniband/hw/cxgb4/cm.c ++++ b/drivers/infiniband/hw/cxgb4/cm.c +@@ -458,6 +458,8 @@ static struct sk_buff *get_skb(struct sk_buff *skb, int len, gfp_t gfp) + skb_reset_transport_header(skb); + } else { + skb = alloc_skb(len, gfp); ++ if (!skb) ++ return NULL; + } + t4_set_arp_err_handler(skb, NULL, NULL); + return skb; +diff --git a/drivers/infiniband/hw/hfi1/init.c b/drivers/infiniband/hw/hfi1/init.c +index da786eb18558..368f4f08b686 100644 +--- a/drivers/infiniband/hw/hfi1/init.c ++++ b/drivers/infiniband/hw/hfi1/init.c +@@ -798,7 +798,8 @@ static int create_workqueues(struct hfi1_devdata *dd) + ppd->hfi1_wq = + alloc_workqueue( + "hfi%d_%d", +- WQ_SYSFS | WQ_HIGHPRI | WQ_CPU_INTENSIVE, ++ WQ_SYSFS | WQ_HIGHPRI | WQ_CPU_INTENSIVE | ++ WQ_MEM_RECLAIM, + HFI1_MAX_ACTIVE_WORKQUEUE_ENTRIES, + dd->unit, pidx); + if (!ppd->hfi1_wq) +diff --git a/drivers/infiniband/hw/hns/hns_roce_ah.c b/drivers/infiniband/hw/hns/hns_roce_ah.c +index 0d96c5bb38cd..d2d4ab9ab071 100644 +--- a/drivers/infiniband/hw/hns/hns_roce_ah.c ++++ b/drivers/infiniband/hw/hns/hns_roce_ah.c +@@ -66,7 +66,7 @@ struct ib_ah *hns_roce_create_ah(struct ib_pd *ibpd, + HNS_ROCE_VLAN_SL_BIT_MASK) << + HNS_ROCE_VLAN_SL_SHIFT; + +- ah->av.port_pd = cpu_to_be32(to_hr_pd(ibpd)->pdn | ++ ah->av.port_pd = cpu_to_le32(to_hr_pd(ibpd)->pdn | + (rdma_ah_get_port_num(ah_attr) << + HNS_ROCE_PORT_NUM_SHIFT)); + ah->av.gid_index = grh->sgid_index; +diff --git a/drivers/md/bcache/alloc.c b/drivers/md/bcache/alloc.c +index 7a28232d868b..de85b3af3b39 100644 +--- a/drivers/md/bcache/alloc.c ++++ b/drivers/md/bcache/alloc.c +@@ -327,10 +327,11 @@ static int bch_allocator_thread(void *arg) + * possibly issue discards to them, then we add the bucket to + * the free list: + */ +- while (!fifo_empty(&ca->free_inc)) { ++ while (1) { + long bucket; + +- fifo_pop(&ca->free_inc, bucket); ++ if (!fifo_pop(&ca->free_inc, bucket)) ++ break; + + if (ca->discard) { + mutex_unlock(&ca->set->bucket_lock); +diff --git a/drivers/md/bcache/journal.c b/drivers/md/bcache/journal.c +index 772258ee1f51..f880e5eba8dd 100644 +--- a/drivers/md/bcache/journal.c ++++ b/drivers/md/bcache/journal.c +@@ -317,6 +317,18 @@ void bch_journal_mark(struct cache_set *c, struct list_head *list) + } + } + ++bool is_discard_enabled(struct cache_set *s) ++{ ++ struct cache *ca; ++ unsigned int i; ++ ++ for_each_cache(ca, s, i) ++ if (ca->discard) ++ return true; ++ ++ return false; ++} ++ + int bch_journal_replay(struct cache_set *s, struct list_head *list) + { + int ret = 0, keys = 0, entries = 0; +@@ -330,9 +342,17 @@ int bch_journal_replay(struct cache_set *s, struct list_head *list) + list_for_each_entry(i, list, list) { + BUG_ON(i->pin && atomic_read(i->pin) != 1); + +- cache_set_err_on(n != i->j.seq, s, +-"bcache: journal entries %llu-%llu missing! (replaying %llu-%llu)", +- n, i->j.seq - 1, start, end); ++ if (n != i->j.seq) { ++ if (n == start && is_discard_enabled(s)) ++ pr_info("bcache: journal entries %llu-%llu may be discarded! (replaying %llu-%llu)", ++ n, i->j.seq - 1, start, end); ++ else { ++ pr_err("bcache: journal entries %llu-%llu missing! (replaying %llu-%llu)", ++ n, i->j.seq - 1, start, end); ++ ret = -EIO; ++ goto err; ++ } ++ } + + for (k = i->j.start; + k < bset_bkey_last(&i->j); +diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c +index 2c0d35c882ed..2409507d7bff 100644 +--- a/drivers/md/bcache/super.c ++++ b/drivers/md/bcache/super.c +@@ -1770,13 +1770,15 @@ err: + return NULL; + } + +-static void run_cache_set(struct cache_set *c) ++static int run_cache_set(struct cache_set *c) + { + const char *err = "cannot allocate memory"; + struct cached_dev *dc, *t; + struct cache *ca; + struct closure cl; + unsigned int i; ++ LIST_HEAD(journal); ++ struct journal_replay *l; + + closure_init_stack(&cl); + +@@ -1864,7 +1866,9 @@ static void run_cache_set(struct cache_set *c) + if (j->version < BCACHE_JSET_VERSION_UUID) + __uuid_write(c); + +- bch_journal_replay(c, &journal); ++ err = "bcache: replay journal failed"; ++ if (bch_journal_replay(c, &journal)) ++ goto err; + } else { + pr_notice("invalidating existing data"); + +@@ -1932,11 +1936,19 @@ static void run_cache_set(struct cache_set *c) + flash_devs_run(c); + + set_bit(CACHE_SET_RUNNING, &c->flags); +- return; ++ return 0; + err: ++ while (!list_empty(&journal)) { ++ l = list_first_entry(&journal, struct journal_replay, list); ++ list_del(&l->list); ++ kfree(l); ++ } ++ + closure_sync(&cl); + /* XXX: test this, it's broken */ + bch_cache_set_error(c, "%s", err); ++ ++ return -EIO; + } + + static bool can_attach_cache(struct cache *ca, struct cache_set *c) +@@ -2000,8 +2012,11 @@ found: + ca->set->cache[ca->sb.nr_this_dev] = ca; + c->cache_by_alloc[c->caches_loaded++] = ca; + +- if (c->caches_loaded == c->sb.nr_in_set) +- run_cache_set(c); ++ if (c->caches_loaded == c->sb.nr_in_set) { ++ err = "failed to run cache set"; ++ if (run_cache_set(c) < 0) ++ goto err; ++ } + + return NULL; + err: +diff --git a/drivers/media/common/videobuf2/videobuf2-core.c b/drivers/media/common/videobuf2/videobuf2-core.c +index 6889c25c62cb..9226dca44e90 100644 +--- a/drivers/media/common/videobuf2/videobuf2-core.c ++++ b/drivers/media/common/videobuf2/videobuf2-core.c +@@ -668,6 +668,11 @@ int vb2_core_reqbufs(struct vb2_queue *q, enum vb2_memory memory, + return -EBUSY; + } + ++ if (q->waiting_in_dqbuf && *count) { ++ dprintk(1, "another dup()ped fd is waiting for a buffer\n"); ++ return -EBUSY; ++ } ++ + if (*count == 0 || q->num_buffers != 0 || + (q->memory != VB2_MEMORY_UNKNOWN && q->memory != memory)) { + /* +@@ -797,6 +802,10 @@ int vb2_core_create_bufs(struct vb2_queue *q, enum vb2_memory memory, + } + + if (!q->num_buffers) { ++ if (q->waiting_in_dqbuf && *count) { ++ dprintk(1, "another dup()ped fd is waiting for a buffer\n"); ++ return -EBUSY; ++ } + memset(q->alloc_devs, 0, sizeof(q->alloc_devs)); + q->memory = memory; + q->waiting_for_buffers = !q->is_output; +@@ -1466,6 +1475,11 @@ static int __vb2_wait_for_done_vb(struct vb2_queue *q, int nonblocking) + for (;;) { + int ret; + ++ if (q->waiting_in_dqbuf) { ++ dprintk(1, "another dup()ped fd is waiting for a buffer\n"); ++ return -EBUSY; ++ } ++ + if (!q->streaming) { + dprintk(1, "streaming off, will not wait for buffers\n"); + return -EINVAL; +@@ -1493,6 +1507,7 @@ static int __vb2_wait_for_done_vb(struct vb2_queue *q, int nonblocking) + return -EAGAIN; + } + ++ q->waiting_in_dqbuf = 1; + /* + * We are streaming and blocking, wait for another buffer to + * become ready or for streamoff. Driver's lock is released to +@@ -1513,6 +1528,7 @@ static int __vb2_wait_for_done_vb(struct vb2_queue *q, int nonblocking) + * the locks or return an error if one occurred. + */ + call_void_qop(q, wait_finish, q); ++ q->waiting_in_dqbuf = 0; + if (ret) { + dprintk(1, "sleep was interrupted\n"); + return ret; +@@ -2361,6 +2377,12 @@ static size_t __vb2_perform_fileio(struct vb2_queue *q, char __user *data, size_ + if (!data) + return -EINVAL; + ++ if (q->waiting_in_dqbuf) { ++ dprintk(3, "another dup()ped fd is %s\n", ++ read ? "reading" : "writing"); ++ return -EBUSY; ++ } ++ + /* + * Initialize emulator on first call. + */ +diff --git a/drivers/media/dvb-frontends/m88ds3103.c b/drivers/media/dvb-frontends/m88ds3103.c +index dffd2d4bf1c8..c25c92797408 100644 +--- a/drivers/media/dvb-frontends/m88ds3103.c ++++ b/drivers/media/dvb-frontends/m88ds3103.c +@@ -309,6 +309,9 @@ static int m88ds3103_set_frontend(struct dvb_frontend *fe) + u16 u16tmp; + u32 tuner_frequency_khz, target_mclk; + s32 s32tmp; ++ static const struct reg_sequence reset_buf[] = { ++ {0x07, 0x80}, {0x07, 0x00} ++ }; + + dev_dbg(&client->dev, + "delivery_system=%d modulation=%d frequency=%u symbol_rate=%d inversion=%d pilot=%d rolloff=%d\n", +@@ -321,11 +324,7 @@ static int m88ds3103_set_frontend(struct dvb_frontend *fe) + } + + /* reset */ +- ret = regmap_write(dev->regmap, 0x07, 0x80); +- if (ret) +- goto err; +- +- ret = regmap_write(dev->regmap, 0x07, 0x00); ++ ret = regmap_multi_reg_write(dev->regmap, reset_buf, 2); + if (ret) + goto err; + +diff --git a/drivers/media/dvb-frontends/si2165.c b/drivers/media/dvb-frontends/si2165.c +index feacd8da421d..d55d8f169dca 100644 +--- a/drivers/media/dvb-frontends/si2165.c ++++ b/drivers/media/dvb-frontends/si2165.c +@@ -275,18 +275,20 @@ static u32 si2165_get_fe_clk(struct si2165_state *state) + + static int si2165_wait_init_done(struct si2165_state *state) + { +- int ret = -EINVAL; ++ int ret; + u8 val = 0; + int i; + + for (i = 0; i < 3; ++i) { +- si2165_readreg8(state, REG_INIT_DONE, &val); ++ ret = si2165_readreg8(state, REG_INIT_DONE, &val); ++ if (ret < 0) ++ return ret; + if (val == 0x01) + return 0; + usleep_range(1000, 50000); + } + dev_err(&state->client->dev, "init_done was not set\n"); +- return ret; ++ return -EINVAL; + } + + static int si2165_upload_firmware_block(struct si2165_state *state, +diff --git a/drivers/media/i2c/ov2659.c b/drivers/media/i2c/ov2659.c +index 4715edc8ca33..e6a8b5669b9c 100644 +--- a/drivers/media/i2c/ov2659.c ++++ b/drivers/media/i2c/ov2659.c +@@ -1117,8 +1117,10 @@ static int ov2659_set_fmt(struct v4l2_subdev *sd, + if (ov2659_formats[index].code == mf->code) + break; + +- if (index < 0) +- return -EINVAL; ++ if (index < 0) { ++ index = 0; ++ mf->code = ov2659_formats[index].code; ++ } + + mf->colorspace = V4L2_COLORSPACE_SRGB; + mf->field = V4L2_FIELD_NONE; +diff --git a/drivers/media/i2c/ov6650.c b/drivers/media/i2c/ov6650.c +index a9264d515e54..edded869d792 100644 +--- a/drivers/media/i2c/ov6650.c ++++ b/drivers/media/i2c/ov6650.c +@@ -811,9 +811,16 @@ static int ov6650_video_probe(struct i2c_client *client) + u8 pidh, pidl, midh, midl; + int ret; + ++ priv->clk = v4l2_clk_get(&client->dev, NULL); ++ if (IS_ERR(priv->clk)) { ++ ret = PTR_ERR(priv->clk); ++ dev_err(&client->dev, "v4l2_clk request err: %d\n", ret); ++ return ret; ++ } ++ + ret = ov6650_s_power(&priv->subdev, 1); + if (ret < 0) +- return ret; ++ goto eclkput; + + msleep(20); + +@@ -850,6 +857,11 @@ static int ov6650_video_probe(struct i2c_client *client) + + done: + ov6650_s_power(&priv->subdev, 0); ++ if (!ret) ++ return 0; ++eclkput: ++ v4l2_clk_put(priv->clk); ++ + return ret; + } + +@@ -992,18 +1004,9 @@ static int ov6650_probe(struct i2c_client *client, + priv->code = MEDIA_BUS_FMT_YUYV8_2X8; + priv->colorspace = V4L2_COLORSPACE_JPEG; + +- priv->clk = v4l2_clk_get(&client->dev, NULL); +- if (IS_ERR(priv->clk)) { +- ret = PTR_ERR(priv->clk); +- goto eclkget; +- } +- + ret = ov6650_video_probe(client); +- if (ret) { +- v4l2_clk_put(priv->clk); +-eclkget: ++ if (ret) + v4l2_ctrl_handler_free(&priv->hdl); +- } + + return ret; + } +diff --git a/drivers/media/pci/saa7146/hexium_gemini.c b/drivers/media/pci/saa7146/hexium_gemini.c +index 5817d9cde4d0..6d8e4afe9673 100644 +--- a/drivers/media/pci/saa7146/hexium_gemini.c ++++ b/drivers/media/pci/saa7146/hexium_gemini.c +@@ -270,9 +270,8 @@ static int hexium_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_d + /* enable i2c-port pins */ + saa7146_write(dev, MC1, (MASK_08 | MASK_24 | MASK_10 | MASK_26)); + +- hexium->i2c_adapter = (struct i2c_adapter) { +- .name = "hexium gemini", +- }; ++ strscpy(hexium->i2c_adapter.name, "hexium gemini", ++ sizeof(hexium->i2c_adapter.name)); + saa7146_i2c_adapter_prepare(dev, &hexium->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480); + if (i2c_add_adapter(&hexium->i2c_adapter) < 0) { + DEB_S("cannot register i2c-device. skipping.\n"); +diff --git a/drivers/media/pci/saa7146/hexium_orion.c b/drivers/media/pci/saa7146/hexium_orion.c +index 0a05176c18ab..a794f9e5f990 100644 +--- a/drivers/media/pci/saa7146/hexium_orion.c ++++ b/drivers/media/pci/saa7146/hexium_orion.c +@@ -231,9 +231,8 @@ static int hexium_probe(struct saa7146_dev *dev) + saa7146_write(dev, DD1_STREAM_B, 0x00000000); + saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26)); + +- hexium->i2c_adapter = (struct i2c_adapter) { +- .name = "hexium orion", +- }; ++ strscpy(hexium->i2c_adapter.name, "hexium orion", ++ sizeof(hexium->i2c_adapter.name)); + saa7146_i2c_adapter_prepare(dev, &hexium->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480); + if (i2c_add_adapter(&hexium->i2c_adapter) < 0) { + DEB_S("cannot register i2c-device. skipping.\n"); +diff --git a/drivers/media/platform/coda/coda-bit.c b/drivers/media/platform/coda/coda-bit.c +index d20d3df5778b..a3cfefdbee12 100644 +--- a/drivers/media/platform/coda/coda-bit.c ++++ b/drivers/media/platform/coda/coda-bit.c +@@ -1999,6 +1999,9 @@ static int coda_prepare_decode(struct coda_ctx *ctx) + /* Clear decode success flag */ + coda_write(dev, 0, CODA_RET_DEC_PIC_SUCCESS); + ++ /* Clear error return value */ ++ coda_write(dev, 0, CODA_RET_DEC_PIC_ERR_MB); ++ + trace_coda_dec_pic_run(ctx, meta); + + coda_command_async(ctx, CODA_COMMAND_PIC_RUN); +diff --git a/drivers/media/platform/stm32/stm32-dcmi.c b/drivers/media/platform/stm32/stm32-dcmi.c +index 721564176d8c..d38682265892 100644 +--- a/drivers/media/platform/stm32/stm32-dcmi.c ++++ b/drivers/media/platform/stm32/stm32-dcmi.c +@@ -808,6 +808,9 @@ static int dcmi_try_fmt(struct stm32_dcmi *dcmi, struct v4l2_format *f, + + sd_fmt = find_format_by_fourcc(dcmi, pix->pixelformat); + if (!sd_fmt) { ++ if (!dcmi->num_of_sd_formats) ++ return -ENODATA; ++ + sd_fmt = dcmi->sd_formats[dcmi->num_of_sd_formats - 1]; + pix->pixelformat = sd_fmt->fourcc; + } +@@ -986,6 +989,9 @@ static int dcmi_set_sensor_format(struct stm32_dcmi *dcmi, + + sd_fmt = find_format_by_fourcc(dcmi, pix->pixelformat); + if (!sd_fmt) { ++ if (!dcmi->num_of_sd_formats) ++ return -ENODATA; ++ + sd_fmt = dcmi->sd_formats[dcmi->num_of_sd_formats - 1]; + pix->pixelformat = sd_fmt->fourcc; + } +@@ -1645,7 +1651,7 @@ static int dcmi_probe(struct platform_device *pdev) + dcmi->rstc = devm_reset_control_get_exclusive(&pdev->dev, NULL); + if (IS_ERR(dcmi->rstc)) { + dev_err(&pdev->dev, "Could not get reset control\n"); +- return -ENODEV; ++ return PTR_ERR(dcmi->rstc); + } + + /* Get bus characteristics from devicetree */ +@@ -1660,7 +1666,7 @@ static int dcmi_probe(struct platform_device *pdev) + of_node_put(np); + if (ret) { + dev_err(&pdev->dev, "Could not parse the endpoint\n"); +- return -ENODEV; ++ return ret; + } + + if (ep.bus_type == V4L2_MBUS_CSI2) { +@@ -1673,8 +1679,9 @@ static int dcmi_probe(struct platform_device *pdev) + + irq = platform_get_irq(pdev, 0); + if (irq <= 0) { +- dev_err(&pdev->dev, "Could not get irq\n"); +- return -ENODEV; ++ if (irq != -EPROBE_DEFER) ++ dev_err(&pdev->dev, "Could not get irq\n"); ++ return irq; + } + + dcmi->res = platform_get_resource(pdev, IORESOURCE_MEM, 0); +@@ -1694,12 +1701,13 @@ static int dcmi_probe(struct platform_device *pdev) + dev_name(&pdev->dev), dcmi); + if (ret) { + dev_err(&pdev->dev, "Unable to request irq %d\n", irq); +- return -ENODEV; ++ return ret; + } + + mclk = devm_clk_get(&pdev->dev, "mclk"); + if (IS_ERR(mclk)) { +- dev_err(&pdev->dev, "Unable to get mclk\n"); ++ if (PTR_ERR(mclk) != -EPROBE_DEFER) ++ dev_err(&pdev->dev, "Unable to get mclk\n"); + return PTR_ERR(mclk); + } + +diff --git a/drivers/media/platform/video-mux.c b/drivers/media/platform/video-mux.c +index c01e1592ad0a..c8ffe7bff77f 100644 +--- a/drivers/media/platform/video-mux.c ++++ b/drivers/media/platform/video-mux.c +@@ -365,9 +365,14 @@ static int video_mux_probe(struct platform_device *pdev) + vmux->active = -1; + vmux->pads = devm_kcalloc(dev, num_pads, sizeof(*vmux->pads), + GFP_KERNEL); ++ if (!vmux->pads) ++ return -ENOMEM; ++ + vmux->format_mbus = devm_kcalloc(dev, num_pads, + sizeof(*vmux->format_mbus), + GFP_KERNEL); ++ if (!vmux->format_mbus) ++ return -ENOMEM; + + for (i = 0; i < num_pads; i++) { + vmux->pads[i].flags = (i < num_pads - 1) ? MEDIA_PAD_FL_SINK +diff --git a/drivers/media/platform/vimc/vimc-core.c b/drivers/media/platform/vimc/vimc-core.c +index 9246f265de31..27db8835c241 100644 +--- a/drivers/media/platform/vimc/vimc-core.c ++++ b/drivers/media/platform/vimc/vimc-core.c +@@ -303,6 +303,8 @@ static int vimc_probe(struct platform_device *pdev) + + dev_dbg(&pdev->dev, "probe"); + ++ memset(&vimc->mdev, 0, sizeof(vimc->mdev)); ++ + /* Create platform_device for each entity in the topology*/ + vimc->subdevs = devm_kcalloc(&vimc->pdev.dev, vimc->pipe_cfg->num_ents, + sizeof(*vimc->subdevs), GFP_KERNEL); +diff --git a/drivers/media/platform/vimc/vimc-streamer.c b/drivers/media/platform/vimc/vimc-streamer.c +index fcc897fb247b..392754c18046 100644 +--- a/drivers/media/platform/vimc/vimc-streamer.c ++++ b/drivers/media/platform/vimc/vimc-streamer.c +@@ -120,7 +120,6 @@ static int vimc_streamer_thread(void *data) + int i; + + set_freezable(); +- set_current_state(TASK_UNINTERRUPTIBLE); + + for (;;) { + try_to_freeze(); +@@ -137,6 +136,7 @@ static int vimc_streamer_thread(void *data) + break; + } + //wait for 60hz ++ set_current_state(TASK_UNINTERRUPTIBLE); + schedule_timeout(HZ / 60); + } + +diff --git a/drivers/media/platform/vivid/vivid-vid-cap.c b/drivers/media/platform/vivid/vivid-vid-cap.c +index baa7c83ee6e0..3b09ffceefd5 100644 +--- a/drivers/media/platform/vivid/vivid-vid-cap.c ++++ b/drivers/media/platform/vivid/vivid-vid-cap.c +@@ -992,7 +992,7 @@ int vivid_vid_cap_s_selection(struct file *file, void *fh, struct v4l2_selection + v4l2_rect_map_inside(&s->r, &dev->fmt_cap_rect); + if (dev->bitmap_cap && (compose->width != s->r.width || + compose->height != s->r.height)) { +- kfree(dev->bitmap_cap); ++ vfree(dev->bitmap_cap); + dev->bitmap_cap = NULL; + } + *compose = s->r; +diff --git a/drivers/media/radio/wl128x/fmdrv_common.c b/drivers/media/radio/wl128x/fmdrv_common.c +index 800d69c3f80b..1cf4019689a5 100644 +--- a/drivers/media/radio/wl128x/fmdrv_common.c ++++ b/drivers/media/radio/wl128x/fmdrv_common.c +@@ -489,7 +489,8 @@ int fmc_send_cmd(struct fmdev *fmdev, u8 fm_op, u16 type, void *payload, + return -EIO; + } + /* Send response data to caller */ +- if (response != NULL && response_len != NULL && evt_hdr->dlen) { ++ if (response != NULL && response_len != NULL && evt_hdr->dlen && ++ evt_hdr->dlen <= payload_len) { + /* Skip header info and copy only response data */ + skb_pull(skb, sizeof(struct fm_event_msg_hdr)); + memcpy(response, skb->data, evt_hdr->dlen); +@@ -583,6 +584,8 @@ static void fm_irq_handle_flag_getcmd_resp(struct fmdev *fmdev) + return; + + fm_evt_hdr = (void *)skb->data; ++ if (fm_evt_hdr->dlen > sizeof(fmdev->irq_info.flag)) ++ return; + + /* Skip header info and copy only response data */ + skb_pull(skb, sizeof(struct fm_event_msg_hdr)); +@@ -1308,7 +1311,7 @@ static int load_default_rx_configuration(struct fmdev *fmdev) + static int fm_power_up(struct fmdev *fmdev, u8 mode) + { + u16 payload; +- __be16 asic_id, asic_ver; ++ __be16 asic_id = 0, asic_ver = 0; + int resp_len, ret; + u8 fw_name[50]; + +diff --git a/drivers/media/rc/serial_ir.c b/drivers/media/rc/serial_ir.c +index 8bf5637b3a69..e613c0175591 100644 +--- a/drivers/media/rc/serial_ir.c ++++ b/drivers/media/rc/serial_ir.c +@@ -773,8 +773,6 @@ static void serial_ir_exit(void) + + static int __init serial_ir_init_module(void) + { +- int result; +- + switch (type) { + case IR_HOMEBREW: + case IR_IRDEO: +@@ -802,12 +800,7 @@ static int __init serial_ir_init_module(void) + if (sense != -1) + sense = !!sense; + +- result = serial_ir_init(); +- if (!result) +- return 0; +- +- serial_ir_exit(); +- return result; ++ return serial_ir_init(); + } + + static void __exit serial_ir_exit_module(void) +diff --git a/drivers/media/usb/au0828/au0828-video.c b/drivers/media/usb/au0828/au0828-video.c +index 62b45062b1e6..3e111f7f56df 100644 +--- a/drivers/media/usb/au0828/au0828-video.c ++++ b/drivers/media/usb/au0828/au0828-video.c +@@ -758,6 +758,9 @@ static int au0828_analog_stream_enable(struct au0828_dev *d) + + dprintk(1, "au0828_analog_stream_enable called\n"); + ++ if (test_bit(DEV_DISCONNECTED, &d->dev_state)) ++ return -ENODEV; ++ + iface = usb_ifnum_to_if(d->usbdev, 0); + if (iface && iface->cur_altsetting->desc.bAlternateSetting != 5) { + dprintk(1, "Changing intf#0 to alt 5\n"); +@@ -839,9 +842,9 @@ int au0828_start_analog_streaming(struct vb2_queue *vq, unsigned int count) + return rc; + } + ++ v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 1); ++ + if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { +- v4l2_device_call_all(&dev->v4l2_dev, 0, video, +- s_stream, 1); + dev->vid_timeout_running = 1; + mod_timer(&dev->vid_timeout, jiffies + (HZ / 10)); + } else if (vq->type == V4L2_BUF_TYPE_VBI_CAPTURE) { +@@ -861,10 +864,11 @@ static void au0828_stop_streaming(struct vb2_queue *vq) + + dprintk(1, "au0828_stop_streaming called %d\n", dev->streaming_users); + +- if (dev->streaming_users-- == 1) ++ if (dev->streaming_users-- == 1) { + au0828_uninit_isoc(dev); ++ v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0); ++ } + +- v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0); + dev->vid_timeout_running = 0; + del_timer_sync(&dev->vid_timeout); + +@@ -893,8 +897,10 @@ void au0828_stop_vbi_streaming(struct vb2_queue *vq) + dprintk(1, "au0828_stop_vbi_streaming called %d\n", + dev->streaming_users); + +- if (dev->streaming_users-- == 1) ++ if (dev->streaming_users-- == 1) { + au0828_uninit_isoc(dev); ++ v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0); ++ } + + spin_lock_irqsave(&dev->slock, flags); + if (dev->isoc_ctl.vbi_buf != NULL) { +diff --git a/drivers/media/usb/cpia2/cpia2_v4l.c b/drivers/media/usb/cpia2/cpia2_v4l.c +index 99f106b13280..d47318958fe5 100644 +--- a/drivers/media/usb/cpia2/cpia2_v4l.c ++++ b/drivers/media/usb/cpia2/cpia2_v4l.c +@@ -1244,8 +1244,7 @@ static int __init cpia2_init(void) + LOG("%s v%s\n", + ABOUT, CPIA_VERSION); + check_parameters(); +- cpia2_usb_init(); +- return 0; ++ return cpia2_usb_init(); + } + + +diff --git a/drivers/media/usb/dvb-usb-v2/dvbsky.c b/drivers/media/usb/dvb-usb-v2/dvbsky.c +index e28bd8836751..ae0814dd202a 100644 +--- a/drivers/media/usb/dvb-usb-v2/dvbsky.c ++++ b/drivers/media/usb/dvb-usb-v2/dvbsky.c +@@ -615,16 +615,18 @@ static int dvbsky_init(struct dvb_usb_device *d) + return 0; + } + +-static void dvbsky_exit(struct dvb_usb_device *d) ++static int dvbsky_frontend_detach(struct dvb_usb_adapter *adap) + { ++ struct dvb_usb_device *d = adap_to_d(adap); + struct dvbsky_state *state = d_to_priv(d); +- struct dvb_usb_adapter *adap = &d->adapter[0]; ++ ++ dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, adap->id); + + dvb_module_release(state->i2c_client_tuner); + dvb_module_release(state->i2c_client_demod); + dvb_module_release(state->i2c_client_ci); + +- adap->fe[0] = NULL; ++ return 0; + } + + /* DVB USB Driver stuff */ +@@ -640,11 +642,11 @@ static struct dvb_usb_device_properties dvbsky_s960_props = { + + .i2c_algo = &dvbsky_i2c_algo, + .frontend_attach = dvbsky_s960_attach, ++ .frontend_detach = dvbsky_frontend_detach, + .init = dvbsky_init, + .get_rc_config = dvbsky_get_rc_config, + .streaming_ctrl = dvbsky_streaming_ctrl, + .identify_state = dvbsky_identify_state, +- .exit = dvbsky_exit, + .read_mac_address = dvbsky_read_mac_addr, + + .num_adapters = 1, +@@ -667,11 +669,11 @@ static struct dvb_usb_device_properties dvbsky_s960c_props = { + + .i2c_algo = &dvbsky_i2c_algo, + .frontend_attach = dvbsky_s960c_attach, ++ .frontend_detach = dvbsky_frontend_detach, + .init = dvbsky_init, + .get_rc_config = dvbsky_get_rc_config, + .streaming_ctrl = dvbsky_streaming_ctrl, + .identify_state = dvbsky_identify_state, +- .exit = dvbsky_exit, + .read_mac_address = dvbsky_read_mac_addr, + + .num_adapters = 1, +@@ -694,11 +696,11 @@ static struct dvb_usb_device_properties dvbsky_t680c_props = { + + .i2c_algo = &dvbsky_i2c_algo, + .frontend_attach = dvbsky_t680c_attach, ++ .frontend_detach = dvbsky_frontend_detach, + .init = dvbsky_init, + .get_rc_config = dvbsky_get_rc_config, + .streaming_ctrl = dvbsky_streaming_ctrl, + .identify_state = dvbsky_identify_state, +- .exit = dvbsky_exit, + .read_mac_address = dvbsky_read_mac_addr, + + .num_adapters = 1, +@@ -721,11 +723,11 @@ static struct dvb_usb_device_properties dvbsky_t330_props = { + + .i2c_algo = &dvbsky_i2c_algo, + .frontend_attach = dvbsky_t330_attach, ++ .frontend_detach = dvbsky_frontend_detach, + .init = dvbsky_init, + .get_rc_config = dvbsky_get_rc_config, + .streaming_ctrl = dvbsky_streaming_ctrl, + .identify_state = dvbsky_identify_state, +- .exit = dvbsky_exit, + .read_mac_address = dvbsky_read_mac_addr, + + .num_adapters = 1, +@@ -748,11 +750,11 @@ static struct dvb_usb_device_properties mygica_t230c_props = { + + .i2c_algo = &dvbsky_i2c_algo, + .frontend_attach = dvbsky_mygica_t230c_attach, ++ .frontend_detach = dvbsky_frontend_detach, + .init = dvbsky_init, + .get_rc_config = dvbsky_get_rc_config, + .streaming_ctrl = dvbsky_streaming_ctrl, + .identify_state = dvbsky_identify_state, +- .exit = dvbsky_exit, + + .num_adapters = 1, + .adapter = { +diff --git a/drivers/media/usb/go7007/go7007-fw.c b/drivers/media/usb/go7007/go7007-fw.c +index 24f5b615dc7a..dfa9f899d0c2 100644 +--- a/drivers/media/usb/go7007/go7007-fw.c ++++ b/drivers/media/usb/go7007/go7007-fw.c +@@ -1499,8 +1499,8 @@ static int modet_to_package(struct go7007 *go, __le16 *code, int space) + return cnt; + } + +-static int do_special(struct go7007 *go, u16 type, __le16 *code, int space, +- int *framelen) ++static noinline_for_stack int do_special(struct go7007 *go, u16 type, ++ __le16 *code, int space, int *framelen) + { + switch (type) { + case SPECIAL_FRM_HEAD: +diff --git a/drivers/media/usb/gspca/gspca.c b/drivers/media/usb/gspca/gspca.c +index 405a6a76d820..b12356c533a6 100644 +--- a/drivers/media/usb/gspca/gspca.c ++++ b/drivers/media/usb/gspca/gspca.c +@@ -294,7 +294,7 @@ static void fill_frame(struct gspca_dev *gspca_dev, + /* check the packet status and length */ + st = urb->iso_frame_desc[i].status; + if (st) { +- pr_err("ISOC data error: [%d] len=%d, status=%d\n", ++ gspca_dbg(gspca_dev, D_PACK, "ISOC data error: [%d] len=%d, status=%d\n", + i, len, st); + gspca_dev->last_packet_type = DISCARD_PACKET; + continue; +@@ -314,6 +314,8 @@ static void fill_frame(struct gspca_dev *gspca_dev, + } + + resubmit: ++ if (!gspca_dev->streaming) ++ return; + /* resubmit the URB */ + st = usb_submit_urb(urb, GFP_ATOMIC); + if (st < 0) +@@ -330,7 +332,7 @@ static void isoc_irq(struct urb *urb) + struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context; + + gspca_dbg(gspca_dev, D_PACK, "isoc irq\n"); +- if (!vb2_start_streaming_called(&gspca_dev->queue)) ++ if (!gspca_dev->streaming) + return; + fill_frame(gspca_dev, urb); + } +@@ -344,7 +346,7 @@ static void bulk_irq(struct urb *urb) + int st; + + gspca_dbg(gspca_dev, D_PACK, "bulk irq\n"); +- if (!vb2_start_streaming_called(&gspca_dev->queue)) ++ if (!gspca_dev->streaming) + return; + switch (urb->status) { + case 0: +@@ -367,6 +369,8 @@ static void bulk_irq(struct urb *urb) + urb->actual_length); + + resubmit: ++ if (!gspca_dev->streaming) ++ return; + /* resubmit the URB */ + if (gspca_dev->cam.bulk_nurbs != 0) { + st = usb_submit_urb(urb, GFP_ATOMIC); +@@ -1630,6 +1634,8 @@ void gspca_disconnect(struct usb_interface *intf) + + mutex_lock(&gspca_dev->usb_lock); + gspca_dev->present = false; ++ destroy_urbs(gspca_dev); ++ gspca_input_destroy_urb(gspca_dev); + + vb2_queue_error(&gspca_dev->queue); + +diff --git a/drivers/media/usb/pvrusb2/pvrusb2-hdw.c b/drivers/media/usb/pvrusb2/pvrusb2-hdw.c +index a8519da0020b..673fdca8d2da 100644 +--- a/drivers/media/usb/pvrusb2/pvrusb2-hdw.c ++++ b/drivers/media/usb/pvrusb2/pvrusb2-hdw.c +@@ -666,6 +666,8 @@ static int ctrl_get_input(struct pvr2_ctrl *cptr,int *vp) + + static int ctrl_check_input(struct pvr2_ctrl *cptr,int v) + { ++ if (v < 0 || v > PVR2_CVAL_INPUT_MAX) ++ return 0; + return ((1 << v) & cptr->hdw->input_allowed_mask) != 0; + } + +diff --git a/drivers/media/usb/pvrusb2/pvrusb2-hdw.h b/drivers/media/usb/pvrusb2/pvrusb2-hdw.h +index 25648add77e5..bd2b7a67b732 100644 +--- a/drivers/media/usb/pvrusb2/pvrusb2-hdw.h ++++ b/drivers/media/usb/pvrusb2/pvrusb2-hdw.h +@@ -50,6 +50,7 @@ + #define PVR2_CVAL_INPUT_COMPOSITE 2 + #define PVR2_CVAL_INPUT_SVIDEO 3 + #define PVR2_CVAL_INPUT_RADIO 4 ++#define PVR2_CVAL_INPUT_MAX PVR2_CVAL_INPUT_RADIO + + enum pvr2_config { + pvr2_config_empty, /* No configuration */ +diff --git a/drivers/mmc/core/pwrseq_emmc.c b/drivers/mmc/core/pwrseq_emmc.c +index efb8a7965dd4..154f4204d58c 100644 +--- a/drivers/mmc/core/pwrseq_emmc.c ++++ b/drivers/mmc/core/pwrseq_emmc.c +@@ -30,19 +30,14 @@ struct mmc_pwrseq_emmc { + + #define to_pwrseq_emmc(p) container_of(p, struct mmc_pwrseq_emmc, pwrseq) + +-static void __mmc_pwrseq_emmc_reset(struct mmc_pwrseq_emmc *pwrseq) +-{ +- gpiod_set_value(pwrseq->reset_gpio, 1); +- udelay(1); +- gpiod_set_value(pwrseq->reset_gpio, 0); +- udelay(200); +-} +- + static void mmc_pwrseq_emmc_reset(struct mmc_host *host) + { + struct mmc_pwrseq_emmc *pwrseq = to_pwrseq_emmc(host->pwrseq); + +- __mmc_pwrseq_emmc_reset(pwrseq); ++ gpiod_set_value_cansleep(pwrseq->reset_gpio, 1); ++ udelay(1); ++ gpiod_set_value_cansleep(pwrseq->reset_gpio, 0); ++ udelay(200); + } + + static int mmc_pwrseq_emmc_reset_nb(struct notifier_block *this, +@@ -50,8 +45,11 @@ static int mmc_pwrseq_emmc_reset_nb(struct notifier_block *this, + { + struct mmc_pwrseq_emmc *pwrseq = container_of(this, + struct mmc_pwrseq_emmc, reset_nb); ++ gpiod_set_value(pwrseq->reset_gpio, 1); ++ udelay(1); ++ gpiod_set_value(pwrseq->reset_gpio, 0); ++ udelay(200); + +- __mmc_pwrseq_emmc_reset(pwrseq); + return NOTIFY_DONE; + } + +@@ -72,14 +70,18 @@ static int mmc_pwrseq_emmc_probe(struct platform_device *pdev) + if (IS_ERR(pwrseq->reset_gpio)) + return PTR_ERR(pwrseq->reset_gpio); + +- /* +- * register reset handler to ensure emmc reset also from +- * emergency_reboot(), priority 255 is the highest priority +- * so it will be executed before any system reboot handler. +- */ +- pwrseq->reset_nb.notifier_call = mmc_pwrseq_emmc_reset_nb; +- pwrseq->reset_nb.priority = 255; +- register_restart_handler(&pwrseq->reset_nb); ++ if (!gpiod_cansleep(pwrseq->reset_gpio)) { ++ /* ++ * register reset handler to ensure emmc reset also from ++ * emergency_reboot(), priority 255 is the highest priority ++ * so it will be executed before any system reboot handler. ++ */ ++ pwrseq->reset_nb.notifier_call = mmc_pwrseq_emmc_reset_nb; ++ pwrseq->reset_nb.priority = 255; ++ register_restart_handler(&pwrseq->reset_nb); ++ } else { ++ dev_notice(dev, "EMMC reset pin tied to a sleepy GPIO driver; reset on emergency-reboot disabled\n"); ++ } + + pwrseq->pwrseq.ops = &mmc_pwrseq_emmc_ops; + pwrseq->pwrseq.dev = dev; +diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c +index d0d9f90e7cdf..cfb8ee24eaba 100644 +--- a/drivers/mmc/core/sd.c ++++ b/drivers/mmc/core/sd.c +@@ -216,6 +216,14 @@ static int mmc_decode_scr(struct mmc_card *card) + + if (scr->sda_spec3) + scr->cmds = UNSTUFF_BITS(resp, 32, 2); ++ ++ /* SD Spec says: any SD Card shall set at least bits 0 and 2 */ ++ if (!(scr->bus_widths & SD_SCR_BUS_WIDTH_1) || ++ !(scr->bus_widths & SD_SCR_BUS_WIDTH_4)) { ++ pr_err("%s: invalid bus width\n", mmc_hostname(card->host)); ++ return -EINVAL; ++ } ++ + return 0; + } + +diff --git a/drivers/mmc/host/mmc_spi.c b/drivers/mmc/host/mmc_spi.c +index 67f6bd24a9d0..ea254d00541f 100644 +--- a/drivers/mmc/host/mmc_spi.c ++++ b/drivers/mmc/host/mmc_spi.c +@@ -819,6 +819,10 @@ mmc_spi_readblock(struct mmc_spi_host *host, struct spi_transfer *t, + } + + status = spi_sync_locked(spi, &host->m); ++ if (status < 0) { ++ dev_dbg(&spi->dev, "read error %d\n", status); ++ return status; ++ } + + if (host->dma_dev) { + dma_sync_single_for_cpu(host->dma_dev, +diff --git a/drivers/mmc/host/sdhci-iproc.c b/drivers/mmc/host/sdhci-iproc.c +index 94eeed2a1b53..f903ab96aa21 100644 +--- a/drivers/mmc/host/sdhci-iproc.c ++++ b/drivers/mmc/host/sdhci-iproc.c +@@ -185,7 +185,8 @@ static const struct sdhci_ops sdhci_iproc_32only_ops = { + }; + + static const struct sdhci_pltfm_data sdhci_iproc_cygnus_pltfm_data = { +- .quirks = SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK, ++ .quirks = SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK | ++ SDHCI_QUIRK_NO_HISPD_BIT, + .quirks2 = SDHCI_QUIRK2_ACMD23_BROKEN | SDHCI_QUIRK2_HOST_OFF_CARD_ON, + .ops = &sdhci_iproc_32only_ops, + }; +@@ -208,7 +209,8 @@ static const struct sdhci_iproc_data iproc_cygnus_data = { + + static const struct sdhci_pltfm_data sdhci_iproc_pltfm_data = { + .quirks = SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK | +- SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12, ++ SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12 | ++ SDHCI_QUIRK_NO_HISPD_BIT, + .quirks2 = SDHCI_QUIRK2_ACMD23_BROKEN, + .ops = &sdhci_iproc_ops, + }; +diff --git a/drivers/mmc/host/sdhci-of-esdhc.c b/drivers/mmc/host/sdhci-of-esdhc.c +index a7bf8515116f..e5c598ae5f24 100644 +--- a/drivers/mmc/host/sdhci-of-esdhc.c ++++ b/drivers/mmc/host/sdhci-of-esdhc.c +@@ -643,6 +643,9 @@ static void esdhc_reset(struct sdhci_host *host, u8 mask) + sdhci_writel(host, host->ier, SDHCI_INT_ENABLE); + sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE); + ++ if (of_find_compatible_node(NULL, NULL, "fsl,p2020-esdhc")) ++ mdelay(5); ++ + if (mask & SDHCI_RESET_ALL) { + val = sdhci_readl(host, ESDHC_TBCTL); + val &= ~ESDHC_TB_EN; +@@ -917,6 +920,11 @@ static int sdhci_esdhc_probe(struct platform_device *pdev) + if (esdhc->vendor_ver > VENDOR_V_22) + host->quirks &= ~SDHCI_QUIRK_NO_BUSY_IRQ; + ++ if (of_find_compatible_node(NULL, NULL, "fsl,p2020-esdhc")) { ++ host->quirks2 |= SDHCI_QUIRK_RESET_AFTER_REQUEST; ++ host->quirks2 |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL; ++ } ++ + if (of_device_is_compatible(np, "fsl,p5040-esdhc") || + of_device_is_compatible(np, "fsl,p5020-esdhc") || + of_device_is_compatible(np, "fsl,p4080-esdhc") || +diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.c b/drivers/net/ethernet/amazon/ena/ena_netdev.c +index 1b5f591cf0a2..b5d72815776c 100644 +--- a/drivers/net/ethernet/amazon/ena/ena_netdev.c ++++ b/drivers/net/ethernet/amazon/ena/ena_netdev.c +@@ -2223,7 +2223,7 @@ static void ena_config_host_info(struct ena_com_dev *ena_dev) + + host_info->os_type = ENA_ADMIN_OS_LINUX; + host_info->kernel_ver = LINUX_VERSION_CODE; +- strncpy(host_info->kernel_ver_str, utsname()->version, ++ strlcpy(host_info->kernel_ver_str, utsname()->version, + sizeof(host_info->kernel_ver_str) - 1); + host_info->os_dist = 0; + strncpy(host_info->os_dist_str, utsname()->release, +diff --git a/drivers/net/ethernet/chelsio/cxgb3/l2t.h b/drivers/net/ethernet/chelsio/cxgb3/l2t.h +index c2fd323c4078..ea75f275023f 100644 +--- a/drivers/net/ethernet/chelsio/cxgb3/l2t.h ++++ b/drivers/net/ethernet/chelsio/cxgb3/l2t.h +@@ -75,8 +75,8 @@ struct l2t_data { + struct l2t_entry *rover; /* starting point for next allocation */ + atomic_t nfree; /* number of free entries */ + rwlock_t lock; +- struct l2t_entry l2tab[0]; + struct rcu_head rcu_head; /* to handle rcu cleanup */ ++ struct l2t_entry l2tab[]; + }; + + typedef void (*arp_failure_handler_func)(struct t3cdev * dev, +diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c +index 961e3087d1d3..bb04c695ab9f 100644 +--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c ++++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c +@@ -6010,15 +6010,24 @@ static int __init cxgb4_init_module(void) + + ret = pci_register_driver(&cxgb4_driver); + if (ret < 0) +- debugfs_remove(cxgb4_debugfs_root); ++ goto err_pci; + + #if IS_ENABLED(CONFIG_IPV6) + if (!inet6addr_registered) { +- register_inet6addr_notifier(&cxgb4_inet6addr_notifier); +- inet6addr_registered = true; ++ ret = register_inet6addr_notifier(&cxgb4_inet6addr_notifier); ++ if (ret) ++ pci_unregister_driver(&cxgb4_driver); ++ else ++ inet6addr_registered = true; + } + #endif + ++ if (ret == 0) ++ return ret; ++ ++err_pci: ++ debugfs_remove(cxgb4_debugfs_root); ++ + return ret; + } + +diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c +index 8b11682ebba2..8cd339c92c1a 100644 +--- a/drivers/net/ethernet/intel/e1000e/netdev.c ++++ b/drivers/net/ethernet/intel/e1000e/netdev.c +@@ -7329,7 +7329,7 @@ static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent) + + dev_pm_set_driver_flags(&pdev->dev, DPM_FLAG_NEVER_SKIP); + +- if (pci_dev_run_wake(pdev)) ++ if (pci_dev_run_wake(pdev) && hw->mac.type < e1000_pch_cnp) + pm_runtime_put_noidle(&pdev->dev); + + return 0; +diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c +index f81ad0aa8b09..df8808cd7e11 100644 +--- a/drivers/net/ethernet/intel/i40e/i40e_main.c ++++ b/drivers/net/ethernet/intel/i40e/i40e_main.c +@@ -2654,6 +2654,10 @@ void i40e_vlan_stripping_enable(struct i40e_vsi *vsi) + struct i40e_vsi_context ctxt; + i40e_status ret; + ++ /* Don't modify stripping options if a port VLAN is active */ ++ if (vsi->info.pvid) ++ return; ++ + if ((vsi->info.valid_sections & + cpu_to_le16(I40E_AQ_VSI_PROP_VLAN_VALID)) && + ((vsi->info.port_vlan_flags & I40E_AQ_VSI_PVLAN_MODE_MASK) == 0)) +@@ -2684,6 +2688,10 @@ void i40e_vlan_stripping_disable(struct i40e_vsi *vsi) + struct i40e_vsi_context ctxt; + i40e_status ret; + ++ /* Don't modify stripping options if a port VLAN is active */ ++ if (vsi->info.pvid) ++ return; ++ + if ((vsi->info.valid_sections & + cpu_to_le16(I40E_AQ_VSI_PROP_VLAN_VALID)) && + ((vsi->info.port_vlan_flags & I40E_AQ_VSI_PVLAN_EMOD_MASK) == +diff --git a/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c b/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c +index c6d24eaede18..d86f3fa7aa6a 100644 +--- a/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c ++++ b/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c +@@ -2399,8 +2399,10 @@ error_param: + (u8 *)&stats, sizeof(stats)); + } + +-/* If the VF is not trusted restrict the number of MAC/VLAN it can program */ +-#define I40E_VC_MAX_MAC_ADDR_PER_VF 12 ++/* If the VF is not trusted restrict the number of MAC/VLAN it can program ++ * MAC filters: 16 for multicast, 1 for MAC, 1 for broadcast ++ */ ++#define I40E_VC_MAX_MAC_ADDR_PER_VF (16 + 1 + 1) + #define I40E_VC_MAX_VLAN_PER_VF 8 + + /** +diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c +index aa39a068858e..5aa083d9a6c9 100644 +--- a/drivers/net/ethernet/intel/igb/igb_main.c ++++ b/drivers/net/ethernet/intel/igb/igb_main.c +@@ -3468,6 +3468,9 @@ static int igb_probe(struct pci_dev *pdev, const struct pci_device_id *ent) + break; + } + } ++ ++ dev_pm_set_driver_flags(&pdev->dev, DPM_FLAG_NEVER_SKIP); ++ + pm_runtime_put_noidle(&pdev->dev); + return 0; + +diff --git a/drivers/net/hyperv/netvsc.c b/drivers/net/hyperv/netvsc.c +index fb12b63439c6..35413041dcf8 100644 +--- a/drivers/net/hyperv/netvsc.c ++++ b/drivers/net/hyperv/netvsc.c +@@ -872,12 +872,6 @@ static inline int netvsc_send_pkt( + } else if (ret == -EAGAIN) { + netif_tx_stop_queue(txq); + ndev_ctx->eth_stats.stop_queue++; +- if (atomic_read(&nvchan->queue_sends) < 1 && +- !net_device->tx_disable) { +- netif_tx_wake_queue(txq); +- ndev_ctx->eth_stats.wake_queue++; +- ret = -ENOSPC; +- } + } else { + netdev_err(ndev, + "Unable to send packet pages %u len %u, ret %d\n", +@@ -885,6 +879,15 @@ static inline int netvsc_send_pkt( + ret); + } + ++ if (netif_tx_queue_stopped(txq) && ++ atomic_read(&nvchan->queue_sends) < 1 && ++ !net_device->tx_disable) { ++ netif_tx_wake_queue(txq); ++ ndev_ctx->eth_stats.wake_queue++; ++ if (ret == -EAGAIN) ++ ret = -ENOSPC; ++ } ++ + return ret; + } + +diff --git a/drivers/net/usb/qmi_wwan.c b/drivers/net/usb/qmi_wwan.c +index 366217263d70..d9a6699abe59 100644 +--- a/drivers/net/usb/qmi_wwan.c ++++ b/drivers/net/usb/qmi_wwan.c +@@ -63,6 +63,7 @@ enum qmi_wwan_flags { + + enum qmi_wwan_quirks { + QMI_WWAN_QUIRK_DTR = 1 << 0, /* needs "set DTR" request */ ++ QMI_WWAN_QUIRK_QUECTEL_DYNCFG = 1 << 1, /* check num. endpoints */ + }; + + struct qmimux_hdr { +@@ -845,6 +846,16 @@ static const struct driver_info qmi_wwan_info_quirk_dtr = { + .data = QMI_WWAN_QUIRK_DTR, + }; + ++static const struct driver_info qmi_wwan_info_quirk_quectel_dyncfg = { ++ .description = "WWAN/QMI device", ++ .flags = FLAG_WWAN | FLAG_SEND_ZLP, ++ .bind = qmi_wwan_bind, ++ .unbind = qmi_wwan_unbind, ++ .manage_power = qmi_wwan_manage_power, ++ .rx_fixup = qmi_wwan_rx_fixup, ++ .data = QMI_WWAN_QUIRK_DTR | QMI_WWAN_QUIRK_QUECTEL_DYNCFG, ++}; ++ + #define HUAWEI_VENDOR_ID 0x12D1 + + /* map QMI/wwan function by a fixed interface number */ +@@ -865,6 +876,15 @@ static const struct driver_info qmi_wwan_info_quirk_dtr = { + #define QMI_GOBI_DEVICE(vend, prod) \ + QMI_FIXED_INTF(vend, prod, 0) + ++/* Quectel does not use fixed interface numbers on at least some of their ++ * devices. We need to check the number of endpoints to ensure that we bind to ++ * the correct interface. ++ */ ++#define QMI_QUIRK_QUECTEL_DYNCFG(vend, prod) \ ++ USB_DEVICE_AND_INTERFACE_INFO(vend, prod, USB_CLASS_VENDOR_SPEC, \ ++ USB_SUBCLASS_VENDOR_SPEC, 0xff), \ ++ .driver_info = (unsigned long)&qmi_wwan_info_quirk_quectel_dyncfg ++ + static const struct usb_device_id products[] = { + /* 1. CDC ECM like devices match on the control interface */ + { /* Huawei E392, E398 and possibly others sharing both device id and more... */ +@@ -969,20 +989,9 @@ static const struct usb_device_id products[] = { + USB_DEVICE_AND_INTERFACE_INFO(0x03f0, 0x581d, USB_CLASS_VENDOR_SPEC, 1, 7), + .driver_info = (unsigned long)&qmi_wwan_info, + }, +- { /* Quectel EP06/EG06/EM06 */ +- USB_DEVICE_AND_INTERFACE_INFO(0x2c7c, 0x0306, +- USB_CLASS_VENDOR_SPEC, +- USB_SUBCLASS_VENDOR_SPEC, +- 0xff), +- .driver_info = (unsigned long)&qmi_wwan_info_quirk_dtr, +- }, +- { /* Quectel EG12/EM12 */ +- USB_DEVICE_AND_INTERFACE_INFO(0x2c7c, 0x0512, +- USB_CLASS_VENDOR_SPEC, +- USB_SUBCLASS_VENDOR_SPEC, +- 0xff), +- .driver_info = (unsigned long)&qmi_wwan_info_quirk_dtr, +- }, ++ {QMI_QUIRK_QUECTEL_DYNCFG(0x2c7c, 0x0125)}, /* Quectel EC25, EC20 R2.0 Mini PCIe */ ++ {QMI_QUIRK_QUECTEL_DYNCFG(0x2c7c, 0x0306)}, /* Quectel EP06/EG06/EM06 */ ++ {QMI_QUIRK_QUECTEL_DYNCFG(0x2c7c, 0x0512)}, /* Quectel EG12/EM12 */ + + /* 3. Combined interface devices matching on interface number */ + {QMI_FIXED_INTF(0x0408, 0xea42, 4)}, /* Yota / Megafon M100-1 */ +@@ -1283,7 +1292,6 @@ static const struct usb_device_id products[] = { + {QMI_FIXED_INTF(0x03f0, 0x9d1d, 1)}, /* HP lt4120 Snapdragon X5 LTE */ + {QMI_FIXED_INTF(0x22de, 0x9061, 3)}, /* WeTelecom WPD-600N */ + {QMI_QUIRK_SET_DTR(0x1e0e, 0x9001, 5)}, /* SIMCom 7100E, 7230E, 7600E ++ */ +- {QMI_QUIRK_SET_DTR(0x2c7c, 0x0125, 4)}, /* Quectel EC25, EC20 R2.0 Mini PCIe */ + {QMI_QUIRK_SET_DTR(0x2c7c, 0x0121, 4)}, /* Quectel EC21 Mini PCIe */ + {QMI_QUIRK_SET_DTR(0x2c7c, 0x0191, 4)}, /* Quectel EG91 */ + {QMI_FIXED_INTF(0x2c7c, 0x0296, 4)}, /* Quectel BG96 */ +@@ -1363,27 +1371,12 @@ static bool quectel_ec20_detected(struct usb_interface *intf) + return false; + } + +-static bool quectel_diag_detected(struct usb_interface *intf) +-{ +- struct usb_device *dev = interface_to_usbdev(intf); +- struct usb_interface_descriptor intf_desc = intf->cur_altsetting->desc; +- u16 id_vendor = le16_to_cpu(dev->descriptor.idVendor); +- u16 id_product = le16_to_cpu(dev->descriptor.idProduct); +- +- if (id_vendor != 0x2c7c || intf_desc.bNumEndpoints != 2) +- return false; +- +- if (id_product == 0x0306 || id_product == 0x0512) +- return true; +- else +- return false; +-} +- + static int qmi_wwan_probe(struct usb_interface *intf, + const struct usb_device_id *prod) + { + struct usb_device_id *id = (struct usb_device_id *)prod; + struct usb_interface_descriptor *desc = &intf->cur_altsetting->desc; ++ const struct driver_info *info; + + /* Workaround to enable dynamic IDs. This disables usbnet + * blacklisting functionality. Which, if required, can be +@@ -1417,10 +1410,14 @@ static int qmi_wwan_probe(struct usb_interface *intf, + * we need to match on class/subclass/protocol. These values are + * identical for the diagnostic- and QMI-interface, but bNumEndpoints is + * different. Ignore the current interface if the number of endpoints +- * the number for the diag interface (two). ++ * equals the number for the diag interface (two). + */ +- if (quectel_diag_detected(intf)) +- return -ENODEV; ++ info = (void *)&id->driver_info; ++ ++ if (info->data & QMI_WWAN_QUIRK_QUECTEL_DYNCFG) { ++ if (desc->bNumEndpoints == 2) ++ return -ENODEV; ++ } + + return usbnet_probe(intf, id); + } +diff --git a/drivers/net/wireless/ath/wil6210/cfg80211.c b/drivers/net/wireless/ath/wil6210/cfg80211.c +index 2daf33342b23..1fc2bf66845c 100644 +--- a/drivers/net/wireless/ath/wil6210/cfg80211.c ++++ b/drivers/net/wireless/ath/wil6210/cfg80211.c +@@ -1131,7 +1131,12 @@ int wil_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev, + params->wait); + + out: ++ /* when the sent packet was not acked by receiver(ACK=0), rc will ++ * be -EAGAIN. In this case this function needs to return success, ++ * the ACK=0 will be reflected in tx_status. ++ */ + tx_status = (rc == 0); ++ rc = (rc == -EAGAIN) ? 0 : rc; + cfg80211_mgmt_tx_status(wdev, cookie ? *cookie : 0, buf, len, + tx_status, GFP_KERNEL); + +diff --git a/drivers/net/wireless/ath/wil6210/wmi.c b/drivers/net/wireless/ath/wil6210/wmi.c +index 42c02a20ec97..6e3b3031f29b 100644 +--- a/drivers/net/wireless/ath/wil6210/wmi.c ++++ b/drivers/net/wireless/ath/wil6210/wmi.c +@@ -3107,8 +3107,9 @@ int wmi_mgmt_tx(struct wil6210_vif *vif, const u8 *buf, size_t len) + rc = wmi_call(wil, WMI_SW_TX_REQ_CMDID, vif->mid, cmd, total, + WMI_SW_TX_COMPLETE_EVENTID, &evt, sizeof(evt), 2000); + if (!rc && evt.evt.status != WMI_FW_STATUS_SUCCESS) { +- wil_err(wil, "mgmt_tx failed with status %d\n", evt.evt.status); +- rc = -EINVAL; ++ wil_dbg_wmi(wil, "mgmt_tx failed with status %d\n", ++ evt.evt.status); ++ rc = -EAGAIN; + } + + kfree(cmd); +@@ -3160,9 +3161,9 @@ int wmi_mgmt_tx_ext(struct wil6210_vif *vif, const u8 *buf, size_t len, + rc = wmi_call(wil, WMI_SW_TX_REQ_EXT_CMDID, vif->mid, cmd, total, + WMI_SW_TX_COMPLETE_EVENTID, &evt, sizeof(evt), 2000); + if (!rc && evt.evt.status != WMI_FW_STATUS_SUCCESS) { +- wil_err(wil, "mgmt_tx_ext failed with status %d\n", +- evt.evt.status); +- rc = -EINVAL; ++ wil_dbg_wmi(wil, "mgmt_tx_ext failed with status %d\n", ++ evt.evt.status); ++ rc = -EAGAIN; + } + + kfree(cmd); +diff --git a/drivers/net/wireless/atmel/at76c50x-usb.c b/drivers/net/wireless/atmel/at76c50x-usb.c +index e99e766a3028..1cabae424839 100644 +--- a/drivers/net/wireless/atmel/at76c50x-usb.c ++++ b/drivers/net/wireless/atmel/at76c50x-usb.c +@@ -2585,8 +2585,8 @@ static int __init at76_mod_init(void) + if (result < 0) + printk(KERN_ERR DRIVER_NAME + ": usb_register failed (status %d)\n", result); +- +- led_trigger_register_simple("at76_usb-tx", &ledtrig_tx); ++ else ++ led_trigger_register_simple("at76_usb-tx", &ledtrig_tx); + return result; + } + +diff --git a/drivers/net/wireless/broadcom/b43/phy_lp.c b/drivers/net/wireless/broadcom/b43/phy_lp.c +index 6922cbb99a04..5a0699fb4b9a 100644 +--- a/drivers/net/wireless/broadcom/b43/phy_lp.c ++++ b/drivers/net/wireless/broadcom/b43/phy_lp.c +@@ -1834,7 +1834,7 @@ static void lpphy_papd_cal(struct b43_wldev *dev, struct lpphy_tx_gains gains, + static void lpphy_papd_cal_txpwr(struct b43_wldev *dev) + { + struct b43_phy_lp *lpphy = dev->phy.lp; +- struct lpphy_tx_gains gains, oldgains; ++ struct lpphy_tx_gains oldgains; + int old_txpctl, old_afe_ovr, old_rf, old_bbmult; + + lpphy_read_tx_pctl_mode_from_hardware(dev); +@@ -1848,9 +1848,9 @@ static void lpphy_papd_cal_txpwr(struct b43_wldev *dev) + lpphy_set_tx_power_control(dev, B43_LPPHY_TXPCTL_OFF); + + if (dev->dev->chip_id == 0x4325 && dev->dev->chip_rev == 0) +- lpphy_papd_cal(dev, gains, 0, 1, 30); ++ lpphy_papd_cal(dev, oldgains, 0, 1, 30); + else +- lpphy_papd_cal(dev, gains, 0, 1, 65); ++ lpphy_papd_cal(dev, oldgains, 0, 1, 65); + + if (old_afe_ovr) + lpphy_set_tx_gains(dev, oldgains); +diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c +index 6f3faaf1b1cb..c7c520f327f2 100644 +--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c ++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c +@@ -3466,6 +3466,8 @@ brcmf_wowl_nd_results(struct brcmf_if *ifp, const struct brcmf_event_msg *e, + } + + netinfo = brcmf_get_netinfo_array(pfn_result); ++ if (netinfo->SSID_len > IEEE80211_MAX_SSID_LEN) ++ netinfo->SSID_len = IEEE80211_MAX_SSID_LEN; + memcpy(cfg->wowl.nd->ssid.ssid, netinfo->SSID, netinfo->SSID_len); + cfg->wowl.nd->ssid.ssid_len = netinfo->SSID_len; + cfg->wowl.nd->n_channels = 1; +@@ -5366,6 +5368,8 @@ static s32 brcmf_get_assoc_ies(struct brcmf_cfg80211_info *cfg, + conn_info->req_ie = + kmemdup(cfg->extra_buf, conn_info->req_ie_len, + GFP_KERNEL); ++ if (!conn_info->req_ie) ++ conn_info->req_ie_len = 0; + } else { + conn_info->req_ie_len = 0; + conn_info->req_ie = NULL; +@@ -5382,6 +5386,8 @@ static s32 brcmf_get_assoc_ies(struct brcmf_cfg80211_info *cfg, + conn_info->resp_ie = + kmemdup(cfg->extra_buf, conn_info->resp_ie_len, + GFP_KERNEL); ++ if (!conn_info->resp_ie) ++ conn_info->resp_ie_len = 0; + } else { + conn_info->resp_ie_len = 0; + conn_info->resp_ie = NULL; +diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/core.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/core.c +index 860a4372cb56..36a04c1144e5 100644 +--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/core.c ++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/core.c +@@ -464,7 +464,8 @@ void brcmf_rx_frame(struct device *dev, struct sk_buff *skb, bool handle_event) + } else { + /* Process special event packets */ + if (handle_event) +- brcmf_fweh_process_skb(ifp->drvr, skb); ++ brcmf_fweh_process_skb(ifp->drvr, skb, ++ BCMILCP_SUBTYPE_VENDOR_LONG); + + brcmf_netif_rx(ifp, skb); + } +@@ -481,7 +482,7 @@ void brcmf_rx_event(struct device *dev, struct sk_buff *skb) + if (brcmf_rx_hdrpull(drvr, skb, &ifp)) + return; + +- brcmf_fweh_process_skb(ifp->drvr, skb); ++ brcmf_fweh_process_skb(ifp->drvr, skb, 0); + brcmu_pkt_buf_free_skb(skb); + } + +@@ -783,17 +784,17 @@ static void brcmf_del_if(struct brcmf_pub *drvr, s32 bsscfgidx, + bool rtnl_locked) + { + struct brcmf_if *ifp; ++ int ifidx; + + ifp = drvr->iflist[bsscfgidx]; +- drvr->iflist[bsscfgidx] = NULL; + if (!ifp) { + brcmf_err("Null interface, bsscfgidx=%d\n", bsscfgidx); + return; + } + brcmf_dbg(TRACE, "Enter, bsscfgidx=%d, ifidx=%d\n", bsscfgidx, + ifp->ifidx); +- if (drvr->if2bss[ifp->ifidx] == bsscfgidx) +- drvr->if2bss[ifp->ifidx] = BRCMF_BSSIDX_INVALID; ++ ifidx = ifp->ifidx; ++ + if (ifp->ndev) { + if (bsscfgidx == 0) { + if (ifp->ndev->netdev_ops == &brcmf_netdev_ops_pri) { +@@ -821,6 +822,10 @@ static void brcmf_del_if(struct brcmf_pub *drvr, s32 bsscfgidx, + brcmf_p2p_ifp_removed(ifp, rtnl_locked); + kfree(ifp); + } ++ ++ drvr->iflist[bsscfgidx] = NULL; ++ if (drvr->if2bss[ifidx] == bsscfgidx) ++ drvr->if2bss[ifidx] = BRCMF_BSSIDX_INVALID; + } + + void brcmf_remove_interface(struct brcmf_if *ifp, bool rtnl_locked) +diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fweh.h b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fweh.h +index 816f80ea925b..ebd66fe0d949 100644 +--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fweh.h ++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fweh.h +@@ -211,7 +211,7 @@ enum brcmf_fweh_event_code { + */ + #define BRCM_OUI "\x00\x10\x18" + #define BCMILCP_BCM_SUBTYPE_EVENT 1 +- ++#define BCMILCP_SUBTYPE_VENDOR_LONG 32769 + + /** + * struct brcm_ethhdr - broadcom specific ether header. +@@ -334,10 +334,10 @@ void brcmf_fweh_process_event(struct brcmf_pub *drvr, + void brcmf_fweh_p2pdev_setup(struct brcmf_if *ifp, bool ongoing); + + static inline void brcmf_fweh_process_skb(struct brcmf_pub *drvr, +- struct sk_buff *skb) ++ struct sk_buff *skb, u16 stype) + { + struct brcmf_event *event_packet; +- u16 usr_stype; ++ u16 subtype, usr_stype; + + /* only process events when protocol matches */ + if (skb->protocol != cpu_to_be16(ETH_P_LINK_CTL)) +@@ -346,8 +346,16 @@ static inline void brcmf_fweh_process_skb(struct brcmf_pub *drvr, + if ((skb->len + ETH_HLEN) < sizeof(*event_packet)) + return; + +- /* check for BRCM oui match */ + event_packet = (struct brcmf_event *)skb_mac_header(skb); ++ ++ /* check subtype if needed */ ++ if (unlikely(stype)) { ++ subtype = get_unaligned_be16(&event_packet->hdr.subtype); ++ if (subtype != stype) ++ return; ++ } ++ ++ /* check for BRCM oui match */ + if (memcmp(BRCM_OUI, &event_packet->hdr.oui[0], + sizeof(event_packet->hdr.oui))) + return; +diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwsignal.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwsignal.c +index f3cbf78c8899..5a0a29c4cdea 100644 +--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwsignal.c ++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwsignal.c +@@ -579,24 +579,6 @@ static bool brcmf_fws_ifidx_match(struct sk_buff *skb, void *arg) + return ifidx == *(int *)arg; + } + +-static void brcmf_fws_psq_flush(struct brcmf_fws_info *fws, struct pktq *q, +- int ifidx) +-{ +- bool (*matchfn)(struct sk_buff *, void *) = NULL; +- struct sk_buff *skb; +- int prec; +- +- if (ifidx != -1) +- matchfn = brcmf_fws_ifidx_match; +- for (prec = 0; prec < q->num_prec; prec++) { +- skb = brcmu_pktq_pdeq_match(q, prec, matchfn, &ifidx); +- while (skb) { +- brcmu_pkt_buf_free_skb(skb); +- skb = brcmu_pktq_pdeq_match(q, prec, matchfn, &ifidx); +- } +- } +-} +- + static void brcmf_fws_hanger_init(struct brcmf_fws_hanger *hanger) + { + int i; +@@ -668,6 +650,28 @@ static inline int brcmf_fws_hanger_poppkt(struct brcmf_fws_hanger *h, + return 0; + } + ++static void brcmf_fws_psq_flush(struct brcmf_fws_info *fws, struct pktq *q, ++ int ifidx) ++{ ++ bool (*matchfn)(struct sk_buff *, void *) = NULL; ++ struct sk_buff *skb; ++ int prec; ++ u32 hslot; ++ ++ if (ifidx != -1) ++ matchfn = brcmf_fws_ifidx_match; ++ for (prec = 0; prec < q->num_prec; prec++) { ++ skb = brcmu_pktq_pdeq_match(q, prec, matchfn, &ifidx); ++ while (skb) { ++ hslot = brcmf_skb_htod_tag_get_field(skb, HSLOT); ++ brcmf_fws_hanger_poppkt(&fws->hanger, hslot, &skb, ++ true); ++ brcmu_pkt_buf_free_skb(skb); ++ skb = brcmu_pktq_pdeq_match(q, prec, matchfn, &ifidx); ++ } ++ } ++} ++ + static int brcmf_fws_hanger_mark_suppressed(struct brcmf_fws_hanger *h, + u32 slot_id) + { +@@ -2168,6 +2172,8 @@ void brcmf_fws_del_interface(struct brcmf_if *ifp) + brcmf_fws_lock(fws); + ifp->fws_desc = NULL; + brcmf_dbg(TRACE, "deleting %s\n", entry->name); ++ brcmf_fws_macdesc_cleanup(fws, &fws->desc.iface[ifp->ifidx], ++ ifp->ifidx); + brcmf_fws_macdesc_deinit(entry); + brcmf_fws_cleanup(fws, ifp->ifidx); + brcmf_fws_unlock(fws); +diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/msgbuf.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/msgbuf.c +index 4e8397a0cbc8..ee922b052561 100644 +--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/msgbuf.c ++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/msgbuf.c +@@ -1116,7 +1116,7 @@ static void brcmf_msgbuf_process_event(struct brcmf_msgbuf *msgbuf, void *buf) + + skb->protocol = eth_type_trans(skb, ifp->ndev); + +- brcmf_fweh_process_skb(ifp->drvr, skb); ++ brcmf_fweh_process_skb(ifp->drvr, skb, 0); + + exit: + brcmu_pkt_buf_free_skb(skb); +diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/usb.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/usb.c +index a4308c6e72d7..44ead0fea7c6 100644 +--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/usb.c ++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/usb.c +@@ -160,7 +160,7 @@ struct brcmf_usbdev_info { + + struct usb_device *usbdev; + struct device *dev; +- struct mutex dev_init_lock; ++ struct completion dev_init_done; + + int ctl_in_pipe, ctl_out_pipe; + struct urb *ctl_urb; /* URB for control endpoint */ +@@ -684,12 +684,18 @@ static int brcmf_usb_up(struct device *dev) + + static void brcmf_cancel_all_urbs(struct brcmf_usbdev_info *devinfo) + { ++ int i; ++ + if (devinfo->ctl_urb) + usb_kill_urb(devinfo->ctl_urb); + if (devinfo->bulk_urb) + usb_kill_urb(devinfo->bulk_urb); +- brcmf_usb_free_q(&devinfo->tx_postq, true); +- brcmf_usb_free_q(&devinfo->rx_postq, true); ++ if (devinfo->tx_reqs) ++ for (i = 0; i < devinfo->bus_pub.ntxq; i++) ++ usb_kill_urb(devinfo->tx_reqs[i].urb); ++ if (devinfo->rx_reqs) ++ for (i = 0; i < devinfo->bus_pub.nrxq; i++) ++ usb_kill_urb(devinfo->rx_reqs[i].urb); + } + + static void brcmf_usb_down(struct device *dev) +@@ -1195,11 +1201,11 @@ static void brcmf_usb_probe_phase2(struct device *dev, int ret, + if (ret) + goto error; + +- mutex_unlock(&devinfo->dev_init_lock); ++ complete(&devinfo->dev_init_done); + return; + error: + brcmf_dbg(TRACE, "failed: dev=%s, err=%d\n", dev_name(dev), ret); +- mutex_unlock(&devinfo->dev_init_lock); ++ complete(&devinfo->dev_init_done); + device_release_driver(dev); + } + +@@ -1267,7 +1273,7 @@ static int brcmf_usb_probe_cb(struct brcmf_usbdev_info *devinfo) + if (ret) + goto fail; + /* we are done */ +- mutex_unlock(&devinfo->dev_init_lock); ++ complete(&devinfo->dev_init_done); + return 0; + } + bus->chip = bus_pub->devid; +@@ -1327,11 +1333,10 @@ brcmf_usb_probe(struct usb_interface *intf, const struct usb_device_id *id) + + devinfo->usbdev = usb; + devinfo->dev = &usb->dev; +- /* Take an init lock, to protect for disconnect while still loading. ++ /* Init completion, to protect for disconnect while still loading. + * Necessary because of the asynchronous firmware load construction + */ +- mutex_init(&devinfo->dev_init_lock); +- mutex_lock(&devinfo->dev_init_lock); ++ init_completion(&devinfo->dev_init_done); + + usb_set_intfdata(intf, devinfo); + +@@ -1409,7 +1414,7 @@ brcmf_usb_probe(struct usb_interface *intf, const struct usb_device_id *id) + return 0; + + fail: +- mutex_unlock(&devinfo->dev_init_lock); ++ complete(&devinfo->dev_init_done); + kfree(devinfo); + usb_set_intfdata(intf, NULL); + return ret; +@@ -1424,7 +1429,7 @@ brcmf_usb_disconnect(struct usb_interface *intf) + devinfo = (struct brcmf_usbdev_info *)usb_get_intfdata(intf); + + if (devinfo) { +- mutex_lock(&devinfo->dev_init_lock); ++ wait_for_completion(&devinfo->dev_init_done); + /* Make sure that devinfo still exists. Firmware probe routines + * may have released the device and cleared the intfdata. + */ +diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/vendor.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/vendor.c +index 8eff2753abad..d493021f6031 100644 +--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/vendor.c ++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/vendor.c +@@ -35,9 +35,10 @@ static int brcmf_cfg80211_vndr_cmds_dcmd_handler(struct wiphy *wiphy, + struct brcmf_if *ifp; + const struct brcmf_vndr_dcmd_hdr *cmdhdr = data; + struct sk_buff *reply; +- int ret, payload, ret_len; ++ unsigned int payload, ret_len; + void *dcmd_buf = NULL, *wr_pointer; + u16 msglen, maxmsglen = PAGE_SIZE - 0x100; ++ int ret; + + if (len < sizeof(*cmdhdr)) { + brcmf_err("vendor command too short: %d\n", len); +@@ -65,7 +66,7 @@ static int brcmf_cfg80211_vndr_cmds_dcmd_handler(struct wiphy *wiphy, + brcmf_err("oversize return buffer %d\n", ret_len); + ret_len = BRCMF_DCMD_MAXLEN; + } +- payload = max(ret_len, len) + 1; ++ payload = max_t(unsigned int, ret_len, len) + 1; + dcmd_buf = vzalloc(payload); + if (NULL == dcmd_buf) + return -ENOMEM; +diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/rx.c b/drivers/net/wireless/intel/iwlwifi/pcie/rx.c +index b2905f01b7df..6dcd5374d9b4 100644 +--- a/drivers/net/wireless/intel/iwlwifi/pcie/rx.c ++++ b/drivers/net/wireless/intel/iwlwifi/pcie/rx.c +@@ -1388,10 +1388,15 @@ out_err: + static void iwl_pcie_rx_handle(struct iwl_trans *trans, int queue) + { + struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans); +- struct iwl_rxq *rxq = &trans_pcie->rxq[queue]; ++ struct iwl_rxq *rxq; + u32 r, i, count = 0; + bool emergency = false; + ++ if (WARN_ON_ONCE(!trans_pcie->rxq || !trans_pcie->rxq[queue].bd)) ++ return; ++ ++ rxq = &trans_pcie->rxq[queue]; ++ + restart: + spin_lock(&rxq->lock); + /* uCode's read index (stored in shared DRAM) indicates the last Rx +diff --git a/drivers/net/wireless/marvell/mwifiex/cfg80211.c b/drivers/net/wireless/marvell/mwifiex/cfg80211.c +index 2d87ebbfa4da..47ec5293c045 100644 +--- a/drivers/net/wireless/marvell/mwifiex/cfg80211.c ++++ b/drivers/net/wireless/marvell/mwifiex/cfg80211.c +@@ -4045,16 +4045,20 @@ static int mwifiex_tm_cmd(struct wiphy *wiphy, struct wireless_dev *wdev, + + if (mwifiex_send_cmd(priv, 0, 0, 0, hostcmd, true)) { + dev_err(priv->adapter->dev, "Failed to process hostcmd\n"); ++ kfree(hostcmd); + return -EFAULT; + } + + /* process hostcmd response*/ + skb = cfg80211_testmode_alloc_reply_skb(wiphy, hostcmd->len); +- if (!skb) ++ if (!skb) { ++ kfree(hostcmd); + return -ENOMEM; ++ } + err = nla_put(skb, MWIFIEX_TM_ATTR_DATA, + hostcmd->len, hostcmd->cmd); + if (err) { ++ kfree(hostcmd); + kfree_skb(skb); + return -EMSGSIZE; + } +diff --git a/drivers/net/wireless/marvell/mwifiex/cfp.c b/drivers/net/wireless/marvell/mwifiex/cfp.c +index bfe84e55df77..f1522fb1c1e8 100644 +--- a/drivers/net/wireless/marvell/mwifiex/cfp.c ++++ b/drivers/net/wireless/marvell/mwifiex/cfp.c +@@ -531,5 +531,8 @@ u8 mwifiex_adjust_data_rate(struct mwifiex_private *priv, + rate_index = (rx_rate > MWIFIEX_RATE_INDEX_OFDM0) ? + rx_rate - 1 : rx_rate; + ++ if (rate_index >= MWIFIEX_MAX_AC_RX_RATES) ++ rate_index = MWIFIEX_MAX_AC_RX_RATES - 1; ++ + return rate_index; + } +diff --git a/drivers/net/wireless/realtek/rtlwifi/base.c b/drivers/net/wireless/realtek/rtlwifi/base.c +index ef9b502ce576..a3189294ecb8 100644 +--- a/drivers/net/wireless/realtek/rtlwifi/base.c ++++ b/drivers/net/wireless/realtek/rtlwifi/base.c +@@ -469,6 +469,11 @@ static void _rtl_init_deferred_work(struct ieee80211_hw *hw) + /* <2> work queue */ + rtlpriv->works.hw = hw; + rtlpriv->works.rtl_wq = alloc_workqueue("%s", 0, 0, rtlpriv->cfg->name); ++ if (unlikely(!rtlpriv->works.rtl_wq)) { ++ pr_err("Failed to allocate work queue\n"); ++ return; ++ } ++ + INIT_DELAYED_WORK(&rtlpriv->works.watchdog_wq, + (void *)rtl_watchdog_wq_callback); + INIT_DELAYED_WORK(&rtlpriv->works.ips_nic_off_wq, +diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8188ee/fw.c b/drivers/net/wireless/realtek/rtlwifi/rtl8188ee/fw.c +index 63874512598b..b5f91c994c79 100644 +--- a/drivers/net/wireless/realtek/rtlwifi/rtl8188ee/fw.c ++++ b/drivers/net/wireless/realtek/rtlwifi/rtl8188ee/fw.c +@@ -622,6 +622,8 @@ void rtl88e_set_fw_rsvdpagepkt(struct ieee80211_hw *hw, bool b_dl_finished) + u1rsvdpageloc, 3); + + skb = dev_alloc_skb(totalpacketlen); ++ if (!skb) ++ return; + skb_put_data(skb, &reserved_page_packet, totalpacketlen); + + rtstatus = rtl_cmd_send_packet(hw, skb); +diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8192c/fw_common.c b/drivers/net/wireless/realtek/rtlwifi/rtl8192c/fw_common.c +index f3bff66e85d0..81ec0e6e07c1 100644 +--- a/drivers/net/wireless/realtek/rtlwifi/rtl8192c/fw_common.c ++++ b/drivers/net/wireless/realtek/rtlwifi/rtl8192c/fw_common.c +@@ -646,6 +646,8 @@ void rtl92c_set_fw_rsvdpagepkt(struct ieee80211_hw *hw, + + + skb = dev_alloc_skb(totalpacketlen); ++ if (!skb) ++ return; + skb_put_data(skb, &reserved_page_packet, totalpacketlen); + + if (cmd_send_packet) +diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8192ee/fw.c b/drivers/net/wireless/realtek/rtlwifi/rtl8192ee/fw.c +index 84a0d0eb72e1..a933490928ba 100644 +--- a/drivers/net/wireless/realtek/rtlwifi/rtl8192ee/fw.c ++++ b/drivers/net/wireless/realtek/rtlwifi/rtl8192ee/fw.c +@@ -766,6 +766,8 @@ void rtl92ee_set_fw_rsvdpagepkt(struct ieee80211_hw *hw, bool b_dl_finished) + u1rsvdpageloc, 3); + + skb = dev_alloc_skb(totalpacketlen); ++ if (!skb) ++ return; + skb_put_data(skb, &reserved_page_packet, totalpacketlen); + + rtstatus = rtl_cmd_send_packet(hw, skb); +diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8723ae/fw.c b/drivers/net/wireless/realtek/rtlwifi/rtl8723ae/fw.c +index bf9859f74b6f..52f108744e96 100644 +--- a/drivers/net/wireless/realtek/rtlwifi/rtl8723ae/fw.c ++++ b/drivers/net/wireless/realtek/rtlwifi/rtl8723ae/fw.c +@@ -470,6 +470,8 @@ void rtl8723e_set_fw_rsvdpagepkt(struct ieee80211_hw *hw, bool b_dl_finished) + u1rsvdpageloc, 3); + + skb = dev_alloc_skb(totalpacketlen); ++ if (!skb) ++ return; + skb_put_data(skb, &reserved_page_packet, totalpacketlen); + + rtstatus = rtl_cmd_send_packet(hw, skb); +diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8723be/fw.c b/drivers/net/wireless/realtek/rtlwifi/rtl8723be/fw.c +index f2441fbb92f1..307c2bd77f06 100644 +--- a/drivers/net/wireless/realtek/rtlwifi/rtl8723be/fw.c ++++ b/drivers/net/wireless/realtek/rtlwifi/rtl8723be/fw.c +@@ -584,6 +584,8 @@ void rtl8723be_set_fw_rsvdpagepkt(struct ieee80211_hw *hw, + u1rsvdpageloc, sizeof(u1rsvdpageloc)); + + skb = dev_alloc_skb(totalpacketlen); ++ if (!skb) ++ return; + skb_put_data(skb, &reserved_page_packet, totalpacketlen); + + rtstatus = rtl_cmd_send_packet(hw, skb); +diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/fw.c b/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/fw.c +index d868a034659f..d7235f6165fd 100644 +--- a/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/fw.c ++++ b/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/fw.c +@@ -1645,6 +1645,8 @@ out: + &reserved_page_packet_8812[0], totalpacketlen); + + skb = dev_alloc_skb(totalpacketlen); ++ if (!skb) ++ return; + skb_put_data(skb, &reserved_page_packet_8812, totalpacketlen); + + rtstatus = rtl_cmd_send_packet(hw, skb); +@@ -1781,6 +1783,8 @@ out: + &reserved_page_packet_8821[0], totalpacketlen); + + skb = dev_alloc_skb(totalpacketlen); ++ if (!skb) ++ return; + skb_put_data(skb, &reserved_page_packet_8821, totalpacketlen); + + rtstatus = rtl_cmd_send_packet(hw, skb); +diff --git a/drivers/net/wireless/rsi/rsi_91x_mac80211.c b/drivers/net/wireless/rsi/rsi_91x_mac80211.c +index 4e510cbe0a89..be59d66585d6 100644 +--- a/drivers/net/wireless/rsi/rsi_91x_mac80211.c ++++ b/drivers/net/wireless/rsi/rsi_91x_mac80211.c +@@ -188,27 +188,27 @@ bool rsi_is_cipher_wep(struct rsi_common *common) + * @adapter: Pointer to the adapter structure. + * @band: Operating band to be set. + * +- * Return: None. ++ * Return: int - 0 on success, negative error on failure. + */ +-static void rsi_register_rates_channels(struct rsi_hw *adapter, int band) ++static int rsi_register_rates_channels(struct rsi_hw *adapter, int band) + { + struct ieee80211_supported_band *sbands = &adapter->sbands[band]; + void *channels = NULL; + + if (band == NL80211_BAND_2GHZ) { +- channels = kmalloc(sizeof(rsi_2ghz_channels), GFP_KERNEL); +- memcpy(channels, +- rsi_2ghz_channels, +- sizeof(rsi_2ghz_channels)); ++ channels = kmemdup(rsi_2ghz_channels, sizeof(rsi_2ghz_channels), ++ GFP_KERNEL); ++ if (!channels) ++ return -ENOMEM; + sbands->band = NL80211_BAND_2GHZ; + sbands->n_channels = ARRAY_SIZE(rsi_2ghz_channels); + sbands->bitrates = rsi_rates; + sbands->n_bitrates = ARRAY_SIZE(rsi_rates); + } else { +- channels = kmalloc(sizeof(rsi_5ghz_channels), GFP_KERNEL); +- memcpy(channels, +- rsi_5ghz_channels, +- sizeof(rsi_5ghz_channels)); ++ channels = kmemdup(rsi_5ghz_channels, sizeof(rsi_5ghz_channels), ++ GFP_KERNEL); ++ if (!channels) ++ return -ENOMEM; + sbands->band = NL80211_BAND_5GHZ; + sbands->n_channels = ARRAY_SIZE(rsi_5ghz_channels); + sbands->bitrates = &rsi_rates[4]; +@@ -227,6 +227,7 @@ static void rsi_register_rates_channels(struct rsi_hw *adapter, int band) + sbands->ht_cap.mcs.rx_mask[0] = 0xff; + sbands->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED; + /* sbands->ht_cap.mcs.rx_highest = 0x82; */ ++ return 0; + } + + /** +@@ -1985,11 +1986,16 @@ int rsi_mac80211_attach(struct rsi_common *common) + wiphy->available_antennas_rx = 1; + wiphy->available_antennas_tx = 1; + +- rsi_register_rates_channels(adapter, NL80211_BAND_2GHZ); ++ status = rsi_register_rates_channels(adapter, NL80211_BAND_2GHZ); ++ if (status) ++ return status; + wiphy->bands[NL80211_BAND_2GHZ] = + &adapter->sbands[NL80211_BAND_2GHZ]; + if (common->num_supp_bands > 1) { +- rsi_register_rates_channels(adapter, NL80211_BAND_5GHZ); ++ status = rsi_register_rates_channels(adapter, ++ NL80211_BAND_5GHZ); ++ if (status) ++ return status; + wiphy->bands[NL80211_BAND_5GHZ] = + &adapter->sbands[NL80211_BAND_5GHZ]; + } +diff --git a/drivers/net/wireless/st/cw1200/main.c b/drivers/net/wireless/st/cw1200/main.c +index 90dc979f260b..c1608f0bf6d0 100644 +--- a/drivers/net/wireless/st/cw1200/main.c ++++ b/drivers/net/wireless/st/cw1200/main.c +@@ -345,6 +345,11 @@ static struct ieee80211_hw *cw1200_init_common(const u8 *macaddr, + mutex_init(&priv->wsm_cmd_mux); + mutex_init(&priv->conf_mutex); + priv->workqueue = create_singlethread_workqueue("cw1200_wq"); ++ if (!priv->workqueue) { ++ ieee80211_free_hw(hw); ++ return NULL; ++ } ++ + sema_init(&priv->scan.lock, 1); + INIT_WORK(&priv->scan.work, cw1200_scan_work); + INIT_DELAYED_WORK(&priv->scan.probe_work, cw1200_probe_work); +diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c +index cff027fc2676..a7ce2f1761a2 100644 +--- a/drivers/nvdimm/pmem.c ++++ b/drivers/nvdimm/pmem.c +@@ -281,16 +281,22 @@ static long pmem_dax_direct_access(struct dax_device *dax_dev, + return __pmem_direct_access(pmem, pgoff, nr_pages, kaddr, pfn); + } + ++/* ++ * Use the 'no check' versions of copy_from_iter_flushcache() and ++ * copy_to_iter_mcsafe() to bypass HARDENED_USERCOPY overhead. Bounds ++ * checking, both file offset and device offset, is handled by ++ * dax_iomap_actor() ++ */ + static size_t pmem_copy_from_iter(struct dax_device *dax_dev, pgoff_t pgoff, + void *addr, size_t bytes, struct iov_iter *i) + { +- return copy_from_iter_flushcache(addr, bytes, i); ++ return _copy_from_iter_flushcache(addr, bytes, i); + } + + static size_t pmem_copy_to_iter(struct dax_device *dax_dev, pgoff_t pgoff, + void *addr, size_t bytes, struct iov_iter *i) + { +- return copy_to_iter_mcsafe(addr, bytes, i); ++ return _copy_to_iter_mcsafe(addr, bytes, i); + } + + static const struct dax_operations pmem_dax_ops = { +diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c +index 2cdb3032ca0f..abfb46378cc1 100644 +--- a/drivers/nvme/host/core.c ++++ b/drivers/nvme/host/core.c +@@ -1480,6 +1480,10 @@ static void nvme_update_disk_info(struct gendisk *disk, + sector_t capacity = le64_to_cpup(&id->nsze) << (ns->lba_shift - 9); + unsigned short bs = 1 << ns->lba_shift; + ++ if (ns->lba_shift > PAGE_SHIFT) { ++ /* unsupported block size, set capacity to 0 later */ ++ bs = (1 << 9); ++ } + blk_mq_freeze_queue(disk->queue); + blk_integrity_unregister(disk); + +@@ -1490,7 +1494,8 @@ static void nvme_update_disk_info(struct gendisk *disk, + if (ns->ms && !ns->ext && + (ns->ctrl->ops->flags & NVME_F_METADATA_SUPPORTED)) + nvme_init_integrity(disk, ns->ms, ns->pi_type); +- if (ns->ms && !nvme_ns_has_pi(ns) && !blk_get_integrity(disk)) ++ if ((ns->ms && !nvme_ns_has_pi(ns) && !blk_get_integrity(disk)) || ++ ns->lba_shift > PAGE_SHIFT) + capacity = 0; + + set_capacity(disk, capacity); +diff --git a/drivers/nvme/host/rdma.c b/drivers/nvme/host/rdma.c +index 0939a4e178fb..e4f167e35353 100644 +--- a/drivers/nvme/host/rdma.c ++++ b/drivers/nvme/host/rdma.c +@@ -880,8 +880,9 @@ static void nvme_rdma_teardown_admin_queue(struct nvme_rdma_ctrl *ctrl, + { + blk_mq_quiesce_queue(ctrl->ctrl.admin_q); + nvme_rdma_stop_queue(&ctrl->queues[0]); +- blk_mq_tagset_busy_iter(&ctrl->admin_tag_set, nvme_cancel_request, +- &ctrl->ctrl); ++ if (ctrl->ctrl.admin_tagset) ++ blk_mq_tagset_busy_iter(ctrl->ctrl.admin_tagset, ++ nvme_cancel_request, &ctrl->ctrl); + blk_mq_unquiesce_queue(ctrl->ctrl.admin_q); + nvme_rdma_destroy_admin_queue(ctrl, remove); + } +@@ -892,8 +893,9 @@ static void nvme_rdma_teardown_io_queues(struct nvme_rdma_ctrl *ctrl, + if (ctrl->ctrl.queue_count > 1) { + nvme_stop_queues(&ctrl->ctrl); + nvme_rdma_stop_io_queues(ctrl); +- blk_mq_tagset_busy_iter(&ctrl->tag_set, nvme_cancel_request, +- &ctrl->ctrl); ++ if (ctrl->ctrl.tagset) ++ blk_mq_tagset_busy_iter(ctrl->ctrl.tagset, ++ nvme_cancel_request, &ctrl->ctrl); + if (remove) + nvme_start_queues(&ctrl->ctrl); + nvme_rdma_destroy_io_queues(ctrl, remove); +diff --git a/drivers/perf/arm-cci.c b/drivers/perf/arm-cci.c +index 1bfeb160c5b1..14a541c453e5 100644 +--- a/drivers/perf/arm-cci.c ++++ b/drivers/perf/arm-cci.c +@@ -1692,21 +1692,24 @@ static int cci_pmu_probe(struct platform_device *pdev) + raw_spin_lock_init(&cci_pmu->hw_events.pmu_lock); + mutex_init(&cci_pmu->reserve_mutex); + atomic_set(&cci_pmu->active_events, 0); +- cci_pmu->cpu = get_cpu(); +- +- ret = cci_pmu_init(cci_pmu, pdev); +- if (ret) { +- put_cpu(); +- return ret; +- } + ++ cci_pmu->cpu = raw_smp_processor_id(); ++ g_cci_pmu = cci_pmu; + cpuhp_setup_state_nocalls(CPUHP_AP_PERF_ARM_CCI_ONLINE, + "perf/arm/cci:online", NULL, + cci_pmu_offline_cpu); +- put_cpu(); +- g_cci_pmu = cci_pmu; ++ ++ ret = cci_pmu_init(cci_pmu, pdev); ++ if (ret) ++ goto error_pmu_init; ++ + pr_info("ARM %s PMU driver probed", cci_pmu->model->name); + return 0; ++ ++error_pmu_init: ++ cpuhp_remove_state(CPUHP_AP_PERF_ARM_CCI_ONLINE); ++ g_cci_pmu = NULL; ++ return ret; + } + + static int cci_pmu_remove(struct platform_device *pdev) +diff --git a/drivers/phy/allwinner/phy-sun4i-usb.c b/drivers/phy/allwinner/phy-sun4i-usb.c +index 15c8fc2abf01..1f8809bab002 100644 +--- a/drivers/phy/allwinner/phy-sun4i-usb.c ++++ b/drivers/phy/allwinner/phy-sun4i-usb.c +@@ -550,6 +550,7 @@ static void sun4i_usb_phy0_id_vbus_det_scan(struct work_struct *work) + struct sun4i_usb_phy_data *data = + container_of(work, struct sun4i_usb_phy_data, detect.work); + struct phy *phy0 = data->phys[0].phy; ++ struct sun4i_usb_phy *phy = phy_get_drvdata(phy0); + bool force_session_end, id_notify = false, vbus_notify = false; + int id_det, vbus_det; + +@@ -606,6 +607,9 @@ static void sun4i_usb_phy0_id_vbus_det_scan(struct work_struct *work) + mutex_unlock(&phy0->mutex); + } + ++ /* Enable PHY0 passby for host mode only. */ ++ sun4i_usb_phy_passby(phy, !id_det); ++ + /* Re-route PHY0 if necessary */ + if (data->cfg->phy0_dual_route) + sun4i_usb_phy0_reroute(data, id_det); +diff --git a/drivers/phy/motorola/Kconfig b/drivers/phy/motorola/Kconfig +index 82651524ffb9..718f8729701d 100644 +--- a/drivers/phy/motorola/Kconfig ++++ b/drivers/phy/motorola/Kconfig +@@ -13,7 +13,7 @@ config PHY_CPCAP_USB + + config PHY_MAPPHONE_MDM6600 + tristate "Motorola Mapphone MDM6600 modem USB PHY driver" +- depends on OF && USB_SUPPORT ++ depends on OF && USB_SUPPORT && GPIOLIB + select GENERIC_PHY + help + Enable this for MDM6600 USB modem to work on Motorola phones +diff --git a/drivers/pinctrl/pinctrl-pistachio.c b/drivers/pinctrl/pinctrl-pistachio.c +index 302190d1558d..0d7d379e9bb8 100644 +--- a/drivers/pinctrl/pinctrl-pistachio.c ++++ b/drivers/pinctrl/pinctrl-pistachio.c +@@ -1368,6 +1368,7 @@ static int pistachio_gpio_register(struct pistachio_pinctrl *pctl) + if (!of_find_property(child, "gpio-controller", NULL)) { + dev_err(pctl->dev, + "No gpio-controller property for bank %u\n", i); ++ of_node_put(child); + ret = -ENODEV; + goto err; + } +@@ -1375,6 +1376,7 @@ static int pistachio_gpio_register(struct pistachio_pinctrl *pctl) + irq = irq_of_parse_and_map(child, 0); + if (irq < 0) { + dev_err(pctl->dev, "No IRQ for bank %u: %d\n", i, irq); ++ of_node_put(child); + ret = irq; + goto err; + } +diff --git a/drivers/pinctrl/samsung/pinctrl-exynos-arm.c b/drivers/pinctrl/samsung/pinctrl-exynos-arm.c +index 44c6b753f692..85ddf49a5188 100644 +--- a/drivers/pinctrl/samsung/pinctrl-exynos-arm.c ++++ b/drivers/pinctrl/samsung/pinctrl-exynos-arm.c +@@ -71,6 +71,7 @@ s5pv210_retention_init(struct samsung_pinctrl_drv_data *drvdata, + } + + clk_base = of_iomap(np, 0); ++ of_node_put(np); + if (!clk_base) { + pr_err("%s: failed to map clock registers\n", __func__); + return ERR_PTR(-EINVAL); +diff --git a/drivers/pinctrl/zte/pinctrl-zx.c b/drivers/pinctrl/zte/pinctrl-zx.c +index caa44dd2880a..3cb69309912b 100644 +--- a/drivers/pinctrl/zte/pinctrl-zx.c ++++ b/drivers/pinctrl/zte/pinctrl-zx.c +@@ -411,6 +411,7 @@ int zx_pinctrl_init(struct platform_device *pdev, + } + + zpctl->aux_base = of_iomap(np, 0); ++ of_node_put(np); + if (!zpctl->aux_base) + return -ENOMEM; + +diff --git a/drivers/rtc/rtc-88pm860x.c b/drivers/rtc/rtc-88pm860x.c +index 01ffc0ef8033..fbcf13bbbd8d 100644 +--- a/drivers/rtc/rtc-88pm860x.c ++++ b/drivers/rtc/rtc-88pm860x.c +@@ -414,7 +414,7 @@ static int pm860x_rtc_remove(struct platform_device *pdev) + struct pm860x_rtc_info *info = platform_get_drvdata(pdev); + + #ifdef VRTC_CALIBRATION +- flush_scheduled_work(); ++ cancel_delayed_work_sync(&info->calib_work); + /* disable measurement */ + pm860x_set_bits(info->i2c, PM8607_MEAS_EN2, MEAS2_VRTC, 0); + #endif /* VRTC_CALIBRATION */ +diff --git a/drivers/rtc/rtc-stm32.c b/drivers/rtc/rtc-stm32.c +index c5908cfea234..8e6c9b3bcc29 100644 +--- a/drivers/rtc/rtc-stm32.c ++++ b/drivers/rtc/rtc-stm32.c +@@ -788,11 +788,14 @@ static int stm32_rtc_probe(struct platform_device *pdev) + ret = device_init_wakeup(&pdev->dev, true); + if (rtc->data->has_wakeirq) { + rtc->wakeirq_alarm = platform_get_irq(pdev, 1); +- if (rtc->wakeirq_alarm <= 0) +- ret = rtc->wakeirq_alarm; +- else ++ if (rtc->wakeirq_alarm > 0) { + ret = dev_pm_set_dedicated_wake_irq(&pdev->dev, + rtc->wakeirq_alarm); ++ } else { ++ ret = rtc->wakeirq_alarm; ++ if (rtc->wakeirq_alarm == -EPROBE_DEFER) ++ goto err; ++ } + } + if (ret) + dev_warn(&pdev->dev, "alarm can't wake up the system: %d", ret); +diff --git a/drivers/rtc/rtc-xgene.c b/drivers/rtc/rtc-xgene.c +index 153820876a82..2f741f455c30 100644 +--- a/drivers/rtc/rtc-xgene.c ++++ b/drivers/rtc/rtc-xgene.c +@@ -168,6 +168,10 @@ static int xgene_rtc_probe(struct platform_device *pdev) + if (IS_ERR(pdata->csr_base)) + return PTR_ERR(pdata->csr_base); + ++ pdata->rtc = devm_rtc_allocate_device(&pdev->dev); ++ if (IS_ERR(pdata->rtc)) ++ return PTR_ERR(pdata->rtc); ++ + irq = platform_get_irq(pdev, 0); + if (irq < 0) { + dev_err(&pdev->dev, "No IRQ resource\n"); +@@ -198,15 +202,15 @@ static int xgene_rtc_probe(struct platform_device *pdev) + return ret; + } + +- pdata->rtc = devm_rtc_device_register(&pdev->dev, pdev->name, +- &xgene_rtc_ops, THIS_MODULE); +- if (IS_ERR(pdata->rtc)) { +- clk_disable_unprepare(pdata->clk); +- return PTR_ERR(pdata->rtc); +- } +- + /* HW does not support update faster than 1 seconds */ + pdata->rtc->uie_unsupported = 1; ++ pdata->rtc->ops = &xgene_rtc_ops; ++ ++ ret = rtc_register_device(pdata->rtc); ++ if (ret) { ++ clk_disable_unprepare(pdata->clk); ++ return ret; ++ } + + return 0; + } +diff --git a/drivers/s390/cio/cio.h b/drivers/s390/cio/cio.h +index 9811fd8a0c73..92eabbb5f18d 100644 +--- a/drivers/s390/cio/cio.h ++++ b/drivers/s390/cio/cio.h +@@ -115,7 +115,7 @@ struct subchannel { + struct schib_config config; + } __attribute__ ((aligned(8))); + +-DECLARE_PER_CPU(struct irb, cio_irb); ++DECLARE_PER_CPU_ALIGNED(struct irb, cio_irb); + + #define to_subchannel(n) container_of(n, struct subchannel, dev) + +diff --git a/drivers/s390/cio/vfio_ccw_drv.c b/drivers/s390/cio/vfio_ccw_drv.c +index fabd9798e4c4..7a06cdff6572 100644 +--- a/drivers/s390/cio/vfio_ccw_drv.c ++++ b/drivers/s390/cio/vfio_ccw_drv.c +@@ -40,26 +40,30 @@ int vfio_ccw_sch_quiesce(struct subchannel *sch) + if (ret != -EBUSY) + goto out_unlock; + ++ iretry = 255; + do { +- iretry = 255; + + ret = cio_cancel_halt_clear(sch, &iretry); +- while (ret == -EBUSY) { +- /* +- * Flush all I/O and wait for +- * cancel/halt/clear completion. +- */ +- private->completion = &completion; +- spin_unlock_irq(sch->lock); + +- wait_for_completion_timeout(&completion, 3*HZ); ++ if (ret == -EIO) { ++ pr_err("vfio_ccw: could not quiesce subchannel 0.%x.%04x!\n", ++ sch->schid.ssid, sch->schid.sch_no); ++ break; ++ } ++ ++ /* ++ * Flush all I/O and wait for ++ * cancel/halt/clear completion. ++ */ ++ private->completion = &completion; ++ spin_unlock_irq(sch->lock); + +- spin_lock_irq(sch->lock); +- private->completion = NULL; +- flush_workqueue(vfio_ccw_work_q); +- ret = cio_cancel_halt_clear(sch, &iretry); +- }; ++ if (ret == -EBUSY) ++ wait_for_completion_timeout(&completion, 3*HZ); + ++ private->completion = NULL; ++ flush_workqueue(vfio_ccw_work_q); ++ spin_lock_irq(sch->lock); + ret = cio_disable_subchannel(sch); + } while (ret == -EBUSY); + out_unlock: +diff --git a/drivers/s390/cio/vfio_ccw_ops.c b/drivers/s390/cio/vfio_ccw_ops.c +index f673e106c041..dc5ff47de3fe 100644 +--- a/drivers/s390/cio/vfio_ccw_ops.c ++++ b/drivers/s390/cio/vfio_ccw_ops.c +@@ -130,11 +130,12 @@ static int vfio_ccw_mdev_remove(struct mdev_device *mdev) + + if ((private->state != VFIO_CCW_STATE_NOT_OPER) && + (private->state != VFIO_CCW_STATE_STANDBY)) { +- if (!vfio_ccw_mdev_reset(mdev)) ++ if (!vfio_ccw_sch_quiesce(private->sch)) + private->state = VFIO_CCW_STATE_STANDBY; + /* The state will be NOT_OPER on error. */ + } + ++ cp_free(&private->cp); + private->mdev = NULL; + atomic_inc(&private->avail); + +@@ -158,6 +159,14 @@ static void vfio_ccw_mdev_release(struct mdev_device *mdev) + struct vfio_ccw_private *private = + dev_get_drvdata(mdev_parent_dev(mdev)); + ++ if ((private->state != VFIO_CCW_STATE_NOT_OPER) && ++ (private->state != VFIO_CCW_STATE_STANDBY)) { ++ if (!vfio_ccw_mdev_reset(mdev)) ++ private->state = VFIO_CCW_STATE_STANDBY; ++ /* The state will be NOT_OPER on error. */ ++ } ++ ++ cp_free(&private->cp); + vfio_unregister_notifier(mdev_dev(mdev), VFIO_IOMMU_NOTIFY, + &private->nb); + } +diff --git a/drivers/s390/crypto/zcrypt_api.c b/drivers/s390/crypto/zcrypt_api.c +index e6854127b434..b2737bfeb8bb 100644 +--- a/drivers/s390/crypto/zcrypt_api.c ++++ b/drivers/s390/crypto/zcrypt_api.c +@@ -224,6 +224,7 @@ static long zcrypt_rsa_modexpo(struct ica_rsa_modexpo *mex) + trace_s390_zcrypt_req(mex, TP_ICARSAMODEXPO); + + if (mex->outputdatalength < mex->inputdatalength) { ++ func_code = 0; + rc = -EINVAL; + goto out; + } +@@ -298,6 +299,7 @@ static long zcrypt_rsa_crt(struct ica_rsa_modexpo_crt *crt) + trace_s390_zcrypt_req(crt, TP_ICARSACRT); + + if (crt->outputdatalength < crt->inputdatalength) { ++ func_code = 0; + rc = -EINVAL; + goto out; + } +@@ -483,6 +485,7 @@ static long zcrypt_send_ep11_cprb(struct ep11_urb *xcrb) + + targets = kcalloc(target_num, sizeof(*targets), GFP_KERNEL); + if (!targets) { ++ func_code = 0; + rc = -ENOMEM; + goto out; + } +@@ -490,6 +493,7 @@ static long zcrypt_send_ep11_cprb(struct ep11_urb *xcrb) + uptr = (struct ep11_target_dev __force __user *) xcrb->targets; + if (copy_from_user(targets, uptr, + target_num * sizeof(*targets))) { ++ func_code = 0; + rc = -EFAULT; + goto out_free; + } +diff --git a/drivers/s390/net/qeth_core.h b/drivers/s390/net/qeth_core.h +index 2d1f6a583641..b2657582cfcf 100644 +--- a/drivers/s390/net/qeth_core.h ++++ b/drivers/s390/net/qeth_core.h +@@ -201,6 +201,12 @@ struct qeth_vnicc_info { + bool rx_bcast_enabled; + }; + ++static inline int qeth_is_adp_supported(struct qeth_ipa_info *ipa, ++ enum qeth_ipa_setadp_cmd func) ++{ ++ return (ipa->supported_funcs & func); ++} ++ + static inline int qeth_is_ipa_supported(struct qeth_ipa_info *ipa, + enum qeth_ipa_funcs func) + { +@@ -214,9 +220,7 @@ static inline int qeth_is_ipa_enabled(struct qeth_ipa_info *ipa, + } + + #define qeth_adp_supported(c, f) \ +- qeth_is_ipa_supported(&c->options.adp, f) +-#define qeth_adp_enabled(c, f) \ +- qeth_is_ipa_enabled(&c->options.adp, f) ++ qeth_is_adp_supported(&c->options.adp, f) + #define qeth_is_supported(c, f) \ + qeth_is_ipa_supported(&c->options.ipa4, f) + #define qeth_is_enabled(c, f) \ +diff --git a/drivers/s390/net/qeth_core_main.c b/drivers/s390/net/qeth_core_main.c +index 56aacf32f71b..461afc276db7 100644 +--- a/drivers/s390/net/qeth_core_main.c ++++ b/drivers/s390/net/qeth_core_main.c +@@ -1370,7 +1370,7 @@ static void qeth_set_multiple_write_queues(struct qeth_card *card) + card->qdio.no_out_queues = 4; + } + +-static void qeth_update_from_chp_desc(struct qeth_card *card) ++static int qeth_update_from_chp_desc(struct qeth_card *card) + { + struct ccw_device *ccwdev; + struct channel_path_desc_fmt0 *chp_dsc; +@@ -1380,7 +1380,7 @@ static void qeth_update_from_chp_desc(struct qeth_card *card) + ccwdev = card->data.ccwdev; + chp_dsc = ccw_device_get_chp_desc(ccwdev, 0); + if (!chp_dsc) +- goto out; ++ return -ENOMEM; + + card->info.func_level = 0x4100 + chp_dsc->desc; + if (card->info.type == QETH_CARD_TYPE_IQD) +@@ -1395,6 +1395,7 @@ out: + kfree(chp_dsc); + QETH_DBF_TEXT_(SETUP, 2, "nr:%x", card->qdio.no_out_queues); + QETH_DBF_TEXT_(SETUP, 2, "lvl:%02x", card->info.func_level); ++ return 0; + } + + static void qeth_init_qdio_info(struct qeth_card *card) +@@ -5090,7 +5091,9 @@ int qeth_core_hardsetup_card(struct qeth_card *card) + + QETH_DBF_TEXT(SETUP, 2, "hrdsetup"); + atomic_set(&card->force_alloc_skb, 0); +- qeth_update_from_chp_desc(card); ++ rc = qeth_update_from_chp_desc(card); ++ if (rc) ++ return rc; + retry: + if (retries < 3) + QETH_DBF_MESSAGE(2, "%s Retrying to do IDX activates.\n", +@@ -5768,7 +5771,9 @@ static int qeth_core_probe_device(struct ccwgroup_device *gdev) + gdev->cdev[2]->handler = qeth_irq; + + qeth_setup_card(card); +- qeth_update_from_chp_desc(card); ++ rc = qeth_update_from_chp_desc(card); ++ if (rc) ++ goto err_chp_desc; + + card->dev = qeth_alloc_netdev(card); + if (!card->dev) { +@@ -5806,6 +5811,7 @@ err_disc: + qeth_core_free_discipline(card); + err_load: + free_netdev(card->dev); ++err_chp_desc: + err_card: + qeth_core_free_card(card); + err_dev: +diff --git a/drivers/scsi/libsas/sas_expander.c b/drivers/scsi/libsas/sas_expander.c +index e9ecc667e3fb..231eb79efa32 100644 +--- a/drivers/scsi/libsas/sas_expander.c ++++ b/drivers/scsi/libsas/sas_expander.c +@@ -2040,6 +2040,11 @@ static int sas_rediscover_dev(struct domain_device *dev, int phy_id, bool last) + if ((SAS_ADDR(sas_addr) == 0) || (res == -ECOMM)) { + phy->phy_state = PHY_EMPTY; + sas_unregister_devs_sas_addr(dev, phy_id, last); ++ /* ++ * Even though the PHY is empty, for convenience we discover ++ * the PHY to update the PHY info, like negotiated linkrate. ++ */ ++ sas_ex_phy_discover(dev, phy_id); + return res; + } else if (SAS_ADDR(sas_addr) == SAS_ADDR(phy->attached_sas_addr) && + dev_type_flutter(type, phy->attached_dev_type)) { +diff --git a/drivers/scsi/lpfc/lpfc_ct.c b/drivers/scsi/lpfc/lpfc_ct.c +index 1a964e71582f..d909d90035bb 100644 +--- a/drivers/scsi/lpfc/lpfc_ct.c ++++ b/drivers/scsi/lpfc/lpfc_ct.c +@@ -1762,6 +1762,9 @@ lpfc_fdmi_hba_attr_manufacturer(struct lpfc_vport *vport, + ae = (struct lpfc_fdmi_attr_entry *)&ad->AttrValue; + memset(ae, 0, 256); + ++ /* This string MUST be consistent with other FC platforms ++ * supported by Broadcom. ++ */ + strncpy(ae->un.AttrString, + "Emulex Corporation", + sizeof(ae->un.AttrString)); +@@ -2117,10 +2120,11 @@ lpfc_fdmi_port_attr_fc4type(struct lpfc_vport *vport, + ae = (struct lpfc_fdmi_attr_entry *)&ad->AttrValue; + memset(ae, 0, 32); + +- ae->un.AttrTypes[3] = 0x02; /* Type 1 - ELS */ +- ae->un.AttrTypes[2] = 0x01; /* Type 8 - FCP */ +- ae->un.AttrTypes[6] = 0x01; /* Type 40 - NVME */ +- ae->un.AttrTypes[7] = 0x01; /* Type 32 - CT */ ++ ae->un.AttrTypes[3] = 0x02; /* Type 0x1 - ELS */ ++ ae->un.AttrTypes[2] = 0x01; /* Type 0x8 - FCP */ ++ if (vport->nvmei_support || vport->phba->nvmet_support) ++ ae->un.AttrTypes[6] = 0x01; /* Type 0x28 - NVME */ ++ ae->un.AttrTypes[7] = 0x01; /* Type 0x20 - CT */ + size = FOURBYTES + 32; + ad->AttrLen = cpu_to_be16(size); + ad->AttrType = cpu_to_be16(RPRT_SUPPORTED_FC4_TYPES); +@@ -2425,9 +2429,11 @@ lpfc_fdmi_port_attr_active_fc4type(struct lpfc_vport *vport, + ae = (struct lpfc_fdmi_attr_entry *)&ad->AttrValue; + memset(ae, 0, 32); + +- ae->un.AttrTypes[3] = 0x02; /* Type 1 - ELS */ +- ae->un.AttrTypes[2] = 0x01; /* Type 8 - FCP */ +- ae->un.AttrTypes[7] = 0x01; /* Type 32 - CT */ ++ ae->un.AttrTypes[3] = 0x02; /* Type 0x1 - ELS */ ++ ae->un.AttrTypes[2] = 0x01; /* Type 0x8 - FCP */ ++ if (vport->phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) ++ ae->un.AttrTypes[6] = 0x1; /* Type 0x28 - NVME */ ++ ae->un.AttrTypes[7] = 0x01; /* Type 0x20 - CT */ + size = FOURBYTES + 32; + ad->AttrLen = cpu_to_be16(size); + ad->AttrType = cpu_to_be16(RPRT_ACTIVE_FC4_TYPES); +diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c +index eb71877f12f8..ccdd82b1123f 100644 +--- a/drivers/scsi/lpfc/lpfc_hbadisc.c ++++ b/drivers/scsi/lpfc/lpfc_hbadisc.c +@@ -921,7 +921,11 @@ lpfc_linkdown(struct lpfc_hba *phba) + } + } + lpfc_destroy_vport_work_array(phba, vports); +- /* Clean up any firmware default rpi's */ ++ ++ /* Clean up any SLI3 firmware default rpi's */ ++ if (phba->sli_rev > LPFC_SLI_REV3) ++ goto skip_unreg_did; ++ + mb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); + if (mb) { + lpfc_unreg_did(phba, 0xffff, LPFC_UNREG_ALL_DFLT_RPIS, mb); +@@ -933,6 +937,7 @@ lpfc_linkdown(struct lpfc_hba *phba) + } + } + ++ skip_unreg_did: + /* Setup myDID for link up if we are in pt2pt mode */ + if (phba->pport->fc_flag & FC_PT2PT) { + mb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); +@@ -4855,6 +4860,10 @@ lpfc_unreg_default_rpis(struct lpfc_vport *vport) + LPFC_MBOXQ_t *mbox; + int rc; + ++ /* Unreg DID is an SLI3 operation. */ ++ if (phba->sli_rev > LPFC_SLI_REV3) ++ return; ++ + mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); + if (mbox) { + lpfc_unreg_did(phba, vport->vpi, LPFC_UNREG_ALL_DFLT_RPIS, +diff --git a/drivers/scsi/lpfc/lpfc_nvme.c b/drivers/scsi/lpfc/lpfc_nvme.c +index ca62117a2d13..099f70798fdd 100644 +--- a/drivers/scsi/lpfc/lpfc_nvme.c ++++ b/drivers/scsi/lpfc/lpfc_nvme.c +@@ -2482,15 +2482,15 @@ lpfc_nvme_create_localport(struct lpfc_vport *vport) + if (!cstat) + return -ENOMEM; + ++ if (!IS_ENABLED(CONFIG_NVME_FC)) ++ return ret; ++ + /* localport is allocated from the stack, but the registration + * call allocates heap memory as well as the private area. + */ +-#if (IS_ENABLED(CONFIG_NVME_FC)) ++ + ret = nvme_fc_register_localport(&nfcp_info, &lpfc_nvme_template, + &vport->phba->pcidev->dev, &localport); +-#else +- ret = -ENOMEM; +-#endif + if (!ret) { + lpfc_printf_vlog(vport, KERN_INFO, LOG_NVME | LOG_NVME_DISC, + "6005 Successfully registered local " +diff --git a/drivers/scsi/qedf/qedf_io.c b/drivers/scsi/qedf/qedf_io.c +index 6bbc38b1b465..a17c13846d1e 100644 +--- a/drivers/scsi/qedf/qedf_io.c ++++ b/drivers/scsi/qedf/qedf_io.c +@@ -902,6 +902,7 @@ int qedf_post_io_req(struct qedf_rport *fcport, struct qedf_ioreq *io_req) + if (!test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags)) { + QEDF_ERR(&(qedf->dbg_ctx), "Session not offloaded yet.\n"); + kref_put(&io_req->refcount, qedf_release_cmd); ++ return -EINVAL; + } + + /* Obtain free SQE */ +diff --git a/drivers/scsi/qedi/qedi_iscsi.c b/drivers/scsi/qedi/qedi_iscsi.c +index d4821b9dea45..4130b9117055 100644 +--- a/drivers/scsi/qedi/qedi_iscsi.c ++++ b/drivers/scsi/qedi/qedi_iscsi.c +@@ -1001,6 +1001,9 @@ static void qedi_ep_disconnect(struct iscsi_endpoint *ep) + qedi_ep = ep->dd_data; + qedi = qedi_ep->qedi; + ++ if (qedi_ep->state == EP_STATE_OFLDCONN_START) ++ goto ep_exit_recover; ++ + flush_work(&qedi_ep->offload_work); + + if (qedi_ep->conn) { +diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c +index 36cbb29c84f6..88d8acf86a2a 100644 +--- a/drivers/scsi/qla2xxx/qla_isr.c ++++ b/drivers/scsi/qla2xxx/qla_isr.c +@@ -3449,7 +3449,7 @@ qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp) + ql_log(ql_log_fatal, vha, 0x00c8, + "Failed to allocate memory for ha->msix_entries.\n"); + ret = -ENOMEM; +- goto msix_out; ++ goto free_irqs; + } + ha->flags.msix_enabled = 1; + +@@ -3532,6 +3532,10 @@ msix_register_fail: + + msix_out: + return ret; ++ ++free_irqs: ++ pci_free_irq_vectors(ha->pdev); ++ goto msix_out; + } + + int +diff --git a/drivers/scsi/qla2xxx/qla_target.c b/drivers/scsi/qla2xxx/qla_target.c +index a8c67cd17625..9d7feb005acf 100644 +--- a/drivers/scsi/qla2xxx/qla_target.c ++++ b/drivers/scsi/qla2xxx/qla_target.c +@@ -684,7 +684,6 @@ done: + void qla24xx_do_nack_work(struct scsi_qla_host *vha, struct qla_work_evt *e) + { + fc_port_t *t; +- unsigned long flags; + + switch (e->u.nack.type) { + case SRB_NACK_PRLI: +@@ -694,10 +693,8 @@ void qla24xx_do_nack_work(struct scsi_qla_host *vha, struct qla_work_evt *e) + if (t) { + ql_log(ql_log_info, vha, 0xd034, + "%s create sess success %p", __func__, t); +- spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags); + /* create sess has an extra kref */ + vha->hw->tgt.tgt_ops->put_sess(e->u.nack.fcport); +- spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags); + } + break; + } +@@ -709,9 +706,6 @@ void qla24xx_delete_sess_fn(struct work_struct *work) + { + fc_port_t *fcport = container_of(work, struct fc_port, del_work); + struct qla_hw_data *ha = fcport->vha->hw; +- unsigned long flags; +- +- spin_lock_irqsave(&ha->tgt.sess_lock, flags); + + if (fcport->se_sess) { + ha->tgt.tgt_ops->shutdown_sess(fcport); +@@ -719,7 +713,6 @@ void qla24xx_delete_sess_fn(struct work_struct *work) + } else { + qlt_unreg_sess(fcport); + } +- spin_unlock_irqrestore(&ha->tgt.sess_lock, flags); + } + + /* +@@ -788,8 +781,9 @@ void qlt_fc_port_added(struct scsi_qla_host *vha, fc_port_t *fcport) + fcport->port_name, sess->loop_id); + sess->local = 0; + } +- ha->tgt.tgt_ops->put_sess(sess); + spin_unlock_irqrestore(&ha->tgt.sess_lock, flags); ++ ++ ha->tgt.tgt_ops->put_sess(sess); + } + + /* +@@ -4135,9 +4129,7 @@ static void __qlt_do_work(struct qla_tgt_cmd *cmd) + /* + * Drop extra session reference from qla_tgt_handle_cmd_for_atio*( + */ +- spin_lock_irqsave(&ha->tgt.sess_lock, flags); + ha->tgt.tgt_ops->put_sess(sess); +- spin_unlock_irqrestore(&ha->tgt.sess_lock, flags); + return; + + out_term: +@@ -4154,9 +4146,7 @@ out_term: + target_free_tag(sess->se_sess, &cmd->se_cmd); + spin_unlock_irqrestore(qpair->qp_lock_ptr, flags); + +- spin_lock_irqsave(&ha->tgt.sess_lock, flags); + ha->tgt.tgt_ops->put_sess(sess); +- spin_unlock_irqrestore(&ha->tgt.sess_lock, flags); + } + + static void qlt_do_work(struct work_struct *work) +@@ -4365,9 +4355,7 @@ static int qlt_handle_cmd_for_atio(struct scsi_qla_host *vha, + if (!cmd) { + ql_dbg(ql_dbg_io, vha, 0x3062, + "qla_target(%d): Allocation of cmd failed\n", vha->vp_idx); +- spin_lock_irqsave(&ha->tgt.sess_lock, flags); + ha->tgt.tgt_ops->put_sess(sess); +- spin_unlock_irqrestore(&ha->tgt.sess_lock, flags); + return -EBUSY; + } + +@@ -6105,17 +6093,19 @@ static void qlt_abort_work(struct qla_tgt *tgt, + } + + rc = __qlt_24xx_handle_abts(vha, &prm->abts, sess); +- ha->tgt.tgt_ops->put_sess(sess); + spin_unlock_irqrestore(&ha->tgt.sess_lock, flags2); + ++ ha->tgt.tgt_ops->put_sess(sess); ++ + if (rc != 0) + goto out_term; + return; + + out_term2: ++ spin_unlock_irqrestore(&ha->tgt.sess_lock, flags2); ++ + if (sess) + ha->tgt.tgt_ops->put_sess(sess); +- spin_unlock_irqrestore(&ha->tgt.sess_lock, flags2); + + out_term: + spin_lock_irqsave(&ha->hardware_lock, flags); +@@ -6175,9 +6165,10 @@ static void qlt_tmr_work(struct qla_tgt *tgt, + scsilun_to_int((struct scsi_lun *)&a->u.isp24.fcp_cmnd.lun); + + rc = qlt_issue_task_mgmt(sess, unpacked_lun, fn, iocb, 0); +- ha->tgt.tgt_ops->put_sess(sess); + spin_unlock_irqrestore(&ha->tgt.sess_lock, flags); + ++ ha->tgt.tgt_ops->put_sess(sess); ++ + if (rc != 0) + goto out_term; + return; +diff --git a/drivers/scsi/qla2xxx/tcm_qla2xxx.c b/drivers/scsi/qla2xxx/tcm_qla2xxx.c +index 64e2d859f633..b8c1a739dfbd 100644 +--- a/drivers/scsi/qla2xxx/tcm_qla2xxx.c ++++ b/drivers/scsi/qla2xxx/tcm_qla2xxx.c +@@ -350,7 +350,6 @@ static void tcm_qla2xxx_put_sess(struct fc_port *sess) + if (!sess) + return; + +- assert_spin_locked(&sess->vha->hw->tgt.sess_lock); + kref_put(&sess->sess_kref, tcm_qla2xxx_release_session); + } + +@@ -365,8 +364,9 @@ static void tcm_qla2xxx_close_session(struct se_session *se_sess) + + spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags); + target_sess_cmd_list_set_waiting(se_sess); +- tcm_qla2xxx_put_sess(sess); + spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags); ++ ++ tcm_qla2xxx_put_sess(sess); + } + + static u32 tcm_qla2xxx_sess_get_index(struct se_session *se_sess) +@@ -390,6 +390,8 @@ static int tcm_qla2xxx_write_pending(struct se_cmd *se_cmd) + cmd->se_cmd.transport_state, + cmd->se_cmd.t_state, + cmd->se_cmd.se_cmd_flags); ++ transport_generic_request_failure(&cmd->se_cmd, ++ TCM_CHECK_CONDITION_ABORT_CMD); + return 0; + } + cmd->trc_flags |= TRC_XFR_RDY; +@@ -829,7 +831,6 @@ static void tcm_qla2xxx_clear_nacl_from_fcport_map(struct fc_port *sess) + + static void tcm_qla2xxx_shutdown_sess(struct fc_port *sess) + { +- assert_spin_locked(&sess->vha->hw->tgt.sess_lock); + target_sess_cmd_list_set_waiting(sess->se_sess); + } + +diff --git a/drivers/scsi/qla4xxx/ql4_os.c b/drivers/scsi/qla4xxx/ql4_os.c +index 5dd3e4e01b10..25c8ce54a976 100644 +--- a/drivers/scsi/qla4xxx/ql4_os.c ++++ b/drivers/scsi/qla4xxx/ql4_os.c +@@ -5935,7 +5935,7 @@ static int get_fw_boot_info(struct scsi_qla_host *ha, uint16_t ddb_index[]) + val = rd_nvram_byte(ha, sec_addr); + if (val & BIT_7) + ddb_index[1] = (val & 0x7f); +- ++ goto exit_boot_info; + } else if (is_qla80XX(ha)) { + buf = dma_alloc_coherent(&ha->pdev->dev, size, + &buf_dma, GFP_KERNEL); +diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c +index e925eda93191..77cb45ef55fc 100644 +--- a/drivers/scsi/sd.c ++++ b/drivers/scsi/sd.c +@@ -2605,7 +2605,6 @@ sd_read_write_protect_flag(struct scsi_disk *sdkp, unsigned char *buffer) + int res; + struct scsi_device *sdp = sdkp->device; + struct scsi_mode_data data; +- int disk_ro = get_disk_ro(sdkp->disk); + int old_wp = sdkp->write_prot; + + set_disk_ro(sdkp->disk, 0); +@@ -2646,7 +2645,7 @@ sd_read_write_protect_flag(struct scsi_disk *sdkp, unsigned char *buffer) + "Test WP failed, assume Write Enabled\n"); + } else { + sdkp->write_prot = ((data.device_specific & 0x80) != 0); +- set_disk_ro(sdkp->disk, sdkp->write_prot || disk_ro); ++ set_disk_ro(sdkp->disk, sdkp->write_prot); + if (sdkp->first_scan || old_wp != sdkp->write_prot) { + sd_printk(KERN_NOTICE, sdkp, "Write Protect is %s\n", + sdkp->write_prot ? "on" : "off"); +diff --git a/drivers/scsi/ufs/ufs-hisi.c b/drivers/scsi/ufs/ufs-hisi.c +index 452e19f8fb47..c2cee73a8560 100644 +--- a/drivers/scsi/ufs/ufs-hisi.c ++++ b/drivers/scsi/ufs/ufs-hisi.c +@@ -544,6 +544,10 @@ static int ufs_hisi_init_common(struct ufs_hba *hba) + ufshcd_set_variant(hba, host); + + host->rst = devm_reset_control_get(dev, "rst"); ++ if (IS_ERR(host->rst)) { ++ dev_err(dev, "%s: failed to get reset control\n", __func__); ++ return PTR_ERR(host->rst); ++ } + + ufs_hisi_set_pm_lvl(hba); + +diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c +index 6e80dfe4fa97..3183fa8c5857 100644 +--- a/drivers/scsi/ufs/ufshcd.c ++++ b/drivers/scsi/ufs/ufshcd.c +@@ -6130,19 +6130,19 @@ static u32 ufshcd_find_max_sup_active_icc_level(struct ufs_hba *hba, + goto out; + } + +- if (hba->vreg_info.vcc) ++ if (hba->vreg_info.vcc && hba->vreg_info.vcc->max_uA) + icc_level = ufshcd_get_max_icc_level( + hba->vreg_info.vcc->max_uA, + POWER_DESC_MAX_ACTV_ICC_LVLS - 1, + &desc_buf[PWR_DESC_ACTIVE_LVLS_VCC_0]); + +- if (hba->vreg_info.vccq) ++ if (hba->vreg_info.vccq && hba->vreg_info.vccq->max_uA) + icc_level = ufshcd_get_max_icc_level( + hba->vreg_info.vccq->max_uA, + icc_level, + &desc_buf[PWR_DESC_ACTIVE_LVLS_VCCQ_0]); + +- if (hba->vreg_info.vccq2) ++ if (hba->vreg_info.vccq2 && hba->vreg_info.vccq2->max_uA) + icc_level = ufshcd_get_max_icc_level( + hba->vreg_info.vccq2->max_uA, + icc_level, +@@ -6767,6 +6767,15 @@ static int ufshcd_config_vreg_load(struct device *dev, struct ufs_vreg *vreg, + if (!vreg) + return 0; + ++ /* ++ * "set_load" operation shall be required on those regulators ++ * which specifically configured current limitation. Otherwise ++ * zero max_uA may cause unexpected behavior when regulator is ++ * enabled or set as high power mode. ++ */ ++ if (!vreg->max_uA) ++ return 0; ++ + ret = regulator_set_load(vreg->reg, ua); + if (ret < 0) { + dev_err(dev, "%s: %s set load (ua=%d) failed, err=%d\n", +@@ -6813,12 +6822,15 @@ static int ufshcd_config_vreg(struct device *dev, + name = vreg->name; + + if (regulator_count_voltages(reg) > 0) { +- min_uV = on ? vreg->min_uV : 0; +- ret = regulator_set_voltage(reg, min_uV, vreg->max_uV); +- if (ret) { +- dev_err(dev, "%s: %s set voltage failed, err=%d\n", ++ if (vreg->min_uV && vreg->max_uV) { ++ min_uV = on ? vreg->min_uV : 0; ++ ret = regulator_set_voltage(reg, min_uV, vreg->max_uV); ++ if (ret) { ++ dev_err(dev, ++ "%s: %s set voltage failed, err=%d\n", + __func__, name, ret); +- goto out; ++ goto out; ++ } + } + + uA_load = on ? vreg->max_uA : 0; +diff --git a/drivers/slimbus/qcom-ngd-ctrl.c b/drivers/slimbus/qcom-ngd-ctrl.c +index 14a9d18306cb..f63d1b8a0933 100644 +--- a/drivers/slimbus/qcom-ngd-ctrl.c ++++ b/drivers/slimbus/qcom-ngd-ctrl.c +@@ -1331,6 +1331,10 @@ static int of_qcom_slim_ngd_register(struct device *parent, + return -ENOMEM; + + ngd->pdev = platform_device_alloc(QCOM_SLIM_NGD_DRV_NAME, id); ++ if (!ngd->pdev) { ++ kfree(ngd); ++ return -ENOMEM; ++ } + ngd->id = id; + ngd->pdev->dev.parent = parent; + ngd->pdev->driver_override = QCOM_SLIM_NGD_DRV_NAME; +diff --git a/drivers/spi/spi-imx.c b/drivers/spi/spi-imx.c +index 08dd3a31a3e5..5b6f3655c366 100644 +--- a/drivers/spi/spi-imx.c ++++ b/drivers/spi/spi-imx.c +@@ -1427,7 +1427,7 @@ static int spi_imx_transfer(struct spi_device *spi, + + /* flush rxfifo before transfer */ + while (spi_imx->devtype_data->rx_available(spi_imx)) +- spi_imx->rx(spi_imx); ++ readl(spi_imx->base + MXC_CSPIRXDATA); + + if (spi_imx->slave_mode) + return spi_imx_pio_transfer_slave(spi, transfer); +diff --git a/drivers/spi/spi-pxa2xx.c b/drivers/spi/spi-pxa2xx.c +index b624f6fb04ce..729be74621e3 100644 +--- a/drivers/spi/spi-pxa2xx.c ++++ b/drivers/spi/spi-pxa2xx.c +@@ -876,10 +876,14 @@ static unsigned int ssp_get_clk_div(struct driver_data *drv_data, int rate) + + rate = min_t(int, ssp_clk, rate); + ++ /* ++ * Calculate the divisor for the SCR (Serial Clock Rate), avoiding ++ * that the SSP transmission rate can be greater than the device rate ++ */ + if (ssp->type == PXA25x_SSP || ssp->type == CE4100_SSP) +- return (ssp_clk / (2 * rate) - 1) & 0xff; ++ return (DIV_ROUND_UP(ssp_clk, 2 * rate) - 1) & 0xff; + else +- return (ssp_clk / rate - 1) & 0xfff; ++ return (DIV_ROUND_UP(ssp_clk, rate) - 1) & 0xfff; + } + + static unsigned int pxa2xx_ssp_get_clk_div(struct driver_data *drv_data, +diff --git a/drivers/spi/spi-rspi.c b/drivers/spi/spi-rspi.c +index b37de1d991d6..d61120822f02 100644 +--- a/drivers/spi/spi-rspi.c ++++ b/drivers/spi/spi-rspi.c +@@ -279,7 +279,8 @@ static int rspi_set_config_register(struct rspi_data *rspi, int access_size) + /* Sets parity, interrupt mask */ + rspi_write8(rspi, 0x00, RSPI_SPCR2); + +- /* Sets SPCMD */ ++ /* Resets sequencer */ ++ rspi_write8(rspi, 0, RSPI_SPSCR); + rspi->spcmd |= SPCMD_SPB_8_TO_16(access_size); + rspi_write16(rspi, rspi->spcmd, RSPI_SPCMD0); + +@@ -323,7 +324,8 @@ static int rspi_rz_set_config_register(struct rspi_data *rspi, int access_size) + rspi_write8(rspi, 0x00, RSPI_SSLND); + rspi_write8(rspi, 0x00, RSPI_SPND); + +- /* Sets SPCMD */ ++ /* Resets sequencer */ ++ rspi_write8(rspi, 0, RSPI_SPSCR); + rspi->spcmd |= SPCMD_SPB_8_TO_16(access_size); + rspi_write16(rspi, rspi->spcmd, RSPI_SPCMD0); + +@@ -374,7 +376,8 @@ static int qspi_set_config_register(struct rspi_data *rspi, int access_size) + /* Sets buffer to allow normal operation */ + rspi_write8(rspi, 0x00, QSPI_SPBFCR); + +- /* Sets SPCMD */ ++ /* Resets sequencer */ ++ rspi_write8(rspi, 0, RSPI_SPSCR); + rspi_write16(rspi, rspi->spcmd, RSPI_SPCMD0); + + /* Sets RSPI mode */ +diff --git a/drivers/spi/spi-tegra114.c b/drivers/spi/spi-tegra114.c +index a76acedd7e2f..a1888dc6a938 100644 +--- a/drivers/spi/spi-tegra114.c ++++ b/drivers/spi/spi-tegra114.c +@@ -1067,27 +1067,19 @@ static int tegra_spi_probe(struct platform_device *pdev) + + spi_irq = platform_get_irq(pdev, 0); + tspi->irq = spi_irq; +- ret = request_threaded_irq(tspi->irq, tegra_spi_isr, +- tegra_spi_isr_thread, IRQF_ONESHOT, +- dev_name(&pdev->dev), tspi); +- if (ret < 0) { +- dev_err(&pdev->dev, "Failed to register ISR for IRQ %d\n", +- tspi->irq); +- goto exit_free_master; +- } + + tspi->clk = devm_clk_get(&pdev->dev, "spi"); + if (IS_ERR(tspi->clk)) { + dev_err(&pdev->dev, "can not get clock\n"); + ret = PTR_ERR(tspi->clk); +- goto exit_free_irq; ++ goto exit_free_master; + } + + tspi->rst = devm_reset_control_get_exclusive(&pdev->dev, "spi"); + if (IS_ERR(tspi->rst)) { + dev_err(&pdev->dev, "can not get reset\n"); + ret = PTR_ERR(tspi->rst); +- goto exit_free_irq; ++ goto exit_free_master; + } + + tspi->max_buf_size = SPI_FIFO_DEPTH << 2; +@@ -1095,7 +1087,7 @@ static int tegra_spi_probe(struct platform_device *pdev) + + ret = tegra_spi_init_dma_param(tspi, true); + if (ret < 0) +- goto exit_free_irq; ++ goto exit_free_master; + ret = tegra_spi_init_dma_param(tspi, false); + if (ret < 0) + goto exit_rx_dma_free; +@@ -1117,18 +1109,32 @@ static int tegra_spi_probe(struct platform_device *pdev) + dev_err(&pdev->dev, "pm runtime get failed, e = %d\n", ret); + goto exit_pm_disable; + } ++ ++ reset_control_assert(tspi->rst); ++ udelay(2); ++ reset_control_deassert(tspi->rst); + tspi->def_command1_reg = SPI_M_S; + tegra_spi_writel(tspi, tspi->def_command1_reg, SPI_COMMAND1); + pm_runtime_put(&pdev->dev); ++ ret = request_threaded_irq(tspi->irq, tegra_spi_isr, ++ tegra_spi_isr_thread, IRQF_ONESHOT, ++ dev_name(&pdev->dev), tspi); ++ if (ret < 0) { ++ dev_err(&pdev->dev, "Failed to register ISR for IRQ %d\n", ++ tspi->irq); ++ goto exit_pm_disable; ++ } + + master->dev.of_node = pdev->dev.of_node; + ret = devm_spi_register_master(&pdev->dev, master); + if (ret < 0) { + dev_err(&pdev->dev, "can not register to master err %d\n", ret); +- goto exit_pm_disable; ++ goto exit_free_irq; + } + return ret; + ++exit_free_irq: ++ free_irq(spi_irq, tspi); + exit_pm_disable: + pm_runtime_disable(&pdev->dev); + if (!pm_runtime_status_suspended(&pdev->dev)) +@@ -1136,8 +1142,6 @@ exit_pm_disable: + tegra_spi_deinit_dma_param(tspi, false); + exit_rx_dma_free: + tegra_spi_deinit_dma_param(tspi, true); +-exit_free_irq: +- free_irq(spi_irq, tspi); + exit_free_master: + spi_master_put(master); + return ret; +diff --git a/drivers/spi/spi-topcliff-pch.c b/drivers/spi/spi-topcliff-pch.c +index 97d137591b18..4389ab80c23e 100644 +--- a/drivers/spi/spi-topcliff-pch.c ++++ b/drivers/spi/spi-topcliff-pch.c +@@ -1294,18 +1294,27 @@ static void pch_free_dma_buf(struct pch_spi_board_data *board_dat, + dma->rx_buf_virt, dma->rx_buf_dma); + } + +-static void pch_alloc_dma_buf(struct pch_spi_board_data *board_dat, ++static int pch_alloc_dma_buf(struct pch_spi_board_data *board_dat, + struct pch_spi_data *data) + { + struct pch_spi_dma_ctrl *dma; ++ int ret; + + dma = &data->dma; ++ ret = 0; + /* Get Consistent memory for Tx DMA */ + dma->tx_buf_virt = dma_alloc_coherent(&board_dat->pdev->dev, + PCH_BUF_SIZE, &dma->tx_buf_dma, GFP_KERNEL); ++ if (!dma->tx_buf_virt) ++ ret = -ENOMEM; ++ + /* Get Consistent memory for Rx DMA */ + dma->rx_buf_virt = dma_alloc_coherent(&board_dat->pdev->dev, + PCH_BUF_SIZE, &dma->rx_buf_dma, GFP_KERNEL); ++ if (!dma->rx_buf_virt) ++ ret = -ENOMEM; ++ ++ return ret; + } + + static int pch_spi_pd_probe(struct platform_device *plat_dev) +@@ -1382,7 +1391,9 @@ static int pch_spi_pd_probe(struct platform_device *plat_dev) + + if (use_dma) { + dev_info(&plat_dev->dev, "Use DMA for data transfers\n"); +- pch_alloc_dma_buf(board_dat, data); ++ ret = pch_alloc_dma_buf(board_dat, data); ++ if (ret) ++ goto err_spi_register_master; + } + + ret = spi_register_master(master); +diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c +index 9da0bc5a036c..88a8a8edd44b 100644 +--- a/drivers/spi/spi.c ++++ b/drivers/spi/spi.c +@@ -982,6 +982,8 @@ static int spi_map_msg(struct spi_controller *ctlr, struct spi_message *msg) + if (max_tx || max_rx) { + list_for_each_entry(xfer, &msg->transfers, + transfer_list) { ++ if (!xfer->len) ++ continue; + if (!xfer->tx_buf) + xfer->tx_buf = ctlr->dummy_tx; + if (!xfer->rx_buf) +diff --git a/drivers/ssb/bridge_pcmcia_80211.c b/drivers/ssb/bridge_pcmcia_80211.c +index f51f150307df..ffa379efff83 100644 +--- a/drivers/ssb/bridge_pcmcia_80211.c ++++ b/drivers/ssb/bridge_pcmcia_80211.c +@@ -113,16 +113,21 @@ static struct pcmcia_driver ssb_host_pcmcia_driver = { + .resume = ssb_host_pcmcia_resume, + }; + ++static int pcmcia_init_failed; ++ + /* + * These are not module init/exit functions! + * The module_pcmcia_driver() helper cannot be used here. + */ + int ssb_host_pcmcia_init(void) + { +- return pcmcia_register_driver(&ssb_host_pcmcia_driver); ++ pcmcia_init_failed = pcmcia_register_driver(&ssb_host_pcmcia_driver); ++ ++ return pcmcia_init_failed; + } + + void ssb_host_pcmcia_exit(void) + { +- pcmcia_unregister_driver(&ssb_host_pcmcia_driver); ++ if (!pcmcia_init_failed) ++ pcmcia_unregister_driver(&ssb_host_pcmcia_driver); + } +diff --git a/drivers/staging/media/davinci_vpfe/Kconfig b/drivers/staging/media/davinci_vpfe/Kconfig +index aea449a8dbf8..76818cc48ddc 100644 +--- a/drivers/staging/media/davinci_vpfe/Kconfig ++++ b/drivers/staging/media/davinci_vpfe/Kconfig +@@ -1,7 +1,7 @@ + config VIDEO_DM365_VPFE + tristate "DM365 VPFE Media Controller Capture Driver" + depends on VIDEO_V4L2 +- depends on (ARCH_DAVINCI_DM365 && !VIDEO_DM365_ISIF) || COMPILE_TEST ++ depends on (ARCH_DAVINCI_DM365 && !VIDEO_DM365_ISIF) || (COMPILE_TEST && !ARCH_OMAP1) + depends on VIDEO_V4L2_SUBDEV_API + depends on VIDEO_DAVINCI_VPBE_DISPLAY + select VIDEOBUF2_DMA_CONTIG +diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_2835_arm.c b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_2835_arm.c +index e76720903064..c7c8ef67b67f 100644 +--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_2835_arm.c ++++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_2835_arm.c +@@ -208,6 +208,9 @@ vchiq_platform_init_state(VCHIQ_STATE_T *state) + struct vchiq_2835_state *platform_state; + + state->platform_state = kzalloc(sizeof(*platform_state), GFP_KERNEL); ++ if (!state->platform_state) ++ return VCHIQ_ERROR; ++ + platform_state = (struct vchiq_2835_state *)state->platform_state; + + platform_state->inited = 1; +diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c +index 7642ced31436..63ce567eb6b7 100644 +--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c ++++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c +@@ -2537,6 +2537,8 @@ vchiq_init_state(VCHIQ_STATE_T *state, VCHIQ_SLOT_ZERO_T *slot_zero, + local->debug[DEBUG_ENTRIES] = DEBUG_MAX; + + status = vchiq_platform_init_state(state); ++ if (status != VCHIQ_SUCCESS) ++ return VCHIQ_ERROR; + + /* + bring up slot handler thread +diff --git a/drivers/thunderbolt/icm.c b/drivers/thunderbolt/icm.c +index 28fc4ce75edb..8490a1b6b615 100644 +--- a/drivers/thunderbolt/icm.c ++++ b/drivers/thunderbolt/icm.c +@@ -476,6 +476,11 @@ static void add_switch(struct tb_switch *parent_sw, u64 route, + goto out; + + sw->uuid = kmemdup(uuid, sizeof(*uuid), GFP_KERNEL); ++ if (!sw->uuid) { ++ tb_sw_warn(sw, "cannot allocate memory for switch\n"); ++ tb_switch_put(sw); ++ goto out; ++ } + sw->connection_id = connection_id; + sw->connection_key = connection_key; + sw->link = link; +diff --git a/drivers/thunderbolt/property.c b/drivers/thunderbolt/property.c +index 8fe913a95b4a..be3f8b592b05 100644 +--- a/drivers/thunderbolt/property.c ++++ b/drivers/thunderbolt/property.c +@@ -551,6 +551,11 @@ int tb_property_add_data(struct tb_property_dir *parent, const char *key, + + property->length = size / 4; + property->value.data = kzalloc(size, GFP_KERNEL); ++ if (!property->value.data) { ++ kfree(property); ++ return -ENOMEM; ++ } ++ + memcpy(property->value.data, buf, buflen); + + list_add_tail(&property->list, &parent->properties); +@@ -581,7 +586,12 @@ int tb_property_add_text(struct tb_property_dir *parent, const char *key, + return -ENOMEM; + + property->length = size / 4; +- property->value.data = kzalloc(size, GFP_KERNEL); ++ property->value.text = kzalloc(size, GFP_KERNEL); ++ if (!property->value.text) { ++ kfree(property); ++ return -ENOMEM; ++ } ++ + strcpy(property->value.text, text); + + list_add_tail(&property->list, &parent->properties); +diff --git a/drivers/thunderbolt/switch.c b/drivers/thunderbolt/switch.c +index dd9ae6f5d19c..bc7efa6e515d 100644 +--- a/drivers/thunderbolt/switch.c ++++ b/drivers/thunderbolt/switch.c +@@ -9,15 +9,13 @@ + #include <linux/idr.h> + #include <linux/nvmem-provider.h> + #include <linux/pm_runtime.h> ++#include <linux/sched/signal.h> + #include <linux/sizes.h> + #include <linux/slab.h> + #include <linux/vmalloc.h> + + #include "tb.h" + +-/* Switch authorization from userspace is serialized by this lock */ +-static DEFINE_MUTEX(switch_lock); +- + /* Switch NVM support */ + + #define NVM_DEVID 0x05 +@@ -253,8 +251,8 @@ static int tb_switch_nvm_write(void *priv, unsigned int offset, void *val, + struct tb_switch *sw = priv; + int ret = 0; + +- if (mutex_lock_interruptible(&switch_lock)) +- return -ERESTARTSYS; ++ if (!mutex_trylock(&sw->tb->lock)) ++ return restart_syscall(); + + /* + * Since writing the NVM image might require some special steps, +@@ -274,7 +272,7 @@ static int tb_switch_nvm_write(void *priv, unsigned int offset, void *val, + memcpy(sw->nvm->buf + offset, val, bytes); + + unlock: +- mutex_unlock(&switch_lock); ++ mutex_unlock(&sw->tb->lock); + + return ret; + } +@@ -363,10 +361,7 @@ static int tb_switch_nvm_add(struct tb_switch *sw) + } + nvm->non_active = nvm_dev; + +- mutex_lock(&switch_lock); + sw->nvm = nvm; +- mutex_unlock(&switch_lock); +- + return 0; + + err_nvm_active: +@@ -383,10 +378,8 @@ static void tb_switch_nvm_remove(struct tb_switch *sw) + { + struct tb_switch_nvm *nvm; + +- mutex_lock(&switch_lock); + nvm = sw->nvm; + sw->nvm = NULL; +- mutex_unlock(&switch_lock); + + if (!nvm) + return; +@@ -717,8 +710,8 @@ static int tb_switch_set_authorized(struct tb_switch *sw, unsigned int val) + { + int ret = -EINVAL; + +- if (mutex_lock_interruptible(&switch_lock)) +- return -ERESTARTSYS; ++ if (!mutex_trylock(&sw->tb->lock)) ++ return restart_syscall(); + + if (sw->authorized) + goto unlock; +@@ -761,7 +754,7 @@ static int tb_switch_set_authorized(struct tb_switch *sw, unsigned int val) + } + + unlock: +- mutex_unlock(&switch_lock); ++ mutex_unlock(&sw->tb->lock); + return ret; + } + +@@ -818,15 +811,15 @@ static ssize_t key_show(struct device *dev, struct device_attribute *attr, + struct tb_switch *sw = tb_to_switch(dev); + ssize_t ret; + +- if (mutex_lock_interruptible(&switch_lock)) +- return -ERESTARTSYS; ++ if (!mutex_trylock(&sw->tb->lock)) ++ return restart_syscall(); + + if (sw->key) + ret = sprintf(buf, "%*phN\n", TB_SWITCH_KEY_SIZE, sw->key); + else + ret = sprintf(buf, "\n"); + +- mutex_unlock(&switch_lock); ++ mutex_unlock(&sw->tb->lock); + return ret; + } + +@@ -843,8 +836,8 @@ static ssize_t key_store(struct device *dev, struct device_attribute *attr, + else if (hex2bin(key, buf, sizeof(key))) + return -EINVAL; + +- if (mutex_lock_interruptible(&switch_lock)) +- return -ERESTARTSYS; ++ if (!mutex_trylock(&sw->tb->lock)) ++ return restart_syscall(); + + if (sw->authorized) { + ret = -EBUSY; +@@ -859,7 +852,7 @@ static ssize_t key_store(struct device *dev, struct device_attribute *attr, + } + } + +- mutex_unlock(&switch_lock); ++ mutex_unlock(&sw->tb->lock); + return ret; + } + static DEVICE_ATTR(key, 0600, key_show, key_store); +@@ -905,8 +898,8 @@ static ssize_t nvm_authenticate_store(struct device *dev, + bool val; + int ret; + +- if (mutex_lock_interruptible(&switch_lock)) +- return -ERESTARTSYS; ++ if (!mutex_trylock(&sw->tb->lock)) ++ return restart_syscall(); + + /* If NVMem devices are not yet added */ + if (!sw->nvm) { +@@ -954,7 +947,7 @@ static ssize_t nvm_authenticate_store(struct device *dev, + } + + exit_unlock: +- mutex_unlock(&switch_lock); ++ mutex_unlock(&sw->tb->lock); + + if (ret) + return ret; +@@ -968,8 +961,8 @@ static ssize_t nvm_version_show(struct device *dev, + struct tb_switch *sw = tb_to_switch(dev); + int ret; + +- if (mutex_lock_interruptible(&switch_lock)) +- return -ERESTARTSYS; ++ if (!mutex_trylock(&sw->tb->lock)) ++ return restart_syscall(); + + if (sw->safe_mode) + ret = -ENODATA; +@@ -978,7 +971,7 @@ static ssize_t nvm_version_show(struct device *dev, + else + ret = sprintf(buf, "%x.%x\n", sw->nvm->major, sw->nvm->minor); + +- mutex_unlock(&switch_lock); ++ mutex_unlock(&sw->tb->lock); + + return ret; + } +@@ -1296,13 +1289,14 @@ int tb_switch_configure(struct tb_switch *sw) + return tb_plug_events_active(sw, true); + } + +-static void tb_switch_set_uuid(struct tb_switch *sw) ++static int tb_switch_set_uuid(struct tb_switch *sw) + { + u32 uuid[4]; +- int cap; ++ int cap, ret; + ++ ret = 0; + if (sw->uuid) +- return; ++ return ret; + + /* + * The newer controllers include fused UUID as part of link +@@ -1310,7 +1304,9 @@ static void tb_switch_set_uuid(struct tb_switch *sw) + */ + cap = tb_switch_find_vse_cap(sw, TB_VSE_CAP_LINK_CONTROLLER); + if (cap > 0) { +- tb_sw_read(sw, uuid, TB_CFG_SWITCH, cap + 3, 4); ++ ret = tb_sw_read(sw, uuid, TB_CFG_SWITCH, cap + 3, 4); ++ if (ret) ++ return ret; + } else { + /* + * ICM generates UUID based on UID and fills the upper +@@ -1325,6 +1321,9 @@ static void tb_switch_set_uuid(struct tb_switch *sw) + } + + sw->uuid = kmemdup(uuid, sizeof(uuid), GFP_KERNEL); ++ if (!sw->uuid) ++ ret = -ENOMEM; ++ return ret; + } + + static int tb_switch_add_dma_port(struct tb_switch *sw) +@@ -1374,7 +1373,9 @@ static int tb_switch_add_dma_port(struct tb_switch *sw) + + if (status) { + tb_sw_info(sw, "switch flash authentication failed\n"); +- tb_switch_set_uuid(sw); ++ ret = tb_switch_set_uuid(sw); ++ if (ret) ++ return ret; + nvm_set_auth_status(sw, status); + } + +@@ -1424,7 +1425,9 @@ int tb_switch_add(struct tb_switch *sw) + } + tb_sw_info(sw, "uid: %#llx\n", sw->uid); + +- tb_switch_set_uuid(sw); ++ ret = tb_switch_set_uuid(sw); ++ if (ret) ++ return ret; + + for (i = 0; i <= sw->config.max_port_number; i++) { + if (sw->ports[i].disabled) { +diff --git a/drivers/thunderbolt/tb.h b/drivers/thunderbolt/tb.h +index 5067d69d0501..7a0ee9836a8a 100644 +--- a/drivers/thunderbolt/tb.h ++++ b/drivers/thunderbolt/tb.h +@@ -79,8 +79,7 @@ struct tb_switch_nvm { + * @depth: Depth in the chain this switch is connected (ICM only) + * + * When the switch is being added or removed to the domain (other +- * switches) you need to have domain lock held. For switch authorization +- * internal switch_lock is enough. ++ * switches) you need to have domain lock held. + */ + struct tb_switch { + struct device dev; +diff --git a/drivers/thunderbolt/xdomain.c b/drivers/thunderbolt/xdomain.c +index db8bece63327..befe75490697 100644 +--- a/drivers/thunderbolt/xdomain.c ++++ b/drivers/thunderbolt/xdomain.c +@@ -743,6 +743,7 @@ static void enumerate_services(struct tb_xdomain *xd) + struct tb_service *svc; + struct tb_property *p; + struct device *dev; ++ int id; + + /* + * First remove all services that are not available anymore in +@@ -771,7 +772,12 @@ static void enumerate_services(struct tb_xdomain *xd) + break; + } + +- svc->id = ida_simple_get(&xd->service_ids, 0, 0, GFP_KERNEL); ++ id = ida_simple_get(&xd->service_ids, 0, 0, GFP_KERNEL); ++ if (id < 0) { ++ kfree(svc); ++ break; ++ } ++ svc->id = id; + svc->dev.bus = &tb_bus_type; + svc->dev.type = &tb_service_type; + svc->dev.parent = &xd->dev; +diff --git a/drivers/tty/ipwireless/main.c b/drivers/tty/ipwireless/main.c +index 3475e841ef5c..4c18bbfe1a92 100644 +--- a/drivers/tty/ipwireless/main.c ++++ b/drivers/tty/ipwireless/main.c +@@ -114,6 +114,10 @@ static int ipwireless_probe(struct pcmcia_device *p_dev, void *priv_data) + + ipw->common_memory = ioremap(p_dev->resource[2]->start, + resource_size(p_dev->resource[2])); ++ if (!ipw->common_memory) { ++ ret = -ENOMEM; ++ goto exit1; ++ } + if (!request_mem_region(p_dev->resource[2]->start, + resource_size(p_dev->resource[2]), + IPWIRELESS_PCCARD_NAME)) { +@@ -134,6 +138,10 @@ static int ipwireless_probe(struct pcmcia_device *p_dev, void *priv_data) + + ipw->attr_memory = ioremap(p_dev->resource[3]->start, + resource_size(p_dev->resource[3])); ++ if (!ipw->attr_memory) { ++ ret = -ENOMEM; ++ goto exit3; ++ } + if (!request_mem_region(p_dev->resource[3]->start, + resource_size(p_dev->resource[3]), + IPWIRELESS_PCCARD_NAME)) { +diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c +index 1c21955fe7c0..b82a7d787add 100644 +--- a/drivers/usb/core/hcd.c ++++ b/drivers/usb/core/hcd.c +@@ -3017,6 +3017,9 @@ usb_hcd_platform_shutdown(struct platform_device *dev) + { + struct usb_hcd *hcd = platform_get_drvdata(dev); + ++ /* No need for pm_runtime_put(), we're shutting down */ ++ pm_runtime_get_sync(&dev->dev); ++ + if (hcd->driver->shutdown) + hcd->driver->shutdown(hcd); + } +diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c +index bbcfa63d0233..eb24ec0e160d 100644 +--- a/drivers/usb/core/hub.c ++++ b/drivers/usb/core/hub.c +@@ -5823,7 +5823,10 @@ int usb_reset_device(struct usb_device *udev) + cintf->needs_binding = 1; + } + } +- usb_unbind_and_rebind_marked_interfaces(udev); ++ ++ /* If the reset failed, hub_wq will unbind drivers later */ ++ if (ret == 0) ++ usb_unbind_and_rebind_marked_interfaces(udev); + } + + usb_autosuspend_device(udev); +diff --git a/drivers/usb/dwc2/gadget.c b/drivers/usb/dwc2/gadget.c +index 220c0f9b89b0..03614ef64ca4 100644 +--- a/drivers/usb/dwc2/gadget.c ++++ b/drivers/usb/dwc2/gadget.c +@@ -675,13 +675,11 @@ static unsigned int dwc2_gadget_get_chain_limit(struct dwc2_hsotg_ep *hs_ep) + unsigned int maxsize; + + if (is_isoc) +- maxsize = hs_ep->dir_in ? DEV_DMA_ISOC_TX_NBYTES_LIMIT : +- DEV_DMA_ISOC_RX_NBYTES_LIMIT; ++ maxsize = (hs_ep->dir_in ? DEV_DMA_ISOC_TX_NBYTES_LIMIT : ++ DEV_DMA_ISOC_RX_NBYTES_LIMIT) * ++ MAX_DMA_DESC_NUM_HS_ISOC; + else +- maxsize = DEV_DMA_NBYTES_LIMIT; +- +- /* Above size of one descriptor was chosen, multiple it */ +- maxsize *= MAX_DMA_DESC_NUM_GENERIC; ++ maxsize = DEV_DMA_NBYTES_LIMIT * MAX_DMA_DESC_NUM_GENERIC; + + return maxsize; + } +@@ -864,7 +862,7 @@ static int dwc2_gadget_fill_isoc_desc(struct dwc2_hsotg_ep *hs_ep, + + /* Update index of last configured entry in the chain */ + hs_ep->next_desc++; +- if (hs_ep->next_desc >= MAX_DMA_DESC_NUM_GENERIC) ++ if (hs_ep->next_desc >= MAX_DMA_DESC_NUM_HS_ISOC) + hs_ep->next_desc = 0; + + return 0; +@@ -896,7 +894,7 @@ static void dwc2_gadget_start_isoc_ddma(struct dwc2_hsotg_ep *hs_ep) + } + + /* Initialize descriptor chain by Host Busy status */ +- for (i = 0; i < MAX_DMA_DESC_NUM_GENERIC; i++) { ++ for (i = 0; i < MAX_DMA_DESC_NUM_HS_ISOC; i++) { + desc = &hs_ep->desc_list[i]; + desc->status = 0; + desc->status |= (DEV_DMA_BUFF_STS_HBUSY +@@ -2083,7 +2081,7 @@ static void dwc2_gadget_complete_isoc_request_ddma(struct dwc2_hsotg_ep *hs_ep) + dwc2_hsotg_complete_request(hsotg, hs_ep, hs_req, 0); + + hs_ep->compl_desc++; +- if (hs_ep->compl_desc > (MAX_DMA_DESC_NUM_GENERIC - 1)) ++ if (hs_ep->compl_desc > (MAX_DMA_DESC_NUM_HS_ISOC - 1)) + hs_ep->compl_desc = 0; + desc_sts = hs_ep->desc_list[hs_ep->compl_desc].status; + } +@@ -3779,6 +3777,7 @@ static int dwc2_hsotg_ep_enable(struct usb_ep *ep, + unsigned int i, val, size; + int ret = 0; + unsigned char ep_type; ++ int desc_num; + + dev_dbg(hsotg->dev, + "%s: ep %s: a 0x%02x, attr 0x%02x, mps 0x%04x, intr %d\n", +@@ -3825,11 +3824,15 @@ static int dwc2_hsotg_ep_enable(struct usb_ep *ep, + dev_dbg(hsotg->dev, "%s: read DxEPCTL=0x%08x from 0x%08x\n", + __func__, epctrl, epctrl_reg); + ++ if (using_desc_dma(hsotg) && ep_type == USB_ENDPOINT_XFER_ISOC) ++ desc_num = MAX_DMA_DESC_NUM_HS_ISOC; ++ else ++ desc_num = MAX_DMA_DESC_NUM_GENERIC; ++ + /* Allocate DMA descriptor chain for non-ctrl endpoints */ + if (using_desc_dma(hsotg) && !hs_ep->desc_list) { + hs_ep->desc_list = dmam_alloc_coherent(hsotg->dev, +- MAX_DMA_DESC_NUM_GENERIC * +- sizeof(struct dwc2_dma_desc), ++ desc_num * sizeof(struct dwc2_dma_desc), + &hs_ep->desc_list_dma, GFP_ATOMIC); + if (!hs_ep->desc_list) { + ret = -ENOMEM; +@@ -3971,7 +3974,7 @@ error1: + + error2: + if (ret && using_desc_dma(hsotg) && hs_ep->desc_list) { +- dmam_free_coherent(hsotg->dev, MAX_DMA_DESC_NUM_GENERIC * ++ dmam_free_coherent(hsotg->dev, desc_num * + sizeof(struct dwc2_dma_desc), + hs_ep->desc_list, hs_ep->desc_list_dma); + hs_ep->desc_list = NULL; +diff --git a/drivers/usb/dwc3/core.c b/drivers/usb/dwc3/core.c +index 4d5c7dda8f54..05b9ccff7447 100644 +--- a/drivers/usb/dwc3/core.c ++++ b/drivers/usb/dwc3/core.c +@@ -1591,6 +1591,7 @@ static int dwc3_suspend_common(struct dwc3 *dwc, pm_message_t msg) + spin_lock_irqsave(&dwc->lock, flags); + dwc3_gadget_suspend(dwc); + spin_unlock_irqrestore(&dwc->lock, flags); ++ synchronize_irq(dwc->irq_gadget); + dwc3_core_exit(dwc); + break; + case DWC3_GCTL_PRTCAP_HOST: +@@ -1623,6 +1624,7 @@ static int dwc3_suspend_common(struct dwc3 *dwc, pm_message_t msg) + spin_lock_irqsave(&dwc->lock, flags); + dwc3_gadget_suspend(dwc); + spin_unlock_irqrestore(&dwc->lock, flags); ++ synchronize_irq(dwc->irq_gadget); + } + + dwc3_otg_exit(dwc); +diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c +index 524104eed8a7..65ba1038b111 100644 +--- a/drivers/usb/dwc3/gadget.c ++++ b/drivers/usb/dwc3/gadget.c +@@ -3277,8 +3277,6 @@ int dwc3_gadget_suspend(struct dwc3 *dwc) + dwc3_disconnect_gadget(dwc); + __dwc3_gadget_stop(dwc); + +- synchronize_irq(dwc->irq_gadget); +- + return 0; + } + +diff --git a/drivers/video/fbdev/core/fbcmap.c b/drivers/video/fbdev/core/fbcmap.c +index 68a113594808..2811c4afde01 100644 +--- a/drivers/video/fbdev/core/fbcmap.c ++++ b/drivers/video/fbdev/core/fbcmap.c +@@ -94,6 +94,8 @@ int fb_alloc_cmap_gfp(struct fb_cmap *cmap, int len, int transp, gfp_t flags) + int size = len * sizeof(u16); + int ret = -ENOMEM; + ++ flags |= __GFP_NOWARN; ++ + if (cmap->len != len) { + fb_dealloc_cmap(cmap); + if (!len) +diff --git a/drivers/video/fbdev/core/modedb.c b/drivers/video/fbdev/core/modedb.c +index 283d9307df21..ac049871704d 100644 +--- a/drivers/video/fbdev/core/modedb.c ++++ b/drivers/video/fbdev/core/modedb.c +@@ -935,6 +935,9 @@ void fb_var_to_videomode(struct fb_videomode *mode, + if (var->vmode & FB_VMODE_DOUBLE) + vtotal *= 2; + ++ if (!htotal || !vtotal) ++ return; ++ + hfreq = pixclock/htotal; + mode->refresh = hfreq/vtotal; + } +diff --git a/drivers/video/fbdev/efifb.c b/drivers/video/fbdev/efifb.c +index fd02e8a4841d..9f39f0c360e0 100644 +--- a/drivers/video/fbdev/efifb.c ++++ b/drivers/video/fbdev/efifb.c +@@ -464,7 +464,8 @@ static int efifb_probe(struct platform_device *dev) + info->apertures->ranges[0].base = efifb_fix.smem_start; + info->apertures->ranges[0].size = size_remap; + +- if (!efi_mem_desc_lookup(efifb_fix.smem_start, &md)) { ++ if (efi_enabled(EFI_BOOT) && ++ !efi_mem_desc_lookup(efifb_fix.smem_start, &md)) { + if ((efifb_fix.smem_start + efifb_fix.smem_len) > + (md.phys_addr + (md.num_pages << EFI_PAGE_SHIFT))) { + pr_err("efifb: video memory @ 0x%lx spans multiple EFI memory regions\n", +diff --git a/drivers/video/fbdev/udlfb.c b/drivers/video/fbdev/udlfb.c +index 2001910fd241..5a0d6fb02bbc 100644 +--- a/drivers/video/fbdev/udlfb.c ++++ b/drivers/video/fbdev/udlfb.c +@@ -1659,7 +1659,7 @@ static int dlfb_usb_probe(struct usb_interface *intf, + dlfb = kzalloc(sizeof(*dlfb), GFP_KERNEL); + if (!dlfb) { + dev_err(&intf->dev, "%s: failed to allocate dlfb\n", __func__); +- goto error; ++ return -ENOMEM; + } + + INIT_LIST_HEAD(&dlfb->deferred_free); +@@ -1769,7 +1769,7 @@ static int dlfb_usb_probe(struct usb_interface *intf, + error: + if (dlfb->info) { + dlfb_ops_destroy(dlfb->info); +- } else if (dlfb) { ++ } else { + usb_put_dev(dlfb->udev); + kfree(dlfb); + } +@@ -1796,12 +1796,10 @@ static void dlfb_usb_disconnect(struct usb_interface *intf) + /* this function will wait for all in-flight urbs to complete */ + dlfb_free_urb_list(dlfb); + +- if (info) { +- /* remove udlfb's sysfs interfaces */ +- for (i = 0; i < ARRAY_SIZE(fb_device_attrs); i++) +- device_remove_file(info->dev, &fb_device_attrs[i]); +- device_remove_bin_file(info->dev, &edid_attr); +- } ++ /* remove udlfb's sysfs interfaces */ ++ for (i = 0; i < ARRAY_SIZE(fb_device_attrs); i++) ++ device_remove_file(info->dev, &fb_device_attrs[i]); ++ device_remove_bin_file(info->dev, &edid_attr); + + unregister_framebuffer(info); + } +diff --git a/drivers/w1/w1_io.c b/drivers/w1/w1_io.c +index 0364d3329c52..3516ce6718d9 100644 +--- a/drivers/w1/w1_io.c ++++ b/drivers/w1/w1_io.c +@@ -432,8 +432,7 @@ int w1_reset_resume_command(struct w1_master *dev) + if (w1_reset_bus(dev)) + return -1; + +- /* This will make only the last matched slave perform a skip ROM. */ +- w1_write_8(dev, W1_RESUME_CMD); ++ w1_write_8(dev, dev->slave_count > 1 ? W1_RESUME_CMD : W1_SKIP_ROM); + return 0; + } + EXPORT_SYMBOL_GPL(w1_reset_resume_command); +diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c +index 2a4f52c7be22..ac6c383d6314 100644 +--- a/fs/btrfs/backref.c ++++ b/fs/btrfs/backref.c +@@ -710,7 +710,7 @@ out: + * read tree blocks and add keys where required. + */ + static int add_missing_keys(struct btrfs_fs_info *fs_info, +- struct preftrees *preftrees) ++ struct preftrees *preftrees, bool lock) + { + struct prelim_ref *ref; + struct extent_buffer *eb; +@@ -735,12 +735,14 @@ static int add_missing_keys(struct btrfs_fs_info *fs_info, + free_extent_buffer(eb); + return -EIO; + } +- btrfs_tree_read_lock(eb); ++ if (lock) ++ btrfs_tree_read_lock(eb); + if (btrfs_header_level(eb) == 0) + btrfs_item_key_to_cpu(eb, &ref->key_for_search, 0); + else + btrfs_node_key_to_cpu(eb, &ref->key_for_search, 0); +- btrfs_tree_read_unlock(eb); ++ if (lock) ++ btrfs_tree_read_unlock(eb); + free_extent_buffer(eb); + prelim_ref_insert(fs_info, &preftrees->indirect, ref, NULL); + cond_resched(); +@@ -1225,7 +1227,7 @@ again: + + btrfs_release_path(path); + +- ret = add_missing_keys(fs_info, &preftrees); ++ ret = add_missing_keys(fs_info, &preftrees, path->skip_locking == 0); + if (ret) + goto out; + +@@ -1286,11 +1288,14 @@ again: + ret = -EIO; + goto out; + } +- btrfs_tree_read_lock(eb); +- btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK); ++ if (!path->skip_locking) { ++ btrfs_tree_read_lock(eb); ++ btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK); ++ } + ret = find_extent_in_eb(eb, bytenr, + *extent_item_pos, &eie, ignore_offset); +- btrfs_tree_read_unlock_blocking(eb); ++ if (!path->skip_locking) ++ btrfs_tree_read_unlock_blocking(eb); + free_extent_buffer(eb); + if (ret < 0) + goto out; +diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c +index 809c2c307c64..0cc800d22a08 100644 +--- a/fs/btrfs/extent-tree.c ++++ b/fs/btrfs/extent-tree.c +@@ -3911,8 +3911,7 @@ static int create_space_info(struct btrfs_fs_info *info, u64 flags) + info->space_info_kobj, "%s", + alloc_name(space_info->flags)); + if (ret) { +- percpu_counter_destroy(&space_info->total_bytes_pinned); +- kfree(space_info); ++ kobject_put(&space_info->kobj); + return ret; + } + +@@ -10789,9 +10788,9 @@ int btrfs_error_unpin_extent_range(struct btrfs_fs_info *fs_info, + * held back allocations. + */ + static int btrfs_trim_free_extents(struct btrfs_device *device, +- struct fstrim_range *range, u64 *trimmed) ++ u64 minlen, u64 *trimmed) + { +- u64 start = range->start, len = 0; ++ u64 start = 0, len = 0; + int ret; + + *trimmed = 0; +@@ -10834,8 +10833,8 @@ static int btrfs_trim_free_extents(struct btrfs_device *device, + if (!trans) + up_read(&fs_info->commit_root_sem); + +- ret = find_free_dev_extent_start(trans, device, range->minlen, +- start, &start, &len); ++ ret = find_free_dev_extent_start(trans, device, minlen, start, ++ &start, &len); + if (trans) { + up_read(&fs_info->commit_root_sem); + btrfs_put_transaction(trans); +@@ -10848,16 +10847,6 @@ static int btrfs_trim_free_extents(struct btrfs_device *device, + break; + } + +- /* If we are out of the passed range break */ +- if (start > range->start + range->len - 1) { +- mutex_unlock(&fs_info->chunk_mutex); +- ret = 0; +- break; +- } +- +- start = max(range->start, start); +- len = min(range->len, len); +- + ret = btrfs_issue_discard(device->bdev, start, len, &bytes); + mutex_unlock(&fs_info->chunk_mutex); + +@@ -10867,10 +10856,6 @@ static int btrfs_trim_free_extents(struct btrfs_device *device, + start += len; + *trimmed += bytes; + +- /* We've trimmed enough */ +- if (*trimmed >= range->len) +- break; +- + if (fatal_signal_pending(current)) { + ret = -ERESTARTSYS; + break; +@@ -10954,7 +10939,8 @@ int btrfs_trim_fs(struct btrfs_fs_info *fs_info, struct fstrim_range *range) + mutex_lock(&fs_info->fs_devices->device_list_mutex); + devices = &fs_info->fs_devices->devices; + list_for_each_entry(device, devices, dev_list) { +- ret = btrfs_trim_free_extents(device, range, &group_trimmed); ++ ret = btrfs_trim_free_extents(device, range->minlen, ++ &group_trimmed); + if (ret) { + dev_failed++; + dev_ret = ret; +diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c +index ca4902c66dc4..e24c0a69ff5d 100644 +--- a/fs/btrfs/file.c ++++ b/fs/btrfs/file.c +@@ -2058,6 +2058,18 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync) + int ret = 0, err; + u64 len; + ++ /* ++ * If the inode needs a full sync, make sure we use a full range to ++ * avoid log tree corruption, due to hole detection racing with ordered ++ * extent completion for adjacent ranges, and assertion failures during ++ * hole detection. ++ */ ++ if (test_bit(BTRFS_INODE_NEEDS_FULL_SYNC, ++ &BTRFS_I(inode)->runtime_flags)) { ++ start = 0; ++ end = LLONG_MAX; ++ } ++ + /* + * The range length can be represented by u64, we have to do the typecasts + * to avoid signed overflow if it's [0, LLONG_MAX] eg. from fsync() +@@ -2565,10 +2577,8 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len) + + ret = btrfs_punch_hole_lock_range(inode, lockstart, lockend, + &cached_state); +- if (ret) { +- inode_unlock(inode); ++ if (ret) + goto out_only_mutex; +- } + + path = btrfs_alloc_path(); + if (!path) { +@@ -3151,6 +3161,7 @@ static long btrfs_fallocate(struct file *file, int mode, + ret = btrfs_qgroup_reserve_data(inode, &data_reserved, + cur_offset, last_byte - cur_offset); + if (ret < 0) { ++ cur_offset = last_byte; + free_extent_map(em); + break; + } +@@ -3200,7 +3211,7 @@ out: + /* Let go of our reservation. */ + if (ret != 0 && !(mode & FALLOC_FL_ZERO_RANGE)) + btrfs_free_reserved_data_space(inode, data_reserved, +- alloc_start, alloc_end - cur_offset); ++ cur_offset, alloc_end - cur_offset); + extent_changeset_free(data_reserved); + return ret; + } +diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c +index 0526b6c473c7..5d57ed629345 100644 +--- a/fs/btrfs/relocation.c ++++ b/fs/btrfs/relocation.c +@@ -4289,27 +4289,36 @@ int btrfs_relocate_block_group(struct btrfs_fs_info *fs_info, u64 group_start) + mutex_lock(&fs_info->cleaner_mutex); + ret = relocate_block_group(rc); + mutex_unlock(&fs_info->cleaner_mutex); +- if (ret < 0) { ++ if (ret < 0) + err = ret; +- goto out; +- } +- +- if (rc->extents_found == 0) +- break; +- +- btrfs_info(fs_info, "found %llu extents", rc->extents_found); + ++ /* ++ * We may have gotten ENOSPC after we already dirtied some ++ * extents. If writeout happens while we're relocating a ++ * different block group we could end up hitting the ++ * BUG_ON(rc->stage == UPDATE_DATA_PTRS) in ++ * btrfs_reloc_cow_block. Make sure we write everything out ++ * properly so we don't trip over this problem, and then break ++ * out of the loop if we hit an error. ++ */ + if (rc->stage == MOVE_DATA_EXTENTS && rc->found_file_extent) { + ret = btrfs_wait_ordered_range(rc->data_inode, 0, + (u64)-1); +- if (ret) { ++ if (ret) + err = ret; +- goto out; +- } + invalidate_mapping_pages(rc->data_inode->i_mapping, + 0, -1); + rc->stage = UPDATE_DATA_PTRS; + } ++ ++ if (err < 0) ++ goto out; ++ ++ if (rc->extents_found == 0) ++ break; ++ ++ btrfs_info(fs_info, "found %llu extents", rc->extents_found); ++ + } + + WARN_ON(rc->block_group->pinned > 0); +diff --git a/fs/btrfs/root-tree.c b/fs/btrfs/root-tree.c +index 65bda0682928..3228d3b3084a 100644 +--- a/fs/btrfs/root-tree.c ++++ b/fs/btrfs/root-tree.c +@@ -132,16 +132,17 @@ int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root + return -ENOMEM; + + ret = btrfs_search_slot(trans, root, key, path, 0, 1); +- if (ret < 0) { +- btrfs_abort_transaction(trans, ret); ++ if (ret < 0) + goto out; +- } + +- if (ret != 0) { +- btrfs_print_leaf(path->nodes[0]); +- btrfs_crit(fs_info, "unable to update root key %llu %u %llu", +- key->objectid, key->type, key->offset); +- BUG_ON(1); ++ if (ret > 0) { ++ btrfs_crit(fs_info, ++ "unable to find root key (%llu %u %llu) in tree %llu", ++ key->objectid, key->type, key->offset, ++ root->root_key.objectid); ++ ret = -EUCLEAN; ++ btrfs_abort_transaction(trans, ret); ++ goto out; + } + + l = path->nodes[0]; +diff --git a/fs/btrfs/sysfs.c b/fs/btrfs/sysfs.c +index 3717c864ba23..aefb0169d46d 100644 +--- a/fs/btrfs/sysfs.c ++++ b/fs/btrfs/sysfs.c +@@ -811,7 +811,12 @@ int btrfs_sysfs_add_fsid(struct btrfs_fs_devices *fs_devs, + fs_devs->fsid_kobj.kset = btrfs_kset; + error = kobject_init_and_add(&fs_devs->fsid_kobj, + &btrfs_ktype, parent, "%pU", fs_devs->fsid); +- return error; ++ if (error) { ++ kobject_put(&fs_devs->fsid_kobj); ++ return error; ++ } ++ ++ return 0; + } + + int btrfs_sysfs_add_mounted(struct btrfs_fs_info *fs_info) +diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c +index 2f4f0958e5f2..75051d36dc1a 100644 +--- a/fs/btrfs/tree-log.c ++++ b/fs/btrfs/tree-log.c +@@ -4121,6 +4121,7 @@ fill_holes: + *last_extent, 0, + 0, len, 0, len, + 0, 0, 0); ++ *last_extent += len; + } + } + } +diff --git a/fs/char_dev.c b/fs/char_dev.c +index a279c58fe360..8a63cfa29005 100644 +--- a/fs/char_dev.c ++++ b/fs/char_dev.c +@@ -159,6 +159,12 @@ __register_chrdev_region(unsigned int major, unsigned int baseminor, + ret = -EBUSY; + goto out; + } ++ ++ if (new_min < old_min && new_max > old_max) { ++ ret = -EBUSY; ++ goto out; ++ } ++ + } + + cd->next = *cp; +diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c +index 67e8aa35197e..05dc5a4ba481 100644 +--- a/fs/ext4/inode.c ++++ b/fs/ext4/inode.c +@@ -5596,25 +5596,22 @@ int ext4_setattr(struct dentry *dentry, struct iattr *attr) + up_write(&EXT4_I(inode)->i_data_sem); + ext4_journal_stop(handle); + if (error) { +- if (orphan) ++ if (orphan && inode->i_nlink) + ext4_orphan_del(NULL, inode); + goto err_out; + } + } +- if (!shrink) ++ if (!shrink) { + pagecache_isize_extended(inode, oldsize, inode->i_size); +- +- /* +- * Blocks are going to be removed from the inode. Wait +- * for dio in flight. Temporarily disable +- * dioread_nolock to prevent livelock. +- */ +- if (orphan) { +- if (!ext4_should_journal_data(inode)) { +- inode_dio_wait(inode); +- } else +- ext4_wait_for_tail_page_commit(inode); ++ } else { ++ /* ++ * Blocks are going to be removed from the inode. Wait ++ * for dio in flight. ++ */ ++ inode_dio_wait(inode); + } ++ if (orphan && ext4_should_journal_data(inode)) ++ ext4_wait_for_tail_page_commit(inode); + down_write(&EXT4_I(inode)->i_mmap_sem); + + rc = ext4_break_layouts(inode); +diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c +index 08314fb42652..4d02e76b648a 100644 +--- a/fs/f2fs/data.c ++++ b/fs/f2fs/data.c +@@ -197,12 +197,14 @@ struct block_device *f2fs_target_device(struct f2fs_sb_info *sbi, + struct block_device *bdev = sbi->sb->s_bdev; + int i; + +- for (i = 0; i < sbi->s_ndevs; i++) { +- if (FDEV(i).start_blk <= blk_addr && +- FDEV(i).end_blk >= blk_addr) { +- blk_addr -= FDEV(i).start_blk; +- bdev = FDEV(i).bdev; +- break; ++ if (f2fs_is_multi_device(sbi)) { ++ for (i = 0; i < sbi->s_ndevs; i++) { ++ if (FDEV(i).start_blk <= blk_addr && ++ FDEV(i).end_blk >= blk_addr) { ++ blk_addr -= FDEV(i).start_blk; ++ bdev = FDEV(i).bdev; ++ break; ++ } + } + } + if (bio) { +@@ -216,6 +218,9 @@ int f2fs_target_device_index(struct f2fs_sb_info *sbi, block_t blkaddr) + { + int i; + ++ if (!f2fs_is_multi_device(sbi)) ++ return 0; ++ + for (i = 0; i < sbi->s_ndevs; i++) + if (FDEV(i).start_blk <= blkaddr && FDEV(i).end_blk >= blkaddr) + return i; +diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h +index 1f5d5f62bb77..a4b6eacf22ea 100644 +--- a/fs/f2fs/f2fs.h ++++ b/fs/f2fs/f2fs.h +@@ -1336,6 +1336,17 @@ static inline bool time_to_inject(struct f2fs_sb_info *sbi, int type) + } + #endif + ++/* ++ * Test if the mounted volume is a multi-device volume. ++ * - For a single regular disk volume, sbi->s_ndevs is 0. ++ * - For a single zoned disk volume, sbi->s_ndevs is 1. ++ * - For a multi-device volume, sbi->s_ndevs is always 2 or more. ++ */ ++static inline bool f2fs_is_multi_device(struct f2fs_sb_info *sbi) ++{ ++ return sbi->s_ndevs > 1; ++} ++ + /* For write statistics. Suppose sector size is 512 bytes, + * and the return value is in kbytes. s is of struct f2fs_sb_info. + */ +@@ -3455,7 +3466,7 @@ static inline bool f2fs_force_buffered_io(struct inode *inode, int rw) + { + return (f2fs_post_read_required(inode) || + (rw == WRITE && test_opt(F2FS_I_SB(inode), LFS)) || +- F2FS_I_SB(inode)->s_ndevs); ++ f2fs_is_multi_device(F2FS_I_SB(inode))); + } + + #ifdef CONFIG_F2FS_FAULT_INJECTION +diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c +index b3f46e3bec17..8d1eb8dec605 100644 +--- a/fs/f2fs/file.c ++++ b/fs/f2fs/file.c +@@ -2539,7 +2539,7 @@ static int f2fs_ioc_flush_device(struct file *filp, unsigned long arg) + sizeof(range))) + return -EFAULT; + +- if (sbi->s_ndevs <= 1 || sbi->s_ndevs - 1 <= range.dev_num || ++ if (!f2fs_is_multi_device(sbi) || sbi->s_ndevs - 1 <= range.dev_num || + sbi->segs_per_sec != 1) { + f2fs_msg(sbi->sb, KERN_WARNING, + "Can't flush %u in %d for segs_per_sec %u != 1\n", +diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c +index 5c8d00422237..d44b57a363ff 100644 +--- a/fs/f2fs/gc.c ++++ b/fs/f2fs/gc.c +@@ -1256,7 +1256,7 @@ void f2fs_build_gc_manager(struct f2fs_sb_info *sbi) + sbi->gc_pin_file_threshold = DEF_GC_FAILED_PINNED_FILES; + + /* give warm/cold data area from slower device */ +- if (sbi->s_ndevs && sbi->segs_per_sec == 1) ++ if (f2fs_is_multi_device(sbi) && sbi->segs_per_sec == 1) + SIT_I(sbi)->last_victim[ALLOC_NEXT] = + GET_SEGNO(sbi, FDEV(0).end_blk) + 1; + } +diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c +index ac038563273d..03fa2c4d3d79 100644 +--- a/fs/f2fs/segment.c ++++ b/fs/f2fs/segment.c +@@ -574,7 +574,7 @@ static int submit_flush_wait(struct f2fs_sb_info *sbi, nid_t ino) + int ret = 0; + int i; + +- if (!sbi->s_ndevs) ++ if (!f2fs_is_multi_device(sbi)) + return __submit_flush_wait(sbi, sbi->sb->s_bdev); + + for (i = 0; i < sbi->s_ndevs; i++) { +@@ -640,7 +640,8 @@ int f2fs_issue_flush(struct f2fs_sb_info *sbi, nid_t ino) + return ret; + } + +- if (atomic_inc_return(&fcc->issing_flush) == 1 || sbi->s_ndevs > 1) { ++ if (atomic_inc_return(&fcc->issing_flush) == 1 || ++ f2fs_is_multi_device(sbi)) { + ret = submit_flush_wait(sbi, ino); + atomic_dec(&fcc->issing_flush); + +@@ -746,7 +747,7 @@ int f2fs_flush_device_cache(struct f2fs_sb_info *sbi) + { + int ret = 0, i; + +- if (!sbi->s_ndevs) ++ if (!f2fs_is_multi_device(sbi)) + return 0; + + for (i = 1; i < sbi->s_ndevs; i++) { +@@ -1289,7 +1290,7 @@ static int __queue_discard_cmd(struct f2fs_sb_info *sbi, + + trace_f2fs_queue_discard(bdev, blkstart, blklen); + +- if (sbi->s_ndevs) { ++ if (f2fs_is_multi_device(sbi)) { + int devi = f2fs_target_device_index(sbi, blkstart); + + blkstart -= FDEV(devi).start_blk; +@@ -1638,7 +1639,7 @@ static int __f2fs_issue_discard_zone(struct f2fs_sb_info *sbi, + block_t lblkstart = blkstart; + int devi = 0; + +- if (sbi->s_ndevs) { ++ if (f2fs_is_multi_device(sbi)) { + devi = f2fs_target_device_index(sbi, blkstart); + blkstart -= FDEV(devi).start_blk; + } +@@ -2971,7 +2972,7 @@ static void update_device_state(struct f2fs_io_info *fio) + struct f2fs_sb_info *sbi = fio->sbi; + unsigned int devidx; + +- if (!sbi->s_ndevs) ++ if (!f2fs_is_multi_device(sbi)) + return; + + devidx = f2fs_target_device_index(sbi, fio->new_blkaddr); +diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c +index 9d566e62684c..ccdd8c821abd 100644 +--- a/fs/gfs2/glock.c ++++ b/fs/gfs2/glock.c +@@ -140,6 +140,7 @@ void gfs2_glock_free(struct gfs2_glock *gl) + { + struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; + ++ BUG_ON(atomic_read(&gl->gl_revokes)); + rhashtable_remove_fast(&gl_hash_table, &gl->gl_node, ht_parms); + smp_mb(); + wake_up_glock(gl); +@@ -183,15 +184,19 @@ static int demote_ok(const struct gfs2_glock *gl) + + void gfs2_glock_add_to_lru(struct gfs2_glock *gl) + { ++ if (!(gl->gl_ops->go_flags & GLOF_LRU)) ++ return; ++ + spin_lock(&lru_lock); + +- if (!list_empty(&gl->gl_lru)) +- list_del_init(&gl->gl_lru); +- else ++ list_del(&gl->gl_lru); ++ list_add_tail(&gl->gl_lru, &lru_list); ++ ++ if (!test_bit(GLF_LRU, &gl->gl_flags)) { ++ set_bit(GLF_LRU, &gl->gl_flags); + atomic_inc(&lru_count); ++ } + +- list_add_tail(&gl->gl_lru, &lru_list); +- set_bit(GLF_LRU, &gl->gl_flags); + spin_unlock(&lru_lock); + } + +@@ -201,7 +206,7 @@ static void gfs2_glock_remove_from_lru(struct gfs2_glock *gl) + return; + + spin_lock(&lru_lock); +- if (!list_empty(&gl->gl_lru)) { ++ if (test_bit(GLF_LRU, &gl->gl_flags)) { + list_del_init(&gl->gl_lru); + atomic_dec(&lru_count); + clear_bit(GLF_LRU, &gl->gl_flags); +@@ -1158,8 +1163,7 @@ void gfs2_glock_dq(struct gfs2_holder *gh) + !test_bit(GLF_DEMOTE, &gl->gl_flags)) + fast_path = 1; + } +- if (!test_bit(GLF_LFLUSH, &gl->gl_flags) && demote_ok(gl) && +- (glops->go_flags & GLOF_LRU)) ++ if (!test_bit(GLF_LFLUSH, &gl->gl_flags) && demote_ok(gl)) + gfs2_glock_add_to_lru(gl); + + trace_gfs2_glock_queue(gh, 0); +@@ -1455,6 +1459,7 @@ __acquires(&lru_lock) + if (!spin_trylock(&gl->gl_lockref.lock)) { + add_back_to_lru: + list_add(&gl->gl_lru, &lru_list); ++ set_bit(GLF_LRU, &gl->gl_flags); + atomic_inc(&lru_count); + continue; + } +@@ -1462,7 +1467,6 @@ add_back_to_lru: + spin_unlock(&gl->gl_lockref.lock); + goto add_back_to_lru; + } +- clear_bit(GLF_LRU, &gl->gl_flags); + gl->gl_lockref.count++; + if (demote_ok(gl)) + handle_callback(gl, LM_ST_UNLOCKED, 0, false); +@@ -1497,6 +1501,7 @@ static long gfs2_scan_glock_lru(int nr) + if (!test_bit(GLF_LOCK, &gl->gl_flags)) { + list_move(&gl->gl_lru, &dispose); + atomic_dec(&lru_count); ++ clear_bit(GLF_LRU, &gl->gl_flags); + freed++; + continue; + } +diff --git a/fs/gfs2/lock_dlm.c b/fs/gfs2/lock_dlm.c +index ac7caa267ed6..62edf8f5615f 100644 +--- a/fs/gfs2/lock_dlm.c ++++ b/fs/gfs2/lock_dlm.c +@@ -31,9 +31,10 @@ + * @delta is the difference between the current rtt sample and the + * running average srtt. We add 1/8 of that to the srtt in order to + * update the current srtt estimate. The variance estimate is a bit +- * more complicated. We subtract the abs value of the @delta from +- * the current variance estimate and add 1/4 of that to the running +- * total. ++ * more complicated. We subtract the current variance estimate from ++ * the abs value of the @delta and add 1/4 of that to the running ++ * total. That's equivalent to 3/4 of the current variance ++ * estimate plus 1/4 of the abs of @delta. + * + * Note that the index points at the array entry containing the smoothed + * mean value, and the variance is always in the following entry +@@ -49,7 +50,7 @@ static inline void gfs2_update_stats(struct gfs2_lkstats *s, unsigned index, + s64 delta = sample - s->stats[index]; + s->stats[index] += (delta >> 3); + index++; +- s->stats[index] += ((abs(delta) - s->stats[index]) >> 2); ++ s->stats[index] += (s64)(abs(delta) - s->stats[index]) >> 2; + } + + /** +diff --git a/fs/gfs2/log.c b/fs/gfs2/log.c +index ee20ea42e7b5..cd85092723de 100644 +--- a/fs/gfs2/log.c ++++ b/fs/gfs2/log.c +@@ -604,7 +604,8 @@ void gfs2_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd) + bd->bd_bh = NULL; + bd->bd_ops = &gfs2_revoke_lops; + sdp->sd_log_num_revoke++; +- atomic_inc(&gl->gl_revokes); ++ if (atomic_inc_return(&gl->gl_revokes) == 1) ++ gfs2_glock_hold(gl); + set_bit(GLF_LFLUSH, &gl->gl_flags); + list_add(&bd->bd_list, &sdp->sd_log_le_revoke); + } +diff --git a/fs/gfs2/lops.c b/fs/gfs2/lops.c +index f2567f958d00..8f99b395d7bf 100644 +--- a/fs/gfs2/lops.c ++++ b/fs/gfs2/lops.c +@@ -662,8 +662,10 @@ static void revoke_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr) + bd = list_entry(head->next, struct gfs2_bufdata, bd_list); + list_del_init(&bd->bd_list); + gl = bd->bd_gl; +- atomic_dec(&gl->gl_revokes); +- clear_bit(GLF_LFLUSH, &gl->gl_flags); ++ if (atomic_dec_return(&gl->gl_revokes) == 0) { ++ clear_bit(GLF_LFLUSH, &gl->gl_flags); ++ gfs2_glock_queue_put(gl); ++ } + kmem_cache_free(gfs2_bufdata_cachep, bd); + } + } +diff --git a/fs/internal.h b/fs/internal.h +index d410186bc369..d109665b9e50 100644 +--- a/fs/internal.h ++++ b/fs/internal.h +@@ -80,9 +80,7 @@ extern int sb_prepare_remount_readonly(struct super_block *); + + extern void __init mnt_init(void); + +-extern int __mnt_want_write(struct vfsmount *); + extern int __mnt_want_write_file(struct file *); +-extern void __mnt_drop_write(struct vfsmount *); + extern void __mnt_drop_write_file(struct file *); + + /* +diff --git a/fs/nfs/client.c b/fs/nfs/client.c +index 751ca65da8a3..c092661147b3 100644 +--- a/fs/nfs/client.c ++++ b/fs/nfs/client.c +@@ -290,6 +290,7 @@ static struct nfs_client *nfs_match_client(const struct nfs_client_initdata *dat + struct nfs_client *clp; + const struct sockaddr *sap = data->addr; + struct nfs_net *nn = net_generic(data->net, nfs_net_id); ++ int error; + + again: + list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) { +@@ -302,9 +303,11 @@ again: + if (clp->cl_cons_state > NFS_CS_READY) { + refcount_inc(&clp->cl_count); + spin_unlock(&nn->nfs_client_lock); +- nfs_wait_client_init_complete(clp); ++ error = nfs_wait_client_init_complete(clp); + nfs_put_client(clp); + spin_lock(&nn->nfs_client_lock); ++ if (error < 0) ++ return ERR_PTR(error); + goto again; + } + +@@ -413,6 +416,8 @@ struct nfs_client *nfs_get_client(const struct nfs_client_initdata *cl_init) + clp = nfs_match_client(cl_init); + if (clp) { + spin_unlock(&nn->nfs_client_lock); ++ if (IS_ERR(clp)) ++ return clp; + if (new) + new->rpc_ops->free_client(new); + return nfs_found_client(cl_init, clp); +diff --git a/fs/nfs/nfs42proc.c b/fs/nfs/nfs42proc.c +index fed06fd9998d..94f98e190e63 100644 +--- a/fs/nfs/nfs42proc.c ++++ b/fs/nfs/nfs42proc.c +@@ -329,9 +329,6 @@ ssize_t nfs42_proc_copy(struct file *src, loff_t pos_src, + }; + ssize_t err, err2; + +- if (!nfs_server_capable(file_inode(dst), NFS_CAP_COPY)) +- return -EOPNOTSUPP; +- + src_lock = nfs_get_lock_context(nfs_file_open_context(src)); + if (IS_ERR(src_lock)) + return PTR_ERR(src_lock); +diff --git a/fs/nfs/nfs4file.c b/fs/nfs/nfs4file.c +index 4288a6ecaf75..134858507268 100644 +--- a/fs/nfs/nfs4file.c ++++ b/fs/nfs/nfs4file.c +@@ -133,15 +133,11 @@ static ssize_t nfs4_copy_file_range(struct file *file_in, loff_t pos_in, + struct file *file_out, loff_t pos_out, + size_t count, unsigned int flags) + { +- ssize_t ret; +- ++ if (!nfs_server_capable(file_inode(file_out), NFS_CAP_COPY)) ++ return -EOPNOTSUPP; + if (file_inode(file_in) == file_inode(file_out)) +- return -EINVAL; +-retry: +- ret = nfs42_proc_copy(file_in, pos_in, file_out, pos_out, count); +- if (ret == -EAGAIN) +- goto retry; +- return ret; ++ return -EOPNOTSUPP; ++ return nfs42_proc_copy(file_in, pos_in, file_out, pos_out, count); + } + + static loff_t nfs4_file_llseek(struct file *filep, loff_t offset, int whence) +diff --git a/fs/overlayfs/dir.c b/fs/overlayfs/dir.c +index b2aadd3e1fec..336f04da80ed 100644 +--- a/fs/overlayfs/dir.c ++++ b/fs/overlayfs/dir.c +@@ -260,7 +260,7 @@ static int ovl_instantiate(struct dentry *dentry, struct inode *inode, + * hashed directory inode aliases. + */ + inode = ovl_get_inode(dentry->d_sb, &oip); +- if (WARN_ON(IS_ERR(inode))) ++ if (IS_ERR(inode)) + return PTR_ERR(inode); + } else { + WARN_ON(ovl_inode_real(inode) != d_inode(newdentry)); +diff --git a/fs/overlayfs/inode.c b/fs/overlayfs/inode.c +index 3b7ed5d2279c..b48273e846ad 100644 +--- a/fs/overlayfs/inode.c ++++ b/fs/overlayfs/inode.c +@@ -832,7 +832,7 @@ struct inode *ovl_get_inode(struct super_block *sb, + int fsid = bylower ? oip->lowerpath->layer->fsid : 0; + bool is_dir, metacopy = false; + unsigned long ino = 0; +- int err = -ENOMEM; ++ int err = oip->newinode ? -EEXIST : -ENOMEM; + + if (!realinode) + realinode = d_inode(lowerdentry); +@@ -917,6 +917,7 @@ out: + return inode; + + out_err: ++ pr_warn_ratelimited("overlayfs: failed to get inode (%i)\n", err); + inode = ERR_PTR(err); + goto out; + } +diff --git a/include/drm/tinydrm/mipi-dbi.h b/include/drm/tinydrm/mipi-dbi.h +index b8ba58861986..bcc98bd447f7 100644 +--- a/include/drm/tinydrm/mipi-dbi.h ++++ b/include/drm/tinydrm/mipi-dbi.h +@@ -42,7 +42,7 @@ struct mipi_dbi { + struct spi_device *spi; + bool enabled; + struct mutex cmdlock; +- int (*command)(struct mipi_dbi *mipi, u8 cmd, u8 *param, size_t num); ++ int (*command)(struct mipi_dbi *mipi, u8 *cmd, u8 *param, size_t num); + const u8 *read_commands; + struct gpio_desc *dc; + u16 *tx_buf; +@@ -79,6 +79,7 @@ u32 mipi_dbi_spi_cmd_max_speed(struct spi_device *spi, size_t len); + + int mipi_dbi_command_read(struct mipi_dbi *mipi, u8 cmd, u8 *val); + int mipi_dbi_command_buf(struct mipi_dbi *mipi, u8 cmd, u8 *data, size_t len); ++int mipi_dbi_command_stackbuf(struct mipi_dbi *mipi, u8 cmd, u8 *data, size_t len); + int mipi_dbi_buf_copy(void *dst, struct drm_framebuffer *fb, + struct drm_clip_rect *clip, bool swap); + /** +@@ -96,7 +97,7 @@ int mipi_dbi_buf_copy(void *dst, struct drm_framebuffer *fb, + #define mipi_dbi_command(mipi, cmd, seq...) \ + ({ \ + u8 d[] = { seq }; \ +- mipi_dbi_command_buf(mipi, cmd, d, ARRAY_SIZE(d)); \ ++ mipi_dbi_command_stackbuf(mipi, cmd, d, ARRAY_SIZE(d)); \ + }) + + #ifdef CONFIG_DEBUG_FS +diff --git a/include/linux/bio.h b/include/linux/bio.h +index 51371740d2a8..c7433a201171 100644 +--- a/include/linux/bio.h ++++ b/include/linux/bio.h +@@ -257,7 +257,7 @@ static inline void bio_cnt_set(struct bio *bio, unsigned int count) + { + if (count != 1) { + bio->bi_flags |= (1 << BIO_REFFED); +- smp_mb__before_atomic(); ++ smp_mb(); + } + atomic_set(&bio->__bi_cnt, count); + } +diff --git a/include/linux/cgroup-defs.h b/include/linux/cgroup-defs.h +index 6002275937f5..a6090154b2ab 100644 +--- a/include/linux/cgroup-defs.h ++++ b/include/linux/cgroup-defs.h +@@ -346,6 +346,11 @@ struct cgroup { + * Dying cgroups are cgroups which were deleted by a user, + * but are still existing because someone else is holding a reference. + * max_descendants is a maximum allowed number of descent cgroups. ++ * ++ * nr_descendants and nr_dying_descendants are protected ++ * by cgroup_mutex and css_set_lock. It's fine to read them holding ++ * any of cgroup_mutex and css_set_lock; for writing both locks ++ * should be held. + */ + int nr_descendants; + int nr_dying_descendants; +diff --git a/include/linux/filter.h b/include/linux/filter.h +index 037610845892..d52a7484aeb2 100644 +--- a/include/linux/filter.h ++++ b/include/linux/filter.h +@@ -684,6 +684,7 @@ static inline void bpf_prog_unlock_ro(struct bpf_prog *fp) + static inline void bpf_jit_binary_lock_ro(struct bpf_binary_header *hdr) + { + set_memory_ro((unsigned long)hdr, hdr->pages); ++ set_memory_x((unsigned long)hdr, hdr->pages); + } + + static inline void bpf_jit_binary_unlock_ro(struct bpf_binary_header *hdr) +@@ -836,6 +837,7 @@ bpf_run_sk_reuseport(struct sock_reuseport *reuse, struct sock *sk, + extern int bpf_jit_enable; + extern int bpf_jit_harden; + extern int bpf_jit_kallsyms; ++extern int bpf_jit_limit; + + typedef void (*bpf_jit_fill_hole_t)(void *area, unsigned int size); + +diff --git a/include/linux/genhd.h b/include/linux/genhd.h +index f767293b00e6..f13272d84332 100644 +--- a/include/linux/genhd.h ++++ b/include/linux/genhd.h +@@ -596,6 +596,7 @@ struct unixware_disklabel { + + extern int blk_alloc_devt(struct hd_struct *part, dev_t *devt); + extern void blk_free_devt(dev_t devt); ++extern void blk_invalidate_devt(dev_t devt); + extern dev_t blk_lookup_devt(const char *name, int partno); + extern char *disk_name (struct gendisk *hd, int partno, char *buf); + +diff --git a/include/linux/hid.h b/include/linux/hid.h +index d44a78362942..8b3e5e8a72fb 100644 +--- a/include/linux/hid.h ++++ b/include/linux/hid.h +@@ -414,6 +414,7 @@ struct hid_global { + + struct hid_local { + unsigned usage[HID_MAX_USAGES]; /* usage array */ ++ u8 usage_size[HID_MAX_USAGES]; /* usage size array */ + unsigned collection_index[HID_MAX_USAGES]; /* collection index array */ + unsigned usage_index; + unsigned usage_minimum; +diff --git a/include/linux/iio/adc/ad_sigma_delta.h b/include/linux/iio/adc/ad_sigma_delta.h +index 730ead1a46df..57c122ae5452 100644 +--- a/include/linux/iio/adc/ad_sigma_delta.h ++++ b/include/linux/iio/adc/ad_sigma_delta.h +@@ -66,6 +66,7 @@ struct ad_sigma_delta { + bool irq_dis; + + bool bus_locked; ++ bool keep_cs_asserted; + + uint8_t comm; + +diff --git a/include/linux/mount.h b/include/linux/mount.h +index 45b1f56c6c2f..4b0db4418954 100644 +--- a/include/linux/mount.h ++++ b/include/linux/mount.h +@@ -86,6 +86,8 @@ extern bool mnt_may_suid(struct vfsmount *mnt); + + struct path; + extern struct vfsmount *clone_private_mount(const struct path *path); ++extern int __mnt_want_write(struct vfsmount *); ++extern void __mnt_drop_write(struct vfsmount *); + + struct file_system_type; + extern struct vfsmount *vfs_kern_mount(struct file_system_type *type, +diff --git a/include/linux/overflow.h b/include/linux/overflow.h +index 40b48e2133cb..15eb85de9226 100644 +--- a/include/linux/overflow.h ++++ b/include/linux/overflow.h +@@ -36,6 +36,12 @@ + #define type_max(T) ((T)((__type_half_max(T) - 1) + __type_half_max(T))) + #define type_min(T) ((T)((T)-type_max(T)-(T)1)) + ++/* ++ * Avoids triggering -Wtype-limits compilation warning, ++ * while using unsigned data types to check a < 0. ++ */ ++#define is_non_negative(a) ((a) > 0 || (a) == 0) ++#define is_negative(a) (!(is_non_negative(a))) + + #ifdef COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW + /* +@@ -227,10 +233,10 @@ + typeof(d) _d = d; \ + u64 _a_full = _a; \ + unsigned int _to_shift = \ +- _s >= 0 && _s < 8 * sizeof(*d) ? _s : 0; \ ++ is_non_negative(_s) && _s < 8 * sizeof(*d) ? _s : 0; \ + *_d = (_a_full << _to_shift); \ +- (_to_shift != _s || *_d < 0 || _a < 0 || \ +- (*_d >> _to_shift) != _a); \ ++ (_to_shift != _s || is_negative(*_d) || is_negative(_a) || \ ++ (*_d >> _to_shift) != _a); \ + }) + + /** +diff --git a/include/linux/smpboot.h b/include/linux/smpboot.h +index d0884b525001..9d1bc65d226c 100644 +--- a/include/linux/smpboot.h ++++ b/include/linux/smpboot.h +@@ -29,7 +29,7 @@ struct smpboot_thread_data; + * @thread_comm: The base name of the thread + */ + struct smp_hotplug_thread { +- struct task_struct __percpu **store; ++ struct task_struct * __percpu *store; + struct list_head list; + int (*thread_should_run)(unsigned int cpu); + void (*thread_fn)(unsigned int cpu); +diff --git a/include/linux/time64.h b/include/linux/time64.h +index 05634afba0db..4a45aea0f96e 100644 +--- a/include/linux/time64.h ++++ b/include/linux/time64.h +@@ -41,6 +41,17 @@ struct itimerspec64 { + #define KTIME_MAX ((s64)~((u64)1 << 63)) + #define KTIME_SEC_MAX (KTIME_MAX / NSEC_PER_SEC) + ++/* ++ * Limits for settimeofday(): ++ * ++ * To prevent setting the time close to the wraparound point time setting ++ * is limited so a reasonable uptime can be accomodated. Uptime of 30 years ++ * should be really sufficient, which means the cutoff is 2232. At that ++ * point the cutoff is just a small part of the larger problem. ++ */ ++#define TIME_UPTIME_SEC_MAX (30LL * 365 * 24 *3600) ++#define TIME_SETTOD_SEC_MAX (KTIME_SEC_MAX - TIME_UPTIME_SEC_MAX) ++ + static inline int timespec64_equal(const struct timespec64 *a, + const struct timespec64 *b) + { +@@ -108,6 +119,16 @@ static inline bool timespec64_valid_strict(const struct timespec64 *ts) + return true; + } + ++static inline bool timespec64_valid_settod(const struct timespec64 *ts) ++{ ++ if (!timespec64_valid(ts)) ++ return false; ++ /* Disallow values which cause overflow issues vs. CLOCK_REALTIME */ ++ if ((unsigned long long)ts->tv_sec >= TIME_SETTOD_SEC_MAX) ++ return false; ++ return true; ++} ++ + /** + * timespec64_to_ns - Convert timespec64 to nanoseconds + * @ts: pointer to the timespec64 variable to be converted +diff --git a/include/media/videobuf2-core.h b/include/media/videobuf2-core.h +index f6818f732f34..bddd86c11f5f 100644 +--- a/include/media/videobuf2-core.h ++++ b/include/media/videobuf2-core.h +@@ -551,6 +551,7 @@ struct vb2_queue { + unsigned int start_streaming_called:1; + unsigned int error:1; + unsigned int waiting_for_buffers:1; ++ unsigned int waiting_in_dqbuf:1; + unsigned int is_multiplanar:1; + unsigned int is_output:1; + unsigned int copy_timestamp:1; +diff --git a/include/net/bluetooth/hci.h b/include/net/bluetooth/hci.h +index cdd9f1fe7cfa..845d947dbae8 100644 +--- a/include/net/bluetooth/hci.h ++++ b/include/net/bluetooth/hci.h +@@ -270,6 +270,7 @@ enum { + HCI_FORCE_BREDR_SMP, + HCI_FORCE_STATIC_ADDR, + HCI_LL_RPA_RESOLUTION, ++ HCI_CMD_PENDING, + + __HCI_NUM_FLAGS, + }; +diff --git a/kernel/acct.c b/kernel/acct.c +index addf7732fb56..81f9831a7859 100644 +--- a/kernel/acct.c ++++ b/kernel/acct.c +@@ -227,7 +227,7 @@ static int acct_on(struct filename *pathname) + filp_close(file, NULL); + return PTR_ERR(internal); + } +- err = mnt_want_write(internal); ++ err = __mnt_want_write(internal); + if (err) { + mntput(internal); + kfree(acct); +@@ -252,7 +252,7 @@ static int acct_on(struct filename *pathname) + old = xchg(&ns->bacct, &acct->pin); + mutex_unlock(&acct->lock); + pin_kill(old); +- mnt_drop_write(mnt); ++ __mnt_drop_write(mnt); + mntput(mnt); + return 0; + } +diff --git a/kernel/auditfilter.c b/kernel/auditfilter.c +index bf309f2592c4..425c67e4f568 100644 +--- a/kernel/auditfilter.c ++++ b/kernel/auditfilter.c +@@ -1114,22 +1114,24 @@ int audit_rule_change(int type, int seq, void *data, size_t datasz) + int err = 0; + struct audit_entry *entry; + +- entry = audit_data_to_entry(data, datasz); +- if (IS_ERR(entry)) +- return PTR_ERR(entry); +- + switch (type) { + case AUDIT_ADD_RULE: ++ entry = audit_data_to_entry(data, datasz); ++ if (IS_ERR(entry)) ++ return PTR_ERR(entry); + err = audit_add_rule(entry); + audit_log_rule_change("add_rule", &entry->rule, !err); + break; + case AUDIT_DEL_RULE: ++ entry = audit_data_to_entry(data, datasz); ++ if (IS_ERR(entry)) ++ return PTR_ERR(entry); + err = audit_del_rule(entry); + audit_log_rule_change("remove_rule", &entry->rule, !err); + break; + default: +- err = -EINVAL; + WARN_ON(1); ++ return -EINVAL; + } + + if (err || type == AUDIT_DEL_RULE) { +diff --git a/kernel/bpf/core.c b/kernel/bpf/core.c +index 474525e3a9db..bad9985b8a08 100644 +--- a/kernel/bpf/core.c ++++ b/kernel/bpf/core.c +@@ -366,10 +366,13 @@ void bpf_prog_kallsyms_del_all(struct bpf_prog *fp) + } + + #ifdef CONFIG_BPF_JIT ++# define BPF_JIT_LIMIT_DEFAULT (PAGE_SIZE * 40000) ++ + /* All BPF JIT sysctl knobs here. */ + int bpf_jit_enable __read_mostly = IS_BUILTIN(CONFIG_BPF_JIT_ALWAYS_ON); + int bpf_jit_harden __read_mostly; + int bpf_jit_kallsyms __read_mostly; ++int bpf_jit_limit __read_mostly = BPF_JIT_LIMIT_DEFAULT; + + static __always_inline void + bpf_get_prog_addr_region(const struct bpf_prog *prog, +@@ -578,27 +581,64 @@ int bpf_get_kallsym(unsigned int symnum, unsigned long *value, char *type, + return ret; + } + ++static atomic_long_t bpf_jit_current; ++ ++#if defined(MODULES_VADDR) ++static int __init bpf_jit_charge_init(void) ++{ ++ /* Only used as heuristic here to derive limit. */ ++ bpf_jit_limit = min_t(u64, round_up((MODULES_END - MODULES_VADDR) >> 2, ++ PAGE_SIZE), INT_MAX); ++ return 0; ++} ++pure_initcall(bpf_jit_charge_init); ++#endif ++ ++static int bpf_jit_charge_modmem(u32 pages) ++{ ++ if (atomic_long_add_return(pages, &bpf_jit_current) > ++ (bpf_jit_limit >> PAGE_SHIFT)) { ++ if (!capable(CAP_SYS_ADMIN)) { ++ atomic_long_sub(pages, &bpf_jit_current); ++ return -EPERM; ++ } ++ } ++ ++ return 0; ++} ++ ++static void bpf_jit_uncharge_modmem(u32 pages) ++{ ++ atomic_long_sub(pages, &bpf_jit_current); ++} ++ + struct bpf_binary_header * + bpf_jit_binary_alloc(unsigned int proglen, u8 **image_ptr, + unsigned int alignment, + bpf_jit_fill_hole_t bpf_fill_ill_insns) + { + struct bpf_binary_header *hdr; +- unsigned int size, hole, start; ++ u32 size, hole, start, pages; + + /* Most of BPF filters are really small, but if some of them + * fill a page, allow at least 128 extra bytes to insert a + * random section of illegal instructions. + */ + size = round_up(proglen + sizeof(*hdr) + 128, PAGE_SIZE); ++ pages = size / PAGE_SIZE; ++ ++ if (bpf_jit_charge_modmem(pages)) ++ return NULL; + hdr = module_alloc(size); +- if (hdr == NULL) ++ if (!hdr) { ++ bpf_jit_uncharge_modmem(pages); + return NULL; ++ } + + /* Fill space with illegal/arch-dep instructions. */ + bpf_fill_ill_insns(hdr, size); + +- hdr->pages = size / PAGE_SIZE; ++ hdr->pages = pages; + hole = min_t(unsigned int, size - (proglen + sizeof(*hdr)), + PAGE_SIZE - sizeof(*hdr)); + start = (get_random_int() % hole) & ~(alignment - 1); +@@ -611,7 +651,10 @@ bpf_jit_binary_alloc(unsigned int proglen, u8 **image_ptr, + + void bpf_jit_binary_free(struct bpf_binary_header *hdr) + { ++ u32 pages = hdr->pages; ++ + module_memfree(hdr); ++ bpf_jit_uncharge_modmem(pages); + } + + /* This symbol is only overridden by archs that have different +diff --git a/kernel/bpf/devmap.c b/kernel/bpf/devmap.c +index 141710b82a6c..2faad033715f 100644 +--- a/kernel/bpf/devmap.c ++++ b/kernel/bpf/devmap.c +@@ -164,6 +164,9 @@ static void dev_map_free(struct bpf_map *map) + bpf_clear_redirect_map(map); + synchronize_rcu(); + ++ /* Make sure prior __dev_map_entry_free() have completed. */ ++ rcu_barrier(); ++ + /* To ensure all pending flush operations have completed wait for flush + * bitmap to indicate all flush_needed bits to be zero on _all_ cpus. + * Because the above synchronize_rcu() ensures the map is disconnected +diff --git a/kernel/cgroup/cgroup.c b/kernel/cgroup/cgroup.c +index 63dae7e0ccae..81441117f611 100644 +--- a/kernel/cgroup/cgroup.c ++++ b/kernel/cgroup/cgroup.c +@@ -4659,9 +4659,11 @@ static void css_release_work_fn(struct work_struct *work) + if (cgroup_on_dfl(cgrp)) + cgroup_rstat_flush(cgrp); + ++ spin_lock_irq(&css_set_lock); + for (tcgrp = cgroup_parent(cgrp); tcgrp; + tcgrp = cgroup_parent(tcgrp)) + tcgrp->nr_dying_descendants--; ++ spin_unlock_irq(&css_set_lock); + + cgroup_idr_remove(&cgrp->root->cgroup_idr, cgrp->id); + cgrp->id = -1; +@@ -4874,12 +4876,14 @@ static struct cgroup *cgroup_create(struct cgroup *parent) + if (ret) + goto out_idr_free; + ++ spin_lock_irq(&css_set_lock); + for (tcgrp = cgrp; tcgrp; tcgrp = cgroup_parent(tcgrp)) { + cgrp->ancestor_ids[tcgrp->level] = tcgrp->id; + + if (tcgrp != cgrp) + tcgrp->nr_descendants++; + } ++ spin_unlock_irq(&css_set_lock); + + if (notify_on_release(parent)) + set_bit(CGRP_NOTIFY_ON_RELEASE, &cgrp->flags); +@@ -5162,10 +5166,12 @@ static int cgroup_destroy_locked(struct cgroup *cgrp) + if (parent && cgroup_is_threaded(cgrp)) + parent->nr_threaded_children--; + ++ spin_lock_irq(&css_set_lock); + for (tcgrp = cgroup_parent(cgrp); tcgrp; tcgrp = cgroup_parent(tcgrp)) { + tcgrp->nr_descendants--; + tcgrp->nr_dying_descendants++; + } ++ spin_unlock_irq(&css_set_lock); + + cgroup1_check_for_release(parent); + +diff --git a/kernel/irq_work.c b/kernel/irq_work.c +index 6b7cdf17ccf8..73288914ed5e 100644 +--- a/kernel/irq_work.c ++++ b/kernel/irq_work.c +@@ -56,61 +56,70 @@ void __weak arch_irq_work_raise(void) + */ + } + +-/* +- * Enqueue the irq_work @work on @cpu unless it's already pending +- * somewhere. +- * +- * Can be re-enqueued while the callback is still in progress. +- */ +-bool irq_work_queue_on(struct irq_work *work, int cpu) ++/* Enqueue on current CPU, work must already be claimed and preempt disabled */ ++static void __irq_work_queue_local(struct irq_work *work) + { +- /* All work should have been flushed before going offline */ +- WARN_ON_ONCE(cpu_is_offline(cpu)); +- +-#ifdef CONFIG_SMP +- +- /* Arch remote IPI send/receive backend aren't NMI safe */ +- WARN_ON_ONCE(in_nmi()); ++ /* If the work is "lazy", handle it from next tick if any */ ++ if (work->flags & IRQ_WORK_LAZY) { ++ if (llist_add(&work->llnode, this_cpu_ptr(&lazy_list)) && ++ tick_nohz_tick_stopped()) ++ arch_irq_work_raise(); ++ } else { ++ if (llist_add(&work->llnode, this_cpu_ptr(&raised_list))) ++ arch_irq_work_raise(); ++ } ++} + ++/* Enqueue the irq work @work on the current CPU */ ++bool irq_work_queue(struct irq_work *work) ++{ + /* Only queue if not already pending */ + if (!irq_work_claim(work)) + return false; + +- if (llist_add(&work->llnode, &per_cpu(raised_list, cpu))) +- arch_send_call_function_single_ipi(cpu); +- +-#else /* #ifdef CONFIG_SMP */ +- irq_work_queue(work); +-#endif /* #else #ifdef CONFIG_SMP */ ++ /* Queue the entry and raise the IPI if needed. */ ++ preempt_disable(); ++ __irq_work_queue_local(work); ++ preempt_enable(); + + return true; + } ++EXPORT_SYMBOL_GPL(irq_work_queue); + +-/* Enqueue the irq work @work on the current CPU */ +-bool irq_work_queue(struct irq_work *work) ++/* ++ * Enqueue the irq_work @work on @cpu unless it's already pending ++ * somewhere. ++ * ++ * Can be re-enqueued while the callback is still in progress. ++ */ ++bool irq_work_queue_on(struct irq_work *work, int cpu) + { ++#ifndef CONFIG_SMP ++ return irq_work_queue(work); ++ ++#else /* CONFIG_SMP: */ ++ /* All work should have been flushed before going offline */ ++ WARN_ON_ONCE(cpu_is_offline(cpu)); ++ + /* Only queue if not already pending */ + if (!irq_work_claim(work)) + return false; + +- /* Queue the entry and raise the IPI if needed. */ + preempt_disable(); +- +- /* If the work is "lazy", handle it from next tick if any */ +- if (work->flags & IRQ_WORK_LAZY) { +- if (llist_add(&work->llnode, this_cpu_ptr(&lazy_list)) && +- tick_nohz_tick_stopped()) +- arch_irq_work_raise(); ++ if (cpu != smp_processor_id()) { ++ /* Arch remote IPI send/receive backend aren't NMI safe */ ++ WARN_ON_ONCE(in_nmi()); ++ if (llist_add(&work->llnode, &per_cpu(raised_list, cpu))) ++ arch_send_call_function_single_ipi(cpu); + } else { +- if (llist_add(&work->llnode, this_cpu_ptr(&raised_list))) +- arch_irq_work_raise(); ++ __irq_work_queue_local(work); + } +- + preempt_enable(); + + return true; ++#endif /* CONFIG_SMP */ + } +-EXPORT_SYMBOL_GPL(irq_work_queue); ++ + + bool irq_work_needs_cpu(void) + { +diff --git a/kernel/module.c b/kernel/module.c +index 38bf28b5cc20..f797c6ace712 100644 +--- a/kernel/module.c ++++ b/kernel/module.c +@@ -1949,8 +1949,13 @@ void module_enable_ro(const struct module *mod, bool after_init) + return; + + frob_text(&mod->core_layout, set_memory_ro); ++ frob_text(&mod->core_layout, set_memory_x); ++ + frob_rodata(&mod->core_layout, set_memory_ro); ++ + frob_text(&mod->init_layout, set_memory_ro); ++ frob_text(&mod->init_layout, set_memory_x); ++ + frob_rodata(&mod->init_layout, set_memory_ro); + + if (after_init) +diff --git a/kernel/rcu/rcuperf.c b/kernel/rcu/rcuperf.c +index 34244523550e..19249b86fb33 100644 +--- a/kernel/rcu/rcuperf.c ++++ b/kernel/rcu/rcuperf.c +@@ -561,6 +561,10 @@ rcu_perf_cleanup(void) + + if (torture_cleanup_begin()) + return; ++ if (!cur_ops) { ++ torture_cleanup_end(); ++ return; ++ } + + if (reader_tasks) { + for (i = 0; i < nrealreaders; i++) +@@ -681,6 +685,7 @@ rcu_perf_init(void) + pr_cont(" %s", perf_ops[i]->name); + pr_cont("\n"); + firsterr = -EINVAL; ++ cur_ops = NULL; + goto unwind; + } + if (cur_ops->init) +diff --git a/kernel/rcu/rcutorture.c b/kernel/rcu/rcutorture.c +index c596c6f1e457..0b7af7e2bcbb 100644 +--- a/kernel/rcu/rcutorture.c ++++ b/kernel/rcu/rcutorture.c +@@ -1826,6 +1826,10 @@ rcu_torture_cleanup(void) + cur_ops->cb_barrier(); + return; + } ++ if (!cur_ops) { ++ torture_cleanup_end(); ++ return; ++ } + + rcu_torture_barrier_cleanup(); + torture_stop_kthread(rcu_torture_stall, stall_task); +@@ -1964,6 +1968,7 @@ rcu_torture_init(void) + pr_cont(" %s", torture_ops[i]->name); + pr_cont("\n"); + firsterr = -EINVAL; ++ cur_ops = NULL; + goto unwind; + } + if (cur_ops->fqs == NULL && fqs_duration != 0) { +diff --git a/kernel/sched/core.c b/kernel/sched/core.c +index d7f409866cdf..6138754e5030 100644 +--- a/kernel/sched/core.c ++++ b/kernel/sched/core.c +@@ -6491,6 +6491,8 @@ static void cpu_cgroup_attach(struct cgroup_taskset *tset) + static int cpu_shares_write_u64(struct cgroup_subsys_state *css, + struct cftype *cftype, u64 shareval) + { ++ if (shareval > scale_load_down(ULONG_MAX)) ++ shareval = MAX_SHARES; + return sched_group_set_shares(css_tg(css), scale_load(shareval)); + } + +@@ -6593,8 +6595,10 @@ int tg_set_cfs_quota(struct task_group *tg, long cfs_quota_us) + period = ktime_to_ns(tg->cfs_bandwidth.period); + if (cfs_quota_us < 0) + quota = RUNTIME_INF; +- else ++ else if ((u64)cfs_quota_us <= U64_MAX / NSEC_PER_USEC) + quota = (u64)cfs_quota_us * NSEC_PER_USEC; ++ else ++ return -EINVAL; + + return tg_set_cfs_bandwidth(tg, period, quota); + } +@@ -6616,6 +6620,9 @@ int tg_set_cfs_period(struct task_group *tg, long cfs_period_us) + { + u64 quota, period; + ++ if ((u64)cfs_period_us > U64_MAX / NSEC_PER_USEC) ++ return -EINVAL; ++ + period = (u64)cfs_period_us * NSEC_PER_USEC; + quota = tg->cfs_bandwidth.quota; + +diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c +index d31916366d39..7a1e9db617f7 100644 +--- a/kernel/sched/fair.c ++++ b/kernel/sched/fair.c +@@ -9083,22 +9083,26 @@ static inline int on_null_domain(struct rq *rq) + * - When one of the busy CPUs notice that there may be an idle rebalancing + * needed, they will kick the idle load balancer, which then does idle + * load balancing for all the idle CPUs. ++ * - HK_FLAG_MISC CPUs are used for this task, because HK_FLAG_SCHED not set ++ * anywhere yet. + */ + + static inline int find_new_ilb(void) + { +- int ilb = cpumask_first(nohz.idle_cpus_mask); ++ int ilb; + +- if (ilb < nr_cpu_ids && idle_cpu(ilb)) +- return ilb; ++ for_each_cpu_and(ilb, nohz.idle_cpus_mask, ++ housekeeping_cpumask(HK_FLAG_MISC)) { ++ if (idle_cpu(ilb)) ++ return ilb; ++ } + + return nr_cpu_ids; + } + + /* +- * Kick a CPU to do the nohz balancing, if it is time for it. We pick the +- * nohz_load_balancer CPU (if there is one) otherwise fallback to any idle +- * CPU (if there is one). ++ * Kick a CPU to do the nohz balancing, if it is time for it. We pick any ++ * idle CPU in the HK_FLAG_MISC housekeeping set (if there is one). + */ + static void kick_ilb(unsigned int flags) + { +diff --git a/kernel/sched/rt.c b/kernel/sched/rt.c +index 2e2955a8cf8f..b980cc96604f 100644 +--- a/kernel/sched/rt.c ++++ b/kernel/sched/rt.c +@@ -2559,6 +2559,8 @@ int sched_group_set_rt_runtime(struct task_group *tg, long rt_runtime_us) + rt_runtime = (u64)rt_runtime_us * NSEC_PER_USEC; + if (rt_runtime_us < 0) + rt_runtime = RUNTIME_INF; ++ else if ((u64)rt_runtime_us > U64_MAX / NSEC_PER_USEC) ++ return -EINVAL; + + return tg_set_rt_bandwidth(tg, rt_period, rt_runtime); + } +@@ -2579,6 +2581,9 @@ int sched_group_set_rt_period(struct task_group *tg, u64 rt_period_us) + { + u64 rt_runtime, rt_period; + ++ if (rt_period_us > U64_MAX / NSEC_PER_USEC) ++ return -EINVAL; ++ + rt_period = rt_period_us * NSEC_PER_USEC; + rt_runtime = tg->rt_bandwidth.rt_runtime; + +diff --git a/kernel/time/time.c b/kernel/time/time.c +index ccdb351277ee..be057d6579f1 100644 +--- a/kernel/time/time.c ++++ b/kernel/time/time.c +@@ -172,7 +172,7 @@ int do_sys_settimeofday64(const struct timespec64 *tv, const struct timezone *tz + static int firsttime = 1; + int error = 0; + +- if (tv && !timespec64_valid(tv)) ++ if (tv && !timespec64_valid_settod(tv)) + return -EINVAL; + + error = security_settime64(tv, tz); +diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c +index 7846ce24ecc0..9a6bfcd22dc6 100644 +--- a/kernel/time/timekeeping.c ++++ b/kernel/time/timekeeping.c +@@ -1242,7 +1242,7 @@ int do_settimeofday64(const struct timespec64 *ts) + unsigned long flags; + int ret = 0; + +- if (!timespec64_valid_strict(ts)) ++ if (!timespec64_valid_settod(ts)) + return -EINVAL; + + raw_spin_lock_irqsave(&timekeeper_lock, flags); +@@ -1299,7 +1299,7 @@ static int timekeeping_inject_offset(const struct timespec64 *ts) + /* Make sure the proposed value is valid */ + tmp = timespec64_add(tk_xtime(tk), *ts); + if (timespec64_compare(&tk->wall_to_monotonic, ts) > 0 || +- !timespec64_valid_strict(&tmp)) { ++ !timespec64_valid_settod(&tmp)) { + ret = -EINVAL; + goto error; + } +@@ -1556,7 +1556,7 @@ void __init timekeeping_init(void) + unsigned long flags; + + read_persistent_wall_and_boot_offset(&wall_time, &boot_offset); +- if (timespec64_valid_strict(&wall_time) && ++ if (timespec64_valid_settod(&wall_time) && + timespec64_to_ns(&wall_time) > 0) { + persistent_clock_exists = true; + } else if (timespec64_to_ns(&wall_time) != 0) { +diff --git a/kernel/trace/trace_branch.c b/kernel/trace/trace_branch.c +index 4ad967453b6f..3ea65cdff30d 100644 +--- a/kernel/trace/trace_branch.c ++++ b/kernel/trace/trace_branch.c +@@ -205,6 +205,8 @@ void trace_likely_condition(struct ftrace_likely_data *f, int val, int expect) + void ftrace_likely_update(struct ftrace_likely_data *f, int val, + int expect, int is_constant) + { ++ unsigned long flags = user_access_save(); ++ + /* A constant is always correct */ + if (is_constant) { + f->constant++; +@@ -223,6 +225,8 @@ void ftrace_likely_update(struct ftrace_likely_data *f, int val, + f->data.correct++; + else + f->data.incorrect++; ++ ++ user_access_restore(flags); + } + EXPORT_SYMBOL(ftrace_likely_update); + +diff --git a/lib/kobject_uevent.c b/lib/kobject_uevent.c +index 63d0816ab23b..7761f3294339 100644 +--- a/lib/kobject_uevent.c ++++ b/lib/kobject_uevent.c +@@ -464,6 +464,13 @@ int kobject_uevent_env(struct kobject *kobj, enum kobject_action action, + int i = 0; + int retval = 0; + ++ /* ++ * Mark "remove" event done regardless of result, for some subsystems ++ * do not want to re-trigger "remove" event via automatic cleanup. ++ */ ++ if (action == KOBJ_REMOVE) ++ kobj->state_remove_uevent_sent = 1; ++ + pr_debug("kobject: '%s' (%p): %s\n", + kobject_name(kobj), kobj, __func__); + +@@ -565,10 +572,6 @@ int kobject_uevent_env(struct kobject *kobj, enum kobject_action action, + kobj->state_add_uevent_sent = 1; + break; + +- case KOBJ_REMOVE: +- kobj->state_remove_uevent_sent = 1; +- break; +- + case KOBJ_UNBIND: + zap_modalias_env(env); + break; +diff --git a/lib/sbitmap.c b/lib/sbitmap.c +index fdd1b8aa8ac6..0572ac340325 100644 +--- a/lib/sbitmap.c ++++ b/lib/sbitmap.c +@@ -356,7 +356,7 @@ static void sbitmap_queue_update_wake_batch(struct sbitmap_queue *sbq, + * to ensure that the batch size is updated before the wait + * counts. + */ +- smp_mb__before_atomic(); ++ smp_mb(); + for (i = 0; i < SBQ_WAIT_QUEUES; i++) + atomic_set(&sbq->ws[i].wait_cnt, 1); + } +diff --git a/lib/strncpy_from_user.c b/lib/strncpy_from_user.c +index b53e1b5d80f4..e304b54c9c7d 100644 +--- a/lib/strncpy_from_user.c ++++ b/lib/strncpy_from_user.c +@@ -23,10 +23,11 @@ + * hit it), 'max' is the address space maximum (and we return + * -EFAULT if we hit it). + */ +-static inline long do_strncpy_from_user(char *dst, const char __user *src, long count, unsigned long max) ++static inline long do_strncpy_from_user(char *dst, const char __user *src, ++ unsigned long count, unsigned long max) + { + const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS; +- long res = 0; ++ unsigned long res = 0; + + /* + * Truncate 'max' to the user-specified limit, so that +diff --git a/lib/strnlen_user.c b/lib/strnlen_user.c +index 60d0bbda8f5e..184f80f7bacf 100644 +--- a/lib/strnlen_user.c ++++ b/lib/strnlen_user.c +@@ -28,7 +28,7 @@ + static inline long do_strnlen_user(const char __user *src, unsigned long count, unsigned long max) + { + const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS; +- long align, res = 0; ++ unsigned long align, res = 0; + unsigned long c; + + /* +@@ -42,7 +42,7 @@ static inline long do_strnlen_user(const char __user *src, unsigned long count, + * Do everything aligned. But that means that we + * need to also expand the maximum.. + */ +- align = (sizeof(long) - 1) & (unsigned long)src; ++ align = (sizeof(unsigned long) - 1) & (unsigned long)src; + src -= align; + max += align; + +diff --git a/net/batman-adv/distributed-arp-table.c b/net/batman-adv/distributed-arp-table.c +index a60bacf7120b..2895e3b26e93 100644 +--- a/net/batman-adv/distributed-arp-table.c ++++ b/net/batman-adv/distributed-arp-table.c +@@ -1394,7 +1394,6 @@ bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv, + hw_src, &ip_src, hw_dst, &ip_dst, + dat_entry->mac_addr, &dat_entry->ip); + dropped = true; +- goto out; + } + + /* Update our internal cache with both the IP addresses the node got +@@ -1403,6 +1402,9 @@ bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv, + batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid); + batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid); + ++ if (dropped) ++ goto out; ++ + /* If BLA is enabled, only forward ARP replies if we have claimed the + * source of the ARP reply or if no one else of the same backbone has + * already claimed that client. This prevents that different gateways +diff --git a/net/batman-adv/main.c b/net/batman-adv/main.c +index 69c0d85bceb3..79b8a2d8793e 100644 +--- a/net/batman-adv/main.c ++++ b/net/batman-adv/main.c +@@ -160,6 +160,7 @@ int batadv_mesh_init(struct net_device *soft_iface) + spin_lock_init(&bat_priv->tt.commit_lock); + spin_lock_init(&bat_priv->gw.list_lock); + #ifdef CONFIG_BATMAN_ADV_MCAST ++ spin_lock_init(&bat_priv->mcast.mla_lock); + spin_lock_init(&bat_priv->mcast.want_lists_lock); + #endif + spin_lock_init(&bat_priv->tvlv.container_list_lock); +diff --git a/net/batman-adv/multicast.c b/net/batman-adv/multicast.c +index 86725d792e15..b90fe25d6b0b 100644 +--- a/net/batman-adv/multicast.c ++++ b/net/batman-adv/multicast.c +@@ -325,8 +325,6 @@ static void batadv_mcast_mla_list_free(struct hlist_head *mcast_list) + * translation table except the ones listed in the given mcast_list. + * + * If mcast_list is NULL then all are retracted. +- * +- * Do not call outside of the mcast worker! (or cancel mcast worker first) + */ + static void batadv_mcast_mla_tt_retract(struct batadv_priv *bat_priv, + struct hlist_head *mcast_list) +@@ -334,8 +332,6 @@ static void batadv_mcast_mla_tt_retract(struct batadv_priv *bat_priv, + struct batadv_hw_addr *mcast_entry; + struct hlist_node *tmp; + +- WARN_ON(delayed_work_pending(&bat_priv->mcast.work)); +- + hlist_for_each_entry_safe(mcast_entry, tmp, &bat_priv->mcast.mla_list, + list) { + if (mcast_list && +@@ -359,8 +355,6 @@ static void batadv_mcast_mla_tt_retract(struct batadv_priv *bat_priv, + * + * Adds multicast listener announcements from the given mcast_list to the + * translation table if they have not been added yet. +- * +- * Do not call outside of the mcast worker! (or cancel mcast worker first) + */ + static void batadv_mcast_mla_tt_add(struct batadv_priv *bat_priv, + struct hlist_head *mcast_list) +@@ -368,8 +362,6 @@ static void batadv_mcast_mla_tt_add(struct batadv_priv *bat_priv, + struct batadv_hw_addr *mcast_entry; + struct hlist_node *tmp; + +- WARN_ON(delayed_work_pending(&bat_priv->mcast.work)); +- + if (!mcast_list) + return; + +@@ -658,7 +650,10 @@ static void batadv_mcast_mla_update(struct work_struct *work) + priv_mcast = container_of(delayed_work, struct batadv_priv_mcast, work); + bat_priv = container_of(priv_mcast, struct batadv_priv, mcast); + ++ spin_lock(&bat_priv->mcast.mla_lock); + __batadv_mcast_mla_update(bat_priv); ++ spin_unlock(&bat_priv->mcast.mla_lock); ++ + batadv_mcast_start_timer(bat_priv); + } + +diff --git a/net/batman-adv/types.h b/net/batman-adv/types.h +index 343d304851a5..eeee3e61c625 100644 +--- a/net/batman-adv/types.h ++++ b/net/batman-adv/types.h +@@ -1215,6 +1215,11 @@ struct batadv_priv_mcast { + /** @bridged: whether the soft interface has a bridge on top */ + unsigned char bridged:1; + ++ /** ++ * @mla_lock: a lock protecting mla_list and mla_flags ++ */ ++ spinlock_t mla_lock; ++ + /** + * @num_want_all_unsnoopables: number of nodes wanting unsnoopable IP + * traffic +diff --git a/net/bluetooth/hci_core.c b/net/bluetooth/hci_core.c +index a06f03047717..5afd67ef797a 100644 +--- a/net/bluetooth/hci_core.c ++++ b/net/bluetooth/hci_core.c +@@ -4274,6 +4274,9 @@ void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status, + return; + } + ++ /* If we reach this point this event matches the last command sent */ ++ hci_dev_clear_flag(hdev, HCI_CMD_PENDING); ++ + /* If the command succeeded and there's still more commands in + * this request the request is not yet complete. + */ +@@ -4384,6 +4387,8 @@ static void hci_cmd_work(struct work_struct *work) + + hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); + if (hdev->sent_cmd) { ++ if (hci_req_status_pend(hdev)) ++ hci_dev_set_flag(hdev, HCI_CMD_PENDING); + atomic_dec(&hdev->cmd_cnt); + hci_send_frame(hdev, skb); + if (test_bit(HCI_RESET, &hdev->flags)) +diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c +index 7f800c3480f7..3e7badb3ac2d 100644 +--- a/net/bluetooth/hci_event.c ++++ b/net/bluetooth/hci_event.c +@@ -3357,6 +3357,12 @@ static void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb, + hci_req_cmd_complete(hdev, *opcode, *status, req_complete, + req_complete_skb); + ++ if (hci_dev_test_flag(hdev, HCI_CMD_PENDING)) { ++ bt_dev_err(hdev, ++ "unexpected event for opcode 0x%4.4x", *opcode); ++ return; ++ } ++ + if (atomic_read(&hdev->cmd_cnt) && !skb_queue_empty(&hdev->cmd_q)) + queue_work(hdev->workqueue, &hdev->cmd_work); + } +@@ -3464,6 +3470,12 @@ static void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb, + hci_req_cmd_complete(hdev, *opcode, ev->status, req_complete, + req_complete_skb); + ++ if (hci_dev_test_flag(hdev, HCI_CMD_PENDING)) { ++ bt_dev_err(hdev, ++ "unexpected event for opcode 0x%4.4x", *opcode); ++ return; ++ } ++ + if (atomic_read(&hdev->cmd_cnt) && !skb_queue_empty(&hdev->cmd_q)) + queue_work(hdev->workqueue, &hdev->cmd_work); + } +diff --git a/net/bluetooth/hci_request.c b/net/bluetooth/hci_request.c +index e8c9ef1e1922..9448ebd3780a 100644 +--- a/net/bluetooth/hci_request.c ++++ b/net/bluetooth/hci_request.c +@@ -46,6 +46,11 @@ void hci_req_purge(struct hci_request *req) + skb_queue_purge(&req->cmd_q); + } + ++bool hci_req_status_pend(struct hci_dev *hdev) ++{ ++ return hdev->req_status == HCI_REQ_PEND; ++} ++ + static int req_run(struct hci_request *req, hci_req_complete_t complete, + hci_req_complete_skb_t complete_skb) + { +diff --git a/net/bluetooth/hci_request.h b/net/bluetooth/hci_request.h +index 692cc8b13368..55b2050cc9ff 100644 +--- a/net/bluetooth/hci_request.h ++++ b/net/bluetooth/hci_request.h +@@ -37,6 +37,7 @@ struct hci_request { + + void hci_req_init(struct hci_request *req, struct hci_dev *hdev); + void hci_req_purge(struct hci_request *req); ++bool hci_req_status_pend(struct hci_dev *hdev); + int hci_req_run(struct hci_request *req, hci_req_complete_t complete); + int hci_req_run_skb(struct hci_request *req, hci_req_complete_skb_t complete); + void hci_req_add(struct hci_request *req, u16 opcode, u32 plen, +diff --git a/net/core/sysctl_net_core.c b/net/core/sysctl_net_core.c +index b1a2c5e38530..37b4667128a3 100644 +--- a/net/core/sysctl_net_core.c ++++ b/net/core/sysctl_net_core.c +@@ -279,7 +279,6 @@ static int proc_dointvec_minmax_bpf_enable(struct ctl_table *table, int write, + return ret; + } + +-# ifdef CONFIG_HAVE_EBPF_JIT + static int + proc_dointvec_minmax_bpf_restricted(struct ctl_table *table, int write, + void __user *buffer, size_t *lenp, +@@ -290,7 +289,6 @@ proc_dointvec_minmax_bpf_restricted(struct ctl_table *table, int write, + + return proc_dointvec_minmax(table, write, buffer, lenp, ppos); + } +-# endif + #endif + + static struct ctl_table net_core_table[] = { +@@ -397,6 +395,14 @@ static struct ctl_table net_core_table[] = { + .extra2 = &one, + }, + # endif ++ { ++ .procname = "bpf_jit_limit", ++ .data = &bpf_jit_limit, ++ .maxlen = sizeof(int), ++ .mode = 0600, ++ .proc_handler = proc_dointvec_minmax_bpf_restricted, ++ .extra1 = &one, ++ }, + #endif + { + .procname = "netdev_tstamp_prequeue", +diff --git a/net/mac80211/mlme.c b/net/mac80211/mlme.c +index 3dbecae4be73..2ac749c4a6b2 100644 +--- a/net/mac80211/mlme.c ++++ b/net/mac80211/mlme.c +@@ -1156,9 +1156,6 @@ static void ieee80211_chswitch_work(struct work_struct *work) + goto out; + } + +- /* XXX: shouldn't really modify cfg80211-owned data! */ +- ifmgd->associated->channel = sdata->csa_chandef.chan; +- + ifmgd->csa_waiting_bcn = true; + + ieee80211_sta_reset_beacon_monitor(sdata); +diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c +index 048e004ed0ee..c6711ead5e59 100644 +--- a/net/wireless/nl80211.c ++++ b/net/wireless/nl80211.c +@@ -15441,6 +15441,11 @@ void cfg80211_ch_switch_notify(struct net_device *dev, + + wdev->chandef = *chandef; + wdev->preset_chandef = *chandef; ++ ++ if (wdev->iftype == NL80211_IFTYPE_STATION && ++ !WARN_ON(!wdev->current_bss)) ++ wdev->current_bss->pub.channel = chandef->chan; ++ + nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL, + NL80211_CMD_CH_SWITCH_NOTIFY, 0); + } +diff --git a/security/selinux/netlabel.c b/security/selinux/netlabel.c +index 186e727b737b..6fd9954e1c08 100644 +--- a/security/selinux/netlabel.c ++++ b/security/selinux/netlabel.c +@@ -288,11 +288,8 @@ int selinux_netlbl_sctp_assoc_request(struct sctp_endpoint *ep, + int rc; + struct netlbl_lsm_secattr secattr; + struct sk_security_struct *sksec = ep->base.sk->sk_security; +- struct sockaddr *addr; + struct sockaddr_in addr4; +-#if IS_ENABLED(CONFIG_IPV6) + struct sockaddr_in6 addr6; +-#endif + + if (ep->base.sk->sk_family != PF_INET && + ep->base.sk->sk_family != PF_INET6) +@@ -310,16 +307,15 @@ int selinux_netlbl_sctp_assoc_request(struct sctp_endpoint *ep, + if (ip_hdr(skb)->version == 4) { + addr4.sin_family = AF_INET; + addr4.sin_addr.s_addr = ip_hdr(skb)->saddr; +- addr = (struct sockaddr *)&addr4; +-#if IS_ENABLED(CONFIG_IPV6) +- } else { ++ rc = netlbl_conn_setattr(ep->base.sk, (void *)&addr4, &secattr); ++ } else if (IS_ENABLED(CONFIG_IPV6) && ip_hdr(skb)->version == 6) { + addr6.sin6_family = AF_INET6; + addr6.sin6_addr = ipv6_hdr(skb)->saddr; +- addr = (struct sockaddr *)&addr6; +-#endif ++ rc = netlbl_conn_setattr(ep->base.sk, (void *)&addr6, &secattr); ++ } else { ++ rc = -EAFNOSUPPORT; + } + +- rc = netlbl_conn_setattr(ep->base.sk, addr, &secattr); + if (rc == 0) + sksec->nlbl_state = NLBL_LABELED; + +diff --git a/sound/soc/codecs/hdmi-codec.c b/sound/soc/codecs/hdmi-codec.c +index d5f73c837281..7994e8ddc7d2 100644 +--- a/sound/soc/codecs/hdmi-codec.c ++++ b/sound/soc/codecs/hdmi-codec.c +@@ -439,8 +439,12 @@ static int hdmi_codec_startup(struct snd_pcm_substream *substream, + if (!ret) { + ret = snd_pcm_hw_constraint_eld(substream->runtime, + hcp->eld); +- if (ret) ++ if (ret) { ++ mutex_lock(&hcp->current_stream_lock); ++ hcp->current_stream = NULL; ++ mutex_unlock(&hcp->current_stream_lock); + return ret; ++ } + } + /* Select chmap supported */ + hdmi_codec_eld_chmap(hcp); +diff --git a/sound/soc/davinci/davinci-mcasp.c b/sound/soc/davinci/davinci-mcasp.c +index f70db8412c7c..160b2764b2ad 100644 +--- a/sound/soc/davinci/davinci-mcasp.c ++++ b/sound/soc/davinci/davinci-mcasp.c +@@ -43,6 +43,7 @@ + + #define MCASP_MAX_AFIFO_DEPTH 64 + ++#ifdef CONFIG_PM + static u32 context_regs[] = { + DAVINCI_MCASP_TXFMCTL_REG, + DAVINCI_MCASP_RXFMCTL_REG, +@@ -65,6 +66,7 @@ struct davinci_mcasp_context { + u32 *xrsr_regs; /* for serializer configuration */ + bool pm_state; + }; ++#endif + + struct davinci_mcasp_ruledata { + struct davinci_mcasp *mcasp; +diff --git a/sound/soc/fsl/Kconfig b/sound/soc/fsl/Kconfig +index 2e75b5bc5f1d..f721cd4e3f97 100644 +--- a/sound/soc/fsl/Kconfig ++++ b/sound/soc/fsl/Kconfig +@@ -173,16 +173,17 @@ config SND_MPC52xx_SOC_EFIKA + + endif # SND_POWERPC_SOC + ++config SND_SOC_IMX_PCM_FIQ ++ tristate ++ default y if SND_SOC_IMX_SSI=y && (SND_SOC_FSL_SSI=m || SND_SOC_FSL_SPDIF=m) && (MXC_TZIC || MXC_AVIC) ++ select FIQ ++ + if SND_IMX_SOC + + config SND_SOC_IMX_SSI + tristate + select SND_SOC_FSL_UTILS + +-config SND_SOC_IMX_PCM_FIQ +- tristate +- select FIQ +- + comment "SoC Audio support for Freescale i.MX boards:" + + config SND_MXC_SOC_WM1133_EV1 +diff --git a/sound/soc/fsl/eukrea-tlv320.c b/sound/soc/fsl/eukrea-tlv320.c +index 191426a6d9ad..30a3d68b5c03 100644 +--- a/sound/soc/fsl/eukrea-tlv320.c ++++ b/sound/soc/fsl/eukrea-tlv320.c +@@ -118,13 +118,13 @@ static int eukrea_tlv320_probe(struct platform_device *pdev) + if (ret) { + dev_err(&pdev->dev, + "fsl,mux-int-port node missing or invalid.\n"); +- return ret; ++ goto err; + } + ret = of_property_read_u32(np, "fsl,mux-ext-port", &ext_port); + if (ret) { + dev_err(&pdev->dev, + "fsl,mux-ext-port node missing or invalid.\n"); +- return ret; ++ goto err; + } + + /* +diff --git a/sound/soc/fsl/fsl_sai.c b/sound/soc/fsl/fsl_sai.c +index 4163f2cfc06f..bfc5b21d0c3f 100644 +--- a/sound/soc/fsl/fsl_sai.c ++++ b/sound/soc/fsl/fsl_sai.c +@@ -268,12 +268,14 @@ static int fsl_sai_set_dai_fmt_tr(struct snd_soc_dai *cpu_dai, + case SND_SOC_DAIFMT_CBS_CFS: + val_cr2 |= FSL_SAI_CR2_BCD_MSTR; + val_cr4 |= FSL_SAI_CR4_FSD_MSTR; ++ sai->is_slave_mode = false; + break; + case SND_SOC_DAIFMT_CBM_CFM: + sai->is_slave_mode = true; + break; + case SND_SOC_DAIFMT_CBS_CFM: + val_cr2 |= FSL_SAI_CR2_BCD_MSTR; ++ sai->is_slave_mode = false; + break; + case SND_SOC_DAIFMT_CBM_CFS: + val_cr4 |= FSL_SAI_CR4_FSD_MSTR; +diff --git a/sound/soc/fsl/fsl_utils.c b/sound/soc/fsl/fsl_utils.c +index 7f0fa4b52223..cca33ab7020a 100644 +--- a/sound/soc/fsl/fsl_utils.c ++++ b/sound/soc/fsl/fsl_utils.c +@@ -71,6 +71,7 @@ int fsl_asoc_get_dma_channel(struct device_node *ssi_np, + iprop = of_get_property(dma_np, "cell-index", NULL); + if (!iprop) { + of_node_put(dma_np); ++ of_node_put(dma_channel_np); + return -EINVAL; + } + *dma_id = be32_to_cpup(iprop); +diff --git a/sound/soc/intel/boards/kbl_da7219_max98357a.c b/sound/soc/intel/boards/kbl_da7219_max98357a.c +index 38f6ab74709d..07491a0f8fb8 100644 +--- a/sound/soc/intel/boards/kbl_da7219_max98357a.c ++++ b/sound/soc/intel/boards/kbl_da7219_max98357a.c +@@ -188,7 +188,7 @@ static int kabylake_da7219_codec_init(struct snd_soc_pcm_runtime *rtd) + + jack = &ctx->kabylake_headset; + +- snd_jack_set_key(jack->jack, SND_JACK_BTN_0, KEY_MEDIA); ++ snd_jack_set_key(jack->jack, SND_JACK_BTN_0, KEY_PLAYPAUSE); + snd_jack_set_key(jack->jack, SND_JACK_BTN_1, KEY_VOLUMEUP); + snd_jack_set_key(jack->jack, SND_JACK_BTN_2, KEY_VOLUMEDOWN); + snd_jack_set_key(jack->jack, SND_JACK_BTN_3, KEY_VOICECOMMAND); +diff --git a/tools/bpf/bpftool/.gitignore b/tools/bpf/bpftool/.gitignore +index 67167e44b726..8248b8dd89d4 100644 +--- a/tools/bpf/bpftool/.gitignore ++++ b/tools/bpf/bpftool/.gitignore +@@ -1,5 +1,5 @@ + *.d +-bpftool ++/bpftool + bpftool*.8 + bpf-helpers.* + FEATURE-DUMP.bpftool +diff --git a/tools/lib/bpf/bpf.c b/tools/lib/bpf/bpf.c +index 7a0014794bff..dd0b68d1f4be 100644 +--- a/tools/lib/bpf/bpf.c ++++ b/tools/lib/bpf/bpf.c +@@ -53,6 +53,8 @@ + # define __NR_bpf 349 + # elif defined(__s390__) + # define __NR_bpf 351 ++# elif defined(__arc__) ++# define __NR_bpf 280 + # else + # error __NR_bpf not defined. libbpf does not support your arch. + # endif +diff --git a/tools/lib/bpf/bpf.h b/tools/lib/bpf/bpf.h +index 6f38164b2618..c3145ab3bdca 100644 +--- a/tools/lib/bpf/bpf.h ++++ b/tools/lib/bpf/bpf.h +@@ -26,6 +26,7 @@ + #include <linux/bpf.h> + #include <stdbool.h> + #include <stddef.h> ++#include <stdint.h> + + struct bpf_create_map_attr { + const char *name; +diff --git a/tools/testing/selftests/bpf/test_libbpf_open.c b/tools/testing/selftests/bpf/test_libbpf_open.c +index 8fcd1c076add..cbd55f5f8d59 100644 +--- a/tools/testing/selftests/bpf/test_libbpf_open.c ++++ b/tools/testing/selftests/bpf/test_libbpf_open.c +@@ -11,6 +11,8 @@ static const char *__doc__ = + #include <bpf/libbpf.h> + #include <getopt.h> + ++#include "bpf_rlimit.h" ++ + static const struct option long_options[] = { + {"help", no_argument, NULL, 'h' }, + {"debug", no_argument, NULL, 'D' }, +diff --git a/tools/testing/selftests/bpf/trace_helpers.c b/tools/testing/selftests/bpf/trace_helpers.c +index cabe2a3a3b30..cf156b353679 100644 +--- a/tools/testing/selftests/bpf/trace_helpers.c ++++ b/tools/testing/selftests/bpf/trace_helpers.c +@@ -51,6 +51,10 @@ struct ksym *ksym_search(long key) + int start = 0, end = sym_cnt; + int result; + ++ /* kallsyms not loaded. return NULL */ ++ if (sym_cnt <= 0) ++ return NULL; ++ + while (start < end) { + size_t mid = start + (end - start) / 2; + +diff --git a/tools/testing/selftests/cgroup/test_memcontrol.c b/tools/testing/selftests/cgroup/test_memcontrol.c +index 28d321ba311b..6f339882a6ca 100644 +--- a/tools/testing/selftests/cgroup/test_memcontrol.c ++++ b/tools/testing/selftests/cgroup/test_memcontrol.c +@@ -26,7 +26,7 @@ + */ + static int test_memcg_subtree_control(const char *root) + { +- char *parent, *child, *parent2, *child2; ++ char *parent, *child, *parent2 = NULL, *child2 = NULL; + int ret = KSFT_FAIL; + char buf[PAGE_SIZE]; + +@@ -34,50 +34,54 @@ static int test_memcg_subtree_control(const char *root) + parent = cg_name(root, "memcg_test_0"); + child = cg_name(root, "memcg_test_0/memcg_test_1"); + if (!parent || !child) +- goto cleanup; ++ goto cleanup_free; + + if (cg_create(parent)) +- goto cleanup; ++ goto cleanup_free; + + if (cg_write(parent, "cgroup.subtree_control", "+memory")) +- goto cleanup; ++ goto cleanup_parent; + + if (cg_create(child)) +- goto cleanup; ++ goto cleanup_parent; + + if (cg_read_strstr(child, "cgroup.controllers", "memory")) +- goto cleanup; ++ goto cleanup_child; + + /* Create two nested cgroups without enabling memory controller */ + parent2 = cg_name(root, "memcg_test_1"); + child2 = cg_name(root, "memcg_test_1/memcg_test_1"); + if (!parent2 || !child2) +- goto cleanup; ++ goto cleanup_free2; + + if (cg_create(parent2)) +- goto cleanup; ++ goto cleanup_free2; + + if (cg_create(child2)) +- goto cleanup; ++ goto cleanup_parent2; + + if (cg_read(child2, "cgroup.controllers", buf, sizeof(buf))) +- goto cleanup; ++ goto cleanup_all; + + if (!cg_read_strstr(child2, "cgroup.controllers", "memory")) +- goto cleanup; ++ goto cleanup_all; + + ret = KSFT_PASS; + +-cleanup: +- cg_destroy(child); +- cg_destroy(parent); +- free(parent); +- free(child); +- ++cleanup_all: + cg_destroy(child2); ++cleanup_parent2: + cg_destroy(parent2); ++cleanup_free2: + free(parent2); + free(child2); ++cleanup_child: ++ cg_destroy(child); ++cleanup_parent: ++ cg_destroy(parent); ++cleanup_free: ++ free(parent); ++ free(child); + + return ret; + } |