diff options
author | Alice Ferrazzi <alicef@gentoo.org> | 2017-11-30 12:08:35 +0000 |
---|---|---|
committer | Alice Ferrazzi <alicef@gentoo.org> | 2017-11-30 12:08:35 +0000 |
commit | 333a8fe029b7693b974251030f8b07f2a07a8776 (patch) | |
tree | ad556a5805718939421b060c840e97f5af813d3f | |
parent | remove upstream patch (diff) | |
download | linux-patches-333a8fe0.tar.gz linux-patches-333a8fe0.tar.bz2 linux-patches-333a8fe0.zip |
linux kernel 4.14.34.14-4
-rw-r--r-- | 0000_README | 4 | ||||
-rw-r--r-- | 1002_linux-4.14.3.patch | 8034 |
2 files changed, 8038 insertions, 0 deletions
diff --git a/0000_README b/0000_README index 1324e53f..9aaf65aa 100644 --- a/0000_README +++ b/0000_README @@ -51,6 +51,10 @@ Patch: 1001_linux-4.14.2.patch From: http://www.kernel.org Desc: Linux 4.14.2 +Patch: 1002_linux-4.14.3.patch +From: http://www.kernel.org +Desc: Linux 4.14.3 + 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/1002_linux-4.14.3.patch b/1002_linux-4.14.3.patch new file mode 100644 index 00000000..269ad50d --- /dev/null +++ b/1002_linux-4.14.3.patch @@ -0,0 +1,8034 @@ +diff --git a/Makefile b/Makefile +index 75d89dc2b94a..ede4de0d8634 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 4 + PATCHLEVEL = 14 +-SUBLEVEL = 2 ++SUBLEVEL = 3 + EXTRAVERSION = + NAME = Petit Gorille + +diff --git a/arch/arm/mm/dump.c b/arch/arm/mm/dump.c +index 35ff45470dbf..fc3b44028cfb 100644 +--- a/arch/arm/mm/dump.c ++++ b/arch/arm/mm/dump.c +@@ -129,8 +129,8 @@ static const struct prot_bits section_bits[] = { + .val = PMD_SECT_USER, + .set = "USR", + }, { +- .mask = L_PMD_SECT_RDONLY, +- .val = L_PMD_SECT_RDONLY, ++ .mask = L_PMD_SECT_RDONLY | PMD_SECT_AP2, ++ .val = L_PMD_SECT_RDONLY | PMD_SECT_AP2, + .set = "ro", + .clear = "RW", + #elif __LINUX_ARM_ARCH__ >= 6 +diff --git a/arch/arm/mm/init.c b/arch/arm/mm/init.c +index ad80548325fe..0f6d1537f330 100644 +--- a/arch/arm/mm/init.c ++++ b/arch/arm/mm/init.c +@@ -639,8 +639,8 @@ static struct section_perm ro_perms[] = { + .start = (unsigned long)_stext, + .end = (unsigned long)__init_begin, + #ifdef CONFIG_ARM_LPAE +- .mask = ~L_PMD_SECT_RDONLY, +- .prot = L_PMD_SECT_RDONLY, ++ .mask = ~(L_PMD_SECT_RDONLY | PMD_SECT_AP2), ++ .prot = L_PMD_SECT_RDONLY | PMD_SECT_AP2, + #else + .mask = ~(PMD_SECT_APX | PMD_SECT_AP_WRITE), + .prot = PMD_SECT_APX | PMD_SECT_AP_WRITE, +diff --git a/arch/arm64/boot/dts/amlogic/meson-gxl.dtsi b/arch/arm64/boot/dts/amlogic/meson-gxl.dtsi +index d8dd3298b15c..fb8d76a17bc5 100644 +--- a/arch/arm64/boot/dts/amlogic/meson-gxl.dtsi ++++ b/arch/arm64/boot/dts/amlogic/meson-gxl.dtsi +@@ -49,6 +49,14 @@ + + / { + compatible = "amlogic,meson-gxl"; ++ ++ reserved-memory { ++ /* Alternate 3 MiB reserved for ARM Trusted Firmware (BL31) */ ++ secmon_reserved_alt: secmon@05000000 { ++ reg = <0x0 0x05000000 0x0 0x300000>; ++ no-map; ++ }; ++ }; + }; + + ðmac { +diff --git a/arch/arm64/include/asm/pgtable.h b/arch/arm64/include/asm/pgtable.h +index b46e54c2399b..c9530b5b5ca8 100644 +--- a/arch/arm64/include/asm/pgtable.h ++++ b/arch/arm64/include/asm/pgtable.h +@@ -98,6 +98,8 @@ extern unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)]; + ((pte_val(pte) & (PTE_VALID | PTE_USER | PTE_UXN)) == (PTE_VALID | PTE_UXN)) + #define pte_valid_young(pte) \ + ((pte_val(pte) & (PTE_VALID | PTE_AF)) == (PTE_VALID | PTE_AF)) ++#define pte_valid_user(pte) \ ++ ((pte_val(pte) & (PTE_VALID | PTE_USER)) == (PTE_VALID | PTE_USER)) + + /* + * Could the pte be present in the TLB? We must check mm_tlb_flush_pending +@@ -107,6 +109,18 @@ extern unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)]; + #define pte_accessible(mm, pte) \ + (mm_tlb_flush_pending(mm) ? pte_present(pte) : pte_valid_young(pte)) + ++/* ++ * p??_access_permitted() is true for valid user mappings (subject to the ++ * write permission check) other than user execute-only which do not have the ++ * PTE_USER bit set. PROT_NONE mappings do not have the PTE_VALID bit set. ++ */ ++#define pte_access_permitted(pte, write) \ ++ (pte_valid_user(pte) && (!(write) || pte_write(pte))) ++#define pmd_access_permitted(pmd, write) \ ++ (pte_access_permitted(pmd_pte(pmd), (write))) ++#define pud_access_permitted(pud, write) \ ++ (pte_access_permitted(pud_pte(pud), (write))) ++ + static inline pte_t clear_pte_bit(pte_t pte, pgprot_t prot) + { + pte_val(pte) &= ~pgprot_val(prot); +diff --git a/arch/mips/Kconfig b/arch/mips/Kconfig +index 5d3284d20678..c3d798b44030 100644 +--- a/arch/mips/Kconfig ++++ b/arch/mips/Kconfig +@@ -65,7 +65,7 @@ config MIPS + select HAVE_PERF_EVENTS + select HAVE_REGS_AND_STACK_ACCESS_API + select HAVE_SYSCALL_TRACEPOINTS +- select HAVE_VIRT_CPU_ACCOUNTING_GEN ++ select HAVE_VIRT_CPU_ACCOUNTING_GEN if 64BIT || !SMP + select IRQ_FORCED_THREADING + select MODULES_USE_ELF_RELA if MODULES && 64BIT + select MODULES_USE_ELF_REL if MODULES +diff --git a/arch/mips/bcm47xx/leds.c b/arch/mips/bcm47xx/leds.c +index d4f2407a42c6..8307a8a02667 100644 +--- a/arch/mips/bcm47xx/leds.c ++++ b/arch/mips/bcm47xx/leds.c +@@ -331,7 +331,7 @@ bcm47xx_leds_linksys_wrt54g3gv2[] __initconst = { + /* Verified on: WRT54GS V1.0 */ + static const struct gpio_led + bcm47xx_leds_linksys_wrt54g_type_0101[] __initconst = { +- BCM47XX_GPIO_LED(0, "green", "wlan", 0, LEDS_GPIO_DEFSTATE_OFF), ++ BCM47XX_GPIO_LED(0, "green", "wlan", 1, LEDS_GPIO_DEFSTATE_OFF), + BCM47XX_GPIO_LED(1, "green", "power", 0, LEDS_GPIO_DEFSTATE_ON), + BCM47XX_GPIO_LED(7, "green", "dmz", 1, LEDS_GPIO_DEFSTATE_OFF), + }; +diff --git a/arch/mips/boot/dts/brcm/Makefile b/arch/mips/boot/dts/brcm/Makefile +index 9e09cc4556b3..398994312361 100644 +--- a/arch/mips/boot/dts/brcm/Makefile ++++ b/arch/mips/boot/dts/brcm/Makefile +@@ -23,7 +23,6 @@ dtb-$(CONFIG_DT_NONE) += \ + bcm63268-comtrend-vr-3032u.dtb \ + bcm93384wvg.dtb \ + bcm93384wvg_viper.dtb \ +- bcm96358nb4ser.dtb \ + bcm96368mvwg.dtb \ + bcm9ejtagprb.dtb \ + bcm97125cbmb.dtb \ +diff --git a/arch/mips/include/asm/asmmacro.h b/arch/mips/include/asm/asmmacro.h +index 83054f79f72a..feb069cbf44e 100644 +--- a/arch/mips/include/asm/asmmacro.h ++++ b/arch/mips/include/asm/asmmacro.h +@@ -19,6 +19,9 @@ + #include <asm/asmmacro-64.h> + #endif + ++/* preprocessor replaces the fp in ".set fp=64" with $30 otherwise */ ++#undef fp ++ + /* + * Helper macros for generating raw instruction encodings. + */ +@@ -105,6 +108,7 @@ + .macro fpu_save_16odd thread + .set push + .set mips64r2 ++ .set fp=64 + SET_HARDFLOAT + sdc1 $f1, THREAD_FPR1(\thread) + sdc1 $f3, THREAD_FPR3(\thread) +@@ -126,8 +130,8 @@ + .endm + + .macro fpu_save_double thread status tmp +-#if defined(CONFIG_64BIT) || defined(CONFIG_CPU_MIPS32_R2) || \ +- defined(CONFIG_CPU_MIPS32_R6) ++#if defined(CONFIG_64BIT) || defined(CONFIG_CPU_MIPSR2) || \ ++ defined(CONFIG_CPU_MIPSR6) + sll \tmp, \status, 5 + bgez \tmp, 10f + fpu_save_16odd \thread +@@ -163,6 +167,7 @@ + .macro fpu_restore_16odd thread + .set push + .set mips64r2 ++ .set fp=64 + SET_HARDFLOAT + ldc1 $f1, THREAD_FPR1(\thread) + ldc1 $f3, THREAD_FPR3(\thread) +@@ -184,8 +189,8 @@ + .endm + + .macro fpu_restore_double thread status tmp +-#if defined(CONFIG_64BIT) || defined(CONFIG_CPU_MIPS32_R2) || \ +- defined(CONFIG_CPU_MIPS32_R6) ++#if defined(CONFIG_64BIT) || defined(CONFIG_CPU_MIPSR2) || \ ++ defined(CONFIG_CPU_MIPSR6) + sll \tmp, \status, 5 + bgez \tmp, 10f # 16 register mode? + +@@ -234,9 +239,6 @@ + .endm + + #ifdef TOOLCHAIN_SUPPORTS_MSA +-/* preprocessor replaces the fp in ".set fp=64" with $30 otherwise */ +-#undef fp +- + .macro _cfcmsa rd, cs + .set push + .set mips32r2 +diff --git a/arch/mips/include/asm/cmpxchg.h b/arch/mips/include/asm/cmpxchg.h +index 7e25c5cc353a..89e9fb7976fe 100644 +--- a/arch/mips/include/asm/cmpxchg.h ++++ b/arch/mips/include/asm/cmpxchg.h +@@ -204,8 +204,10 @@ static inline unsigned long __cmpxchg(volatile void *ptr, unsigned long old, + #else + #include <asm-generic/cmpxchg-local.h> + #define cmpxchg64_local(ptr, o, n) __cmpxchg64_local_generic((ptr), (o), (n)) ++#ifndef CONFIG_SMP + #define cmpxchg64(ptr, o, n) cmpxchg64_local((ptr), (o), (n)) + #endif ++#endif + + #undef __scbeqz + +diff --git a/arch/mips/kernel/ptrace.c b/arch/mips/kernel/ptrace.c +index 1395654cfc8d..5a09c2901a76 100644 +--- a/arch/mips/kernel/ptrace.c ++++ b/arch/mips/kernel/ptrace.c +@@ -618,6 +618,19 @@ static const struct user_regset_view user_mips64_view = { + .n = ARRAY_SIZE(mips64_regsets), + }; + ++#ifdef CONFIG_MIPS32_N32 ++ ++static const struct user_regset_view user_mipsn32_view = { ++ .name = "mipsn32", ++ .e_flags = EF_MIPS_ABI2, ++ .e_machine = ELF_ARCH, ++ .ei_osabi = ELF_OSABI, ++ .regsets = mips64_regsets, ++ .n = ARRAY_SIZE(mips64_regsets), ++}; ++ ++#endif /* CONFIG_MIPS32_N32 */ ++ + #endif /* CONFIG_64BIT */ + + const struct user_regset_view *task_user_regset_view(struct task_struct *task) +@@ -628,6 +641,10 @@ const struct user_regset_view *task_user_regset_view(struct task_struct *task) + #ifdef CONFIG_MIPS32_O32 + if (test_tsk_thread_flag(task, TIF_32BIT_REGS)) + return &user_mips_view; ++#endif ++#ifdef CONFIG_MIPS32_N32 ++ if (test_tsk_thread_flag(task, TIF_32BIT_ADDR)) ++ return &user_mipsn32_view; + #endif + return &user_mips64_view; + #endif +diff --git a/arch/mips/kernel/r4k_fpu.S b/arch/mips/kernel/r4k_fpu.S +index 0a83b1708b3c..8e3a6020c613 100644 +--- a/arch/mips/kernel/r4k_fpu.S ++++ b/arch/mips/kernel/r4k_fpu.S +@@ -40,8 +40,8 @@ + */ + LEAF(_save_fp) + EXPORT_SYMBOL(_save_fp) +-#if defined(CONFIG_64BIT) || defined(CONFIG_CPU_MIPS32_R2) || \ +- defined(CONFIG_CPU_MIPS32_R6) ++#if defined(CONFIG_64BIT) || defined(CONFIG_CPU_MIPSR2) || \ ++ defined(CONFIG_CPU_MIPSR6) + mfc0 t0, CP0_STATUS + #endif + fpu_save_double a0 t0 t1 # clobbers t1 +@@ -52,8 +52,8 @@ EXPORT_SYMBOL(_save_fp) + * Restore a thread's fp context. + */ + LEAF(_restore_fp) +-#if defined(CONFIG_64BIT) || defined(CONFIG_CPU_MIPS32_R2) || \ +- defined(CONFIG_CPU_MIPS32_R6) ++#if defined(CONFIG_64BIT) || defined(CONFIG_CPU_MIPSR2) || \ ++ defined(CONFIG_CPU_MIPSR6) + mfc0 t0, CP0_STATUS + #endif + fpu_restore_double a0 t0 t1 # clobbers t1 +@@ -246,11 +246,11 @@ LEAF(_save_fp_context) + cfc1 t1, fcr31 + .set pop + +-#if defined(CONFIG_64BIT) || defined(CONFIG_CPU_MIPS32_R2) || \ +- defined(CONFIG_CPU_MIPS32_R6) ++#if defined(CONFIG_64BIT) || defined(CONFIG_CPU_MIPSR2) || \ ++ defined(CONFIG_CPU_MIPSR6) + .set push + SET_HARDFLOAT +-#ifdef CONFIG_CPU_MIPS32_R2 ++#ifdef CONFIG_CPU_MIPSR2 + .set mips32r2 + .set fp=64 + mfc0 t0, CP0_STATUS +@@ -314,11 +314,11 @@ LEAF(_save_fp_context) + LEAF(_restore_fp_context) + EX lw t1, 0(a1) + +-#if defined(CONFIG_64BIT) || defined(CONFIG_CPU_MIPS32_R2) || \ +- defined(CONFIG_CPU_MIPS32_R6) ++#if defined(CONFIG_64BIT) || defined(CONFIG_CPU_MIPSR2) || \ ++ defined(CONFIG_CPU_MIPSR6) + .set push + SET_HARDFLOAT +-#ifdef CONFIG_CPU_MIPS32_R2 ++#ifdef CONFIG_CPU_MIPSR2 + .set mips32r2 + .set fp=64 + mfc0 t0, CP0_STATUS +diff --git a/arch/mips/math-emu/cp1emu.c b/arch/mips/math-emu/cp1emu.c +index 16d9ef5a78c5..6f57212f5659 100644 +--- a/arch/mips/math-emu/cp1emu.c ++++ b/arch/mips/math-emu/cp1emu.c +@@ -1795,7 +1795,7 @@ static int fpu_emu(struct pt_regs *xcp, struct mips_fpu_struct *ctx, + SPFROMREG(fs, MIPSInst_FS(ir)); + SPFROMREG(fd, MIPSInst_FD(ir)); + rv.s = ieee754sp_maddf(fd, fs, ft); +- break; ++ goto copcsr; + } + + case fmsubf_op: { +@@ -1809,7 +1809,7 @@ static int fpu_emu(struct pt_regs *xcp, struct mips_fpu_struct *ctx, + SPFROMREG(fs, MIPSInst_FS(ir)); + SPFROMREG(fd, MIPSInst_FD(ir)); + rv.s = ieee754sp_msubf(fd, fs, ft); +- break; ++ goto copcsr; + } + + case frint_op: { +@@ -1834,7 +1834,7 @@ static int fpu_emu(struct pt_regs *xcp, struct mips_fpu_struct *ctx, + SPFROMREG(fs, MIPSInst_FS(ir)); + rv.w = ieee754sp_2008class(fs); + rfmt = w_fmt; +- break; ++ goto copcsr; + } + + case fmin_op: { +@@ -1847,7 +1847,7 @@ static int fpu_emu(struct pt_regs *xcp, struct mips_fpu_struct *ctx, + SPFROMREG(ft, MIPSInst_FT(ir)); + SPFROMREG(fs, MIPSInst_FS(ir)); + rv.s = ieee754sp_fmin(fs, ft); +- break; ++ goto copcsr; + } + + case fmina_op: { +@@ -1860,7 +1860,7 @@ static int fpu_emu(struct pt_regs *xcp, struct mips_fpu_struct *ctx, + SPFROMREG(ft, MIPSInst_FT(ir)); + SPFROMREG(fs, MIPSInst_FS(ir)); + rv.s = ieee754sp_fmina(fs, ft); +- break; ++ goto copcsr; + } + + case fmax_op: { +@@ -1873,7 +1873,7 @@ static int fpu_emu(struct pt_regs *xcp, struct mips_fpu_struct *ctx, + SPFROMREG(ft, MIPSInst_FT(ir)); + SPFROMREG(fs, MIPSInst_FS(ir)); + rv.s = ieee754sp_fmax(fs, ft); +- break; ++ goto copcsr; + } + + case fmaxa_op: { +@@ -1886,7 +1886,7 @@ static int fpu_emu(struct pt_regs *xcp, struct mips_fpu_struct *ctx, + SPFROMREG(ft, MIPSInst_FT(ir)); + SPFROMREG(fs, MIPSInst_FS(ir)); + rv.s = ieee754sp_fmaxa(fs, ft); +- break; ++ goto copcsr; + } + + case fabs_op: +@@ -2165,7 +2165,7 @@ static int fpu_emu(struct pt_regs *xcp, struct mips_fpu_struct *ctx, + DPFROMREG(fs, MIPSInst_FS(ir)); + DPFROMREG(fd, MIPSInst_FD(ir)); + rv.d = ieee754dp_maddf(fd, fs, ft); +- break; ++ goto copcsr; + } + + case fmsubf_op: { +@@ -2179,7 +2179,7 @@ static int fpu_emu(struct pt_regs *xcp, struct mips_fpu_struct *ctx, + DPFROMREG(fs, MIPSInst_FS(ir)); + DPFROMREG(fd, MIPSInst_FD(ir)); + rv.d = ieee754dp_msubf(fd, fs, ft); +- break; ++ goto copcsr; + } + + case frint_op: { +@@ -2204,7 +2204,7 @@ static int fpu_emu(struct pt_regs *xcp, struct mips_fpu_struct *ctx, + DPFROMREG(fs, MIPSInst_FS(ir)); + rv.l = ieee754dp_2008class(fs); + rfmt = l_fmt; +- break; ++ goto copcsr; + } + + case fmin_op: { +@@ -2217,7 +2217,7 @@ static int fpu_emu(struct pt_regs *xcp, struct mips_fpu_struct *ctx, + DPFROMREG(ft, MIPSInst_FT(ir)); + DPFROMREG(fs, MIPSInst_FS(ir)); + rv.d = ieee754dp_fmin(fs, ft); +- break; ++ goto copcsr; + } + + case fmina_op: { +@@ -2230,7 +2230,7 @@ static int fpu_emu(struct pt_regs *xcp, struct mips_fpu_struct *ctx, + DPFROMREG(ft, MIPSInst_FT(ir)); + DPFROMREG(fs, MIPSInst_FS(ir)); + rv.d = ieee754dp_fmina(fs, ft); +- break; ++ goto copcsr; + } + + case fmax_op: { +@@ -2243,7 +2243,7 @@ static int fpu_emu(struct pt_regs *xcp, struct mips_fpu_struct *ctx, + DPFROMREG(ft, MIPSInst_FT(ir)); + DPFROMREG(fs, MIPSInst_FS(ir)); + rv.d = ieee754dp_fmax(fs, ft); +- break; ++ goto copcsr; + } + + case fmaxa_op: { +@@ -2256,7 +2256,7 @@ static int fpu_emu(struct pt_regs *xcp, struct mips_fpu_struct *ctx, + DPFROMREG(ft, MIPSInst_FT(ir)); + DPFROMREG(fs, MIPSInst_FS(ir)); + rv.d = ieee754dp_fmaxa(fs, ft); +- break; ++ goto copcsr; + } + + case fabs_op: +diff --git a/arch/mips/pci/pci-mt7620.c b/arch/mips/pci/pci-mt7620.c +index 90fba9bf98da..27ac00c36bc0 100644 +--- a/arch/mips/pci/pci-mt7620.c ++++ b/arch/mips/pci/pci-mt7620.c +@@ -121,7 +121,7 @@ static int wait_pciephy_busy(void) + else + break; + if (retry++ > WAITRETRY_MAX) { +- printk(KERN_WARN "PCIE-PHY retry failed.\n"); ++ pr_warn("PCIE-PHY retry failed.\n"); + return -1; + } + } +diff --git a/arch/mips/ralink/mt7620.c b/arch/mips/ralink/mt7620.c +index 9be8b08ae46b..41b71c4352c2 100644 +--- a/arch/mips/ralink/mt7620.c ++++ b/arch/mips/ralink/mt7620.c +@@ -145,8 +145,8 @@ static struct rt2880_pmx_func i2c_grp_mt7628[] = { + FUNC("i2c", 0, 4, 2), + }; + +-static struct rt2880_pmx_func refclk_grp_mt7628[] = { FUNC("reclk", 0, 36, 1) }; +-static struct rt2880_pmx_func perst_grp_mt7628[] = { FUNC("perst", 0, 37, 1) }; ++static struct rt2880_pmx_func refclk_grp_mt7628[] = { FUNC("refclk", 0, 37, 1) }; ++static struct rt2880_pmx_func perst_grp_mt7628[] = { FUNC("perst", 0, 36, 1) }; + static struct rt2880_pmx_func wdt_grp_mt7628[] = { FUNC("wdt", 0, 38, 1) }; + static struct rt2880_pmx_func spi_grp_mt7628[] = { FUNC("spi", 0, 7, 4) }; + +diff --git a/arch/parisc/kernel/syscall.S b/arch/parisc/kernel/syscall.S +index 41e60a9c7db2..e775f80ae28c 100644 +--- a/arch/parisc/kernel/syscall.S ++++ b/arch/parisc/kernel/syscall.S +@@ -690,15 +690,15 @@ cas_action: + /* ELF32 Process entry path */ + lws_compare_and_swap_2: + #ifdef CONFIG_64BIT +- /* Clip the input registers */ ++ /* Clip the input registers. We don't need to clip %r23 as we ++ only use it for word operations */ + depdi 0, 31, 32, %r26 + depdi 0, 31, 32, %r25 + depdi 0, 31, 32, %r24 +- depdi 0, 31, 32, %r23 + #endif + + /* Check the validity of the size pointer */ +- subi,>>= 4, %r23, %r0 ++ subi,>>= 3, %r23, %r0 + b,n lws_exit_nosys + + /* Jump to the functions which will load the old and new values into +diff --git a/arch/powerpc/kernel/exceptions-64s.S b/arch/powerpc/kernel/exceptions-64s.S +index 1c80bd292e48..06598142d755 100644 +--- a/arch/powerpc/kernel/exceptions-64s.S ++++ b/arch/powerpc/kernel/exceptions-64s.S +@@ -542,7 +542,7 @@ EXC_COMMON_BEGIN(instruction_access_common) + RECONCILE_IRQ_STATE(r10, r11) + ld r12,_MSR(r1) + ld r3,_NIP(r1) +- andis. r4,r12,DSISR_BAD_FAULT_64S@h ++ andis. r4,r12,DSISR_SRR1_MATCH_64S@h + li r5,0x400 + std r3,_DAR(r1) + std r4,_DSISR(r1) +diff --git a/arch/powerpc/kernel/signal.c b/arch/powerpc/kernel/signal.c +index e9436c5e1e09..3d7539b90010 100644 +--- a/arch/powerpc/kernel/signal.c ++++ b/arch/powerpc/kernel/signal.c +@@ -103,7 +103,7 @@ static void check_syscall_restart(struct pt_regs *regs, struct k_sigaction *ka, + static void do_signal(struct task_struct *tsk) + { + sigset_t *oldset = sigmask_to_save(); +- struct ksignal ksig; ++ struct ksignal ksig = { .sig = 0 }; + int ret; + int is32 = is_32bit_task(); + +diff --git a/arch/powerpc/kvm/book3s_hv_builtin.c b/arch/powerpc/kvm/book3s_hv_builtin.c +index 90644db9d38e..8e0cf8f186df 100644 +--- a/arch/powerpc/kvm/book3s_hv_builtin.c ++++ b/arch/powerpc/kvm/book3s_hv_builtin.c +@@ -529,6 +529,8 @@ static inline bool is_rm(void) + + unsigned long kvmppc_rm_h_xirr(struct kvm_vcpu *vcpu) + { ++ if (!kvmppc_xics_enabled(vcpu)) ++ return H_TOO_HARD; + if (xive_enabled()) { + if (is_rm()) + return xive_rm_h_xirr(vcpu); +@@ -541,6 +543,8 @@ unsigned long kvmppc_rm_h_xirr(struct kvm_vcpu *vcpu) + + unsigned long kvmppc_rm_h_xirr_x(struct kvm_vcpu *vcpu) + { ++ if (!kvmppc_xics_enabled(vcpu)) ++ return H_TOO_HARD; + vcpu->arch.gpr[5] = get_tb(); + if (xive_enabled()) { + if (is_rm()) +@@ -554,6 +558,8 @@ unsigned long kvmppc_rm_h_xirr_x(struct kvm_vcpu *vcpu) + + unsigned long kvmppc_rm_h_ipoll(struct kvm_vcpu *vcpu, unsigned long server) + { ++ if (!kvmppc_xics_enabled(vcpu)) ++ return H_TOO_HARD; + if (xive_enabled()) { + if (is_rm()) + return xive_rm_h_ipoll(vcpu, server); +@@ -567,6 +573,8 @@ unsigned long kvmppc_rm_h_ipoll(struct kvm_vcpu *vcpu, unsigned long server) + int kvmppc_rm_h_ipi(struct kvm_vcpu *vcpu, unsigned long server, + unsigned long mfrr) + { ++ if (!kvmppc_xics_enabled(vcpu)) ++ return H_TOO_HARD; + if (xive_enabled()) { + if (is_rm()) + return xive_rm_h_ipi(vcpu, server, mfrr); +@@ -579,6 +587,8 @@ int kvmppc_rm_h_ipi(struct kvm_vcpu *vcpu, unsigned long server, + + int kvmppc_rm_h_cppr(struct kvm_vcpu *vcpu, unsigned long cppr) + { ++ if (!kvmppc_xics_enabled(vcpu)) ++ return H_TOO_HARD; + if (xive_enabled()) { + if (is_rm()) + return xive_rm_h_cppr(vcpu, cppr); +@@ -591,6 +601,8 @@ int kvmppc_rm_h_cppr(struct kvm_vcpu *vcpu, unsigned long cppr) + + int kvmppc_rm_h_eoi(struct kvm_vcpu *vcpu, unsigned long xirr) + { ++ if (!kvmppc_xics_enabled(vcpu)) ++ return H_TOO_HARD; + if (xive_enabled()) { + if (is_rm()) + return xive_rm_h_eoi(vcpu, xirr); +diff --git a/arch/powerpc/lib/code-patching.c b/arch/powerpc/lib/code-patching.c +index c9de03e0c1f1..d469224c4ada 100644 +--- a/arch/powerpc/lib/code-patching.c ++++ b/arch/powerpc/lib/code-patching.c +@@ -21,6 +21,7 @@ + #include <asm/tlbflush.h> + #include <asm/page.h> + #include <asm/code-patching.h> ++#include <asm/setup.h> + + static int __patch_instruction(unsigned int *addr, unsigned int instr) + { +@@ -146,11 +147,8 @@ int patch_instruction(unsigned int *addr, unsigned int instr) + * During early early boot patch_instruction is called + * when text_poke_area is not ready, but we still need + * to allow patching. We just do the plain old patching +- * We use slab_is_available and per cpu read * via this_cpu_read +- * of text_poke_area. Per-CPU areas might not be up early +- * this can create problems with just using this_cpu_read() + */ +- if (!slab_is_available() || !this_cpu_read(text_poke_area)) ++ if (!this_cpu_read(*PTRRELOC(&text_poke_area))) + return __patch_instruction(addr, instr); + + local_irq_save(flags); +diff --git a/arch/powerpc/mm/hugetlbpage-radix.c b/arch/powerpc/mm/hugetlbpage-radix.c +index 558e9d3891bf..bd022d16745c 100644 +--- a/arch/powerpc/mm/hugetlbpage-radix.c ++++ b/arch/powerpc/mm/hugetlbpage-radix.c +@@ -49,17 +49,28 @@ radix__hugetlb_get_unmapped_area(struct file *file, unsigned long addr, + struct mm_struct *mm = current->mm; + struct vm_area_struct *vma; + struct hstate *h = hstate_file(file); ++ int fixed = (flags & MAP_FIXED); ++ unsigned long high_limit; + struct vm_unmapped_area_info info; + +- if (unlikely(addr > mm->context.addr_limit && addr < TASK_SIZE)) +- mm->context.addr_limit = TASK_SIZE; ++ high_limit = DEFAULT_MAP_WINDOW; ++ if (addr >= high_limit || (fixed && (addr + len > high_limit))) ++ high_limit = TASK_SIZE; + + if (len & ~huge_page_mask(h)) + return -EINVAL; +- if (len > mm->task_size) ++ if (len > high_limit) + return -ENOMEM; ++ if (fixed) { ++ if (addr > high_limit - len) ++ return -ENOMEM; ++ } + +- if (flags & MAP_FIXED) { ++ if (unlikely(addr > mm->context.addr_limit && ++ mm->context.addr_limit != TASK_SIZE)) ++ mm->context.addr_limit = TASK_SIZE; ++ ++ if (fixed) { + if (prepare_hugepage_range(file, addr, len)) + return -EINVAL; + return addr; +@@ -68,7 +79,7 @@ radix__hugetlb_get_unmapped_area(struct file *file, unsigned long addr, + if (addr) { + addr = ALIGN(addr, huge_page_size(h)); + vma = find_vma(mm, addr); +- if (mm->task_size - len >= addr && ++ if (high_limit - len >= addr && + (!vma || addr + len <= vm_start_gap(vma))) + return addr; + } +@@ -79,12 +90,9 @@ radix__hugetlb_get_unmapped_area(struct file *file, unsigned long addr, + info.flags = VM_UNMAPPED_AREA_TOPDOWN; + info.length = len; + info.low_limit = PAGE_SIZE; +- info.high_limit = current->mm->mmap_base; ++ info.high_limit = mm->mmap_base + (high_limit - DEFAULT_MAP_WINDOW); + info.align_mask = PAGE_MASK & ~huge_page_mask(h); + info.align_offset = 0; + +- if (addr > DEFAULT_MAP_WINDOW) +- info.high_limit += mm->context.addr_limit - DEFAULT_MAP_WINDOW; +- + return vm_unmapped_area(&info); + } +diff --git a/arch/powerpc/mm/mmap.c b/arch/powerpc/mm/mmap.c +index 5d78b193fec4..6d476a7b5611 100644 +--- a/arch/powerpc/mm/mmap.c ++++ b/arch/powerpc/mm/mmap.c +@@ -106,22 +106,32 @@ radix__arch_get_unmapped_area(struct file *filp, unsigned long addr, + { + struct mm_struct *mm = current->mm; + struct vm_area_struct *vma; ++ int fixed = (flags & MAP_FIXED); ++ unsigned long high_limit; + struct vm_unmapped_area_info info; + ++ high_limit = DEFAULT_MAP_WINDOW; ++ if (addr >= high_limit || (fixed && (addr + len > high_limit))) ++ high_limit = TASK_SIZE; ++ ++ if (len > high_limit) ++ return -ENOMEM; ++ if (fixed) { ++ if (addr > high_limit - len) ++ return -ENOMEM; ++ } ++ + if (unlikely(addr > mm->context.addr_limit && + mm->context.addr_limit != TASK_SIZE)) + mm->context.addr_limit = TASK_SIZE; + +- if (len > mm->task_size - mmap_min_addr) +- return -ENOMEM; +- +- if (flags & MAP_FIXED) ++ if (fixed) + return addr; + + if (addr) { + addr = PAGE_ALIGN(addr); + vma = find_vma(mm, addr); +- if (mm->task_size - len >= addr && addr >= mmap_min_addr && ++ if (high_limit - len >= addr && addr >= mmap_min_addr && + (!vma || addr + len <= vm_start_gap(vma))) + return addr; + } +@@ -129,13 +139,9 @@ radix__arch_get_unmapped_area(struct file *filp, unsigned long addr, + info.flags = 0; + info.length = len; + info.low_limit = mm->mmap_base; ++ info.high_limit = high_limit; + info.align_mask = 0; + +- if (unlikely(addr > DEFAULT_MAP_WINDOW)) +- info.high_limit = mm->context.addr_limit; +- else +- info.high_limit = DEFAULT_MAP_WINDOW; +- + return vm_unmapped_area(&info); + } + +@@ -149,37 +155,42 @@ radix__arch_get_unmapped_area_topdown(struct file *filp, + struct vm_area_struct *vma; + struct mm_struct *mm = current->mm; + unsigned long addr = addr0; ++ int fixed = (flags & MAP_FIXED); ++ unsigned long high_limit; + struct vm_unmapped_area_info info; + ++ high_limit = DEFAULT_MAP_WINDOW; ++ if (addr >= high_limit || (fixed && (addr + len > high_limit))) ++ high_limit = TASK_SIZE; ++ ++ if (len > high_limit) ++ return -ENOMEM; ++ if (fixed) { ++ if (addr > high_limit - len) ++ return -ENOMEM; ++ } ++ + if (unlikely(addr > mm->context.addr_limit && + mm->context.addr_limit != TASK_SIZE)) + mm->context.addr_limit = TASK_SIZE; + +- /* requested length too big for entire address space */ +- if (len > mm->task_size - mmap_min_addr) +- return -ENOMEM; +- +- if (flags & MAP_FIXED) ++ if (fixed) + return addr; + +- /* requesting a specific address */ + if (addr) { + addr = PAGE_ALIGN(addr); + vma = find_vma(mm, addr); +- if (mm->task_size - len >= addr && addr >= mmap_min_addr && +- (!vma || addr + len <= vm_start_gap(vma))) ++ if (high_limit - len >= addr && addr >= mmap_min_addr && ++ (!vma || addr + len <= vm_start_gap(vma))) + return addr; + } + + info.flags = VM_UNMAPPED_AREA_TOPDOWN; + info.length = len; + info.low_limit = max(PAGE_SIZE, mmap_min_addr); +- info.high_limit = mm->mmap_base; ++ info.high_limit = mm->mmap_base + (high_limit - DEFAULT_MAP_WINDOW); + info.align_mask = 0; + +- if (addr > DEFAULT_MAP_WINDOW) +- info.high_limit += mm->context.addr_limit - DEFAULT_MAP_WINDOW; +- + addr = vm_unmapped_area(&info); + if (!(addr & ~PAGE_MASK)) + return addr; +diff --git a/arch/powerpc/mm/mmu_context_book3s64.c b/arch/powerpc/mm/mmu_context_book3s64.c +index 05e15386d4cb..b94fb62e60fd 100644 +--- a/arch/powerpc/mm/mmu_context_book3s64.c ++++ b/arch/powerpc/mm/mmu_context_book3s64.c +@@ -93,11 +93,11 @@ static int hash__init_new_context(struct mm_struct *mm) + return index; + + /* +- * We do switch_slb() early in fork, even before we setup the +- * mm->context.addr_limit. Default to max task size so that we copy the +- * default values to paca which will help us to handle slb miss early. ++ * In the case of exec, use the default limit, ++ * otherwise inherit it from the mm we are duplicating. + */ +- mm->context.addr_limit = DEFAULT_MAP_WINDOW_USER64; ++ if (!mm->context.addr_limit) ++ mm->context.addr_limit = DEFAULT_MAP_WINDOW_USER64; + + /* + * The old code would re-promote on fork, we don't do that when using +diff --git a/arch/powerpc/mm/pgtable-radix.c b/arch/powerpc/mm/pgtable-radix.c +index 39c252b54d16..cfbbee941a76 100644 +--- a/arch/powerpc/mm/pgtable-radix.c ++++ b/arch/powerpc/mm/pgtable-radix.c +@@ -169,6 +169,16 @@ void radix__mark_rodata_ro(void) + { + unsigned long start, end; + ++ /* ++ * mark_rodata_ro() will mark itself as !writable at some point. ++ * Due to DD1 workaround in radix__pte_update(), we'll end up with ++ * an invalid pte and the system will crash quite severly. ++ */ ++ if (cpu_has_feature(CPU_FTR_POWER9_DD1)) { ++ pr_warn("Warning: Unable to mark rodata read only on P9 DD1\n"); ++ return; ++ } ++ + start = (unsigned long)_stext; + end = (unsigned long)__init_begin; + +diff --git a/arch/powerpc/mm/slice.c b/arch/powerpc/mm/slice.c +index 45f6740dd407..a4f93699194b 100644 +--- a/arch/powerpc/mm/slice.c ++++ b/arch/powerpc/mm/slice.c +@@ -96,7 +96,7 @@ static int slice_area_is_free(struct mm_struct *mm, unsigned long addr, + { + struct vm_area_struct *vma; + +- if ((mm->task_size - len) < addr) ++ if ((mm->context.addr_limit - len) < addr) + return 0; + vma = find_vma(mm, addr); + return (!vma || (addr + len) <= vm_start_gap(vma)); +@@ -133,7 +133,7 @@ static void slice_mask_for_free(struct mm_struct *mm, struct slice_mask *ret) + if (!slice_low_has_vma(mm, i)) + ret->low_slices |= 1u << i; + +- if (mm->task_size <= SLICE_LOW_TOP) ++ if (mm->context.addr_limit <= SLICE_LOW_TOP) + return; + + for (i = 0; i < GET_HIGH_SLICE_INDEX(mm->context.addr_limit); i++) +@@ -412,25 +412,31 @@ unsigned long slice_get_unmapped_area(unsigned long addr, unsigned long len, + struct slice_mask compat_mask; + int fixed = (flags & MAP_FIXED); + int pshift = max_t(int, mmu_psize_defs[psize].shift, PAGE_SHIFT); ++ unsigned long page_size = 1UL << pshift; + struct mm_struct *mm = current->mm; + unsigned long newaddr; + unsigned long high_limit; + +- /* +- * Check if we need to expland slice area. +- */ +- if (unlikely(addr > mm->context.addr_limit && +- mm->context.addr_limit != TASK_SIZE)) { +- mm->context.addr_limit = TASK_SIZE; ++ high_limit = DEFAULT_MAP_WINDOW; ++ if (addr >= high_limit || (fixed && (addr + len > high_limit))) ++ high_limit = TASK_SIZE; ++ ++ if (len > high_limit) ++ return -ENOMEM; ++ if (len & (page_size - 1)) ++ return -EINVAL; ++ if (fixed) { ++ if (addr & (page_size - 1)) ++ return -EINVAL; ++ if (addr > high_limit - len) ++ return -ENOMEM; ++ } ++ ++ if (high_limit > mm->context.addr_limit) { ++ mm->context.addr_limit = high_limit; + on_each_cpu(slice_flush_segments, mm, 1); + } +- /* +- * This mmap request can allocate upt to 512TB +- */ +- if (addr > DEFAULT_MAP_WINDOW) +- high_limit = mm->context.addr_limit; +- else +- high_limit = DEFAULT_MAP_WINDOW; ++ + /* + * init different masks + */ +@@ -446,27 +452,19 @@ unsigned long slice_get_unmapped_area(unsigned long addr, unsigned long len, + + /* Sanity checks */ + BUG_ON(mm->task_size == 0); ++ BUG_ON(mm->context.addr_limit == 0); + VM_BUG_ON(radix_enabled()); + + slice_dbg("slice_get_unmapped_area(mm=%p, psize=%d...\n", mm, psize); + slice_dbg(" addr=%lx, len=%lx, flags=%lx, topdown=%d\n", + addr, len, flags, topdown); + +- if (len > mm->task_size) +- return -ENOMEM; +- if (len & ((1ul << pshift) - 1)) +- return -EINVAL; +- if (fixed && (addr & ((1ul << pshift) - 1))) +- return -EINVAL; +- if (fixed && addr > (mm->task_size - len)) +- return -ENOMEM; +- + /* If hint, make sure it matches our alignment restrictions */ + if (!fixed && addr) { +- addr = _ALIGN_UP(addr, 1ul << pshift); ++ addr = _ALIGN_UP(addr, page_size); + slice_dbg(" aligned addr=%lx\n", addr); + /* Ignore hint if it's too large or overlaps a VMA */ +- if (addr > mm->task_size - len || ++ if (addr > high_limit - len || + !slice_area_is_free(mm, addr, len)) + addr = 0; + } +diff --git a/arch/powerpc/perf/imc-pmu.c b/arch/powerpc/perf/imc-pmu.c +index 36344117c680..cf64e16f92c2 100644 +--- a/arch/powerpc/perf/imc-pmu.c ++++ b/arch/powerpc/perf/imc-pmu.c +@@ -467,7 +467,7 @@ static int nest_imc_event_init(struct perf_event *event) + * Nest HW counter memory resides in a per-chip reserve-memory (HOMER). + * Get the base memory addresss for this cpu. + */ +- chip_id = topology_physical_package_id(event->cpu); ++ chip_id = cpu_to_chip_id(event->cpu); + pcni = pmu->mem_info; + do { + if (pcni->id == chip_id) { +@@ -524,19 +524,19 @@ static int nest_imc_event_init(struct perf_event *event) + */ + static int core_imc_mem_init(int cpu, int size) + { +- int phys_id, rc = 0, core_id = (cpu / threads_per_core); ++ int nid, rc = 0, core_id = (cpu / threads_per_core); + struct imc_mem_info *mem_info; + + /* + * alloc_pages_node() will allocate memory for core in the + * local node only. + */ +- phys_id = topology_physical_package_id(cpu); ++ nid = cpu_to_node(cpu); + mem_info = &core_imc_pmu->mem_info[core_id]; + mem_info->id = core_id; + + /* We need only vbase for core counters */ +- mem_info->vbase = page_address(alloc_pages_node(phys_id, ++ mem_info->vbase = page_address(alloc_pages_node(nid, + GFP_KERNEL | __GFP_ZERO | __GFP_THISNODE | + __GFP_NOWARN, get_order(size))); + if (!mem_info->vbase) +@@ -797,14 +797,14 @@ static int core_imc_event_init(struct perf_event *event) + static int thread_imc_mem_alloc(int cpu_id, int size) + { + u64 ldbar_value, *local_mem = per_cpu(thread_imc_mem, cpu_id); +- int phys_id = topology_physical_package_id(cpu_id); ++ int nid = cpu_to_node(cpu_id); + + if (!local_mem) { + /* + * This case could happen only once at start, since we dont + * free the memory in cpu offline path. + */ +- local_mem = page_address(alloc_pages_node(phys_id, ++ local_mem = page_address(alloc_pages_node(nid, + GFP_KERNEL | __GFP_ZERO | __GFP_THISNODE | + __GFP_NOWARN, get_order(size))); + if (!local_mem) +diff --git a/arch/s390/include/asm/switch_to.h b/arch/s390/include/asm/switch_to.h +index c21fe1d57c00..ec7b476c1ac5 100644 +--- a/arch/s390/include/asm/switch_to.h ++++ b/arch/s390/include/asm/switch_to.h +@@ -37,8 +37,8 @@ static inline void restore_access_regs(unsigned int *acrs) + save_ri_cb(prev->thread.ri_cb); \ + save_gs_cb(prev->thread.gs_cb); \ + } \ ++ update_cr_regs(next); \ + if (next->mm) { \ +- update_cr_regs(next); \ + set_cpu_flag(CIF_FPU); \ + restore_access_regs(&next->thread.acrs[0]); \ + restore_ri_cb(next->thread.ri_cb, prev->thread.ri_cb); \ +diff --git a/arch/s390/kernel/dis.c b/arch/s390/kernel/dis.c +index f7e82302a71e..2394557653d5 100644 +--- a/arch/s390/kernel/dis.c ++++ b/arch/s390/kernel/dis.c +@@ -1548,6 +1548,7 @@ static struct s390_insn opcode_e7[] = { + { "vfsq", 0xce, INSTR_VRR_VV000MM }, + { "vfs", 0xe2, INSTR_VRR_VVV00MM }, + { "vftci", 0x4a, INSTR_VRI_VVIMM }, ++ { "", 0, INSTR_INVALID } + }; + + static struct s390_insn opcode_eb[] = { +@@ -1953,7 +1954,7 @@ void show_code(struct pt_regs *regs) + { + char *mode = user_mode(regs) ? "User" : "Krnl"; + unsigned char code[64]; +- char buffer[64], *ptr; ++ char buffer[128], *ptr; + mm_segment_t old_fs; + unsigned long addr; + int start, end, opsize, hops, i; +@@ -2016,7 +2017,7 @@ void show_code(struct pt_regs *regs) + start += opsize; + pr_cont("%s", buffer); + ptr = buffer; +- ptr += sprintf(ptr, "\n "); ++ ptr += sprintf(ptr, "\n\t "); + hops++; + } + pr_cont("\n"); +diff --git a/arch/s390/kernel/early.c b/arch/s390/kernel/early.c +index b945448b9eae..f7b280f0ab16 100644 +--- a/arch/s390/kernel/early.c ++++ b/arch/s390/kernel/early.c +@@ -375,8 +375,10 @@ static __init void detect_machine_facilities(void) + S390_lowcore.machine_flags |= MACHINE_FLAG_IDTE; + if (test_facility(40)) + S390_lowcore.machine_flags |= MACHINE_FLAG_LPP; +- if (test_facility(50) && test_facility(73)) ++ if (test_facility(50) && test_facility(73)) { + S390_lowcore.machine_flags |= MACHINE_FLAG_TE; ++ __ctl_set_bit(0, 55); ++ } + if (test_facility(51)) + S390_lowcore.machine_flags |= MACHINE_FLAG_TLB_LC; + if (test_facility(129)) { +diff --git a/arch/s390/kernel/guarded_storage.c b/arch/s390/kernel/guarded_storage.c +index bff39b66c9ff..9ee794e14f33 100644 +--- a/arch/s390/kernel/guarded_storage.c ++++ b/arch/s390/kernel/guarded_storage.c +@@ -14,9 +14,11 @@ + + void exit_thread_gs(void) + { ++ preempt_disable(); + kfree(current->thread.gs_cb); + kfree(current->thread.gs_bc_cb); + current->thread.gs_cb = current->thread.gs_bc_cb = NULL; ++ preempt_enable(); + } + + static int gs_enable(void) +diff --git a/arch/s390/kernel/machine_kexec.c b/arch/s390/kernel/machine_kexec.c +index b0ba2c26b45e..d6f7782e75c9 100644 +--- a/arch/s390/kernel/machine_kexec.c ++++ b/arch/s390/kernel/machine_kexec.c +@@ -269,6 +269,7 @@ static void __do_machine_kexec(void *data) + s390_reset_system(); + data_mover = (relocate_kernel_t) page_to_phys(image->control_code_page); + ++ __arch_local_irq_stnsm(0xfb); /* disable DAT - avoid no-execute */ + /* Call the moving routine */ + (*data_mover)(&image->head, image->start); + +diff --git a/arch/s390/kernel/process.c b/arch/s390/kernel/process.c +index a4a84fb08046..203b7cd7c348 100644 +--- a/arch/s390/kernel/process.c ++++ b/arch/s390/kernel/process.c +@@ -100,6 +100,7 @@ int copy_thread_tls(unsigned long clone_flags, unsigned long new_stackp, + memset(&p->thread.per_user, 0, sizeof(p->thread.per_user)); + memset(&p->thread.per_event, 0, sizeof(p->thread.per_event)); + clear_tsk_thread_flag(p, TIF_SINGLE_STEP); ++ p->thread.per_flags = 0; + /* Initialize per thread user and system timer values */ + p->thread.user_timer = 0; + p->thread.guest_timer = 0; +diff --git a/arch/s390/kernel/relocate_kernel.S b/arch/s390/kernel/relocate_kernel.S +index ca37e5d5b40c..9c2c96da23d0 100644 +--- a/arch/s390/kernel/relocate_kernel.S ++++ b/arch/s390/kernel/relocate_kernel.S +@@ -29,7 +29,6 @@ + ENTRY(relocate_kernel) + basr %r13,0 # base address + .base: +- stnsm sys_msk-.base(%r13),0xfb # disable DAT + stctg %c0,%c15,ctlregs-.base(%r13) + stmg %r0,%r15,gprregs-.base(%r13) + lghi %r0,3 +@@ -103,8 +102,6 @@ ENTRY(relocate_kernel) + .align 8 + load_psw: + .long 0x00080000,0x80000000 +- sys_msk: +- .quad 0 + ctlregs: + .rept 16 + .quad 0 +diff --git a/arch/s390/kernel/runtime_instr.c b/arch/s390/kernel/runtime_instr.c +index 32aefb215e59..d85c64821a6b 100644 +--- a/arch/s390/kernel/runtime_instr.c ++++ b/arch/s390/kernel/runtime_instr.c +@@ -50,11 +50,13 @@ void exit_thread_runtime_instr(void) + { + struct task_struct *task = current; + ++ preempt_disable(); + if (!task->thread.ri_cb) + return; + disable_runtime_instr(); + kfree(task->thread.ri_cb); + task->thread.ri_cb = NULL; ++ preempt_enable(); + } + + SYSCALL_DEFINE1(s390_runtime_instr, int, command) +@@ -65,9 +67,7 @@ SYSCALL_DEFINE1(s390_runtime_instr, int, command) + return -EOPNOTSUPP; + + if (command == S390_RUNTIME_INSTR_STOP) { +- preempt_disable(); + exit_thread_runtime_instr(); +- preempt_enable(); + return 0; + } + +diff --git a/arch/x86/entry/entry_64.S b/arch/x86/entry/entry_64.S +index bcfc5668dcb2..518d9286b3d1 100644 +--- a/arch/x86/entry/entry_64.S ++++ b/arch/x86/entry/entry_64.S +@@ -51,15 +51,19 @@ ENTRY(native_usergs_sysret64) + END(native_usergs_sysret64) + #endif /* CONFIG_PARAVIRT */ + +-.macro TRACE_IRQS_IRETQ ++.macro TRACE_IRQS_FLAGS flags:req + #ifdef CONFIG_TRACE_IRQFLAGS +- bt $9, EFLAGS(%rsp) /* interrupts off? */ ++ bt $9, \flags /* interrupts off? */ + jnc 1f + TRACE_IRQS_ON + 1: + #endif + .endm + ++.macro TRACE_IRQS_IRETQ ++ TRACE_IRQS_FLAGS EFLAGS(%rsp) ++.endm ++ + /* + * When dynamic function tracer is enabled it will add a breakpoint + * to all locations that it is about to modify, sync CPUs, update +@@ -148,8 +152,6 @@ ENTRY(entry_SYSCALL_64) + movq %rsp, PER_CPU_VAR(rsp_scratch) + movq PER_CPU_VAR(cpu_current_top_of_stack), %rsp + +- TRACE_IRQS_OFF +- + /* Construct struct pt_regs on stack */ + pushq $__USER_DS /* pt_regs->ss */ + pushq PER_CPU_VAR(rsp_scratch) /* pt_regs->sp */ +@@ -170,6 +172,8 @@ GLOBAL(entry_SYSCALL_64_after_hwframe) + sub $(6*8), %rsp /* pt_regs->bp, bx, r12-15 not saved */ + UNWIND_HINT_REGS extra=0 + ++ TRACE_IRQS_OFF ++ + /* + * If we need to do entry work or if we guess we'll need to do + * exit work, go straight to the slow path. +@@ -923,11 +927,13 @@ ENTRY(native_load_gs_index) + FRAME_BEGIN + pushfq + DISABLE_INTERRUPTS(CLBR_ANY & ~CLBR_RDI) ++ TRACE_IRQS_OFF + SWAPGS + .Lgs_change: + movl %edi, %gs + 2: ALTERNATIVE "", "mfence", X86_BUG_SWAPGS_FENCE + SWAPGS ++ TRACE_IRQS_FLAGS (%rsp) + popfq + FRAME_END + ret +diff --git a/arch/x86/events/intel/core.c b/arch/x86/events/intel/core.c +index 9fb9a1f1e47b..f94855000d4e 100644 +--- a/arch/x86/events/intel/core.c ++++ b/arch/x86/events/intel/core.c +@@ -3730,6 +3730,19 @@ EVENT_ATTR_STR(cycles-t, cycles_t, "event=0x3c,in_tx=1"); + EVENT_ATTR_STR(cycles-ct, cycles_ct, "event=0x3c,in_tx=1,in_tx_cp=1"); + + static struct attribute *hsw_events_attrs[] = { ++ EVENT_PTR(mem_ld_hsw), ++ EVENT_PTR(mem_st_hsw), ++ EVENT_PTR(td_slots_issued), ++ EVENT_PTR(td_slots_retired), ++ EVENT_PTR(td_fetch_bubbles), ++ EVENT_PTR(td_total_slots), ++ EVENT_PTR(td_total_slots_scale), ++ EVENT_PTR(td_recovery_bubbles), ++ EVENT_PTR(td_recovery_bubbles_scale), ++ NULL ++}; ++ ++static struct attribute *hsw_tsx_events_attrs[] = { + EVENT_PTR(tx_start), + EVENT_PTR(tx_commit), + EVENT_PTR(tx_abort), +@@ -3742,18 +3755,16 @@ static struct attribute *hsw_events_attrs[] = { + EVENT_PTR(el_conflict), + EVENT_PTR(cycles_t), + EVENT_PTR(cycles_ct), +- EVENT_PTR(mem_ld_hsw), +- EVENT_PTR(mem_st_hsw), +- EVENT_PTR(td_slots_issued), +- EVENT_PTR(td_slots_retired), +- EVENT_PTR(td_fetch_bubbles), +- EVENT_PTR(td_total_slots), +- EVENT_PTR(td_total_slots_scale), +- EVENT_PTR(td_recovery_bubbles), +- EVENT_PTR(td_recovery_bubbles_scale), + NULL + }; + ++static __init struct attribute **get_hsw_events_attrs(void) ++{ ++ return boot_cpu_has(X86_FEATURE_RTM) ? ++ merge_attr(hsw_events_attrs, hsw_tsx_events_attrs) : ++ hsw_events_attrs; ++} ++ + static ssize_t freeze_on_smi_show(struct device *cdev, + struct device_attribute *attr, + char *buf) +@@ -4182,7 +4193,7 @@ __init int intel_pmu_init(void) + + x86_pmu.hw_config = hsw_hw_config; + x86_pmu.get_event_constraints = hsw_get_event_constraints; +- x86_pmu.cpu_events = hsw_events_attrs; ++ x86_pmu.cpu_events = get_hsw_events_attrs(); + x86_pmu.lbr_double_abort = true; + extra_attr = boot_cpu_has(X86_FEATURE_RTM) ? + hsw_format_attr : nhm_format_attr; +@@ -4221,7 +4232,7 @@ __init int intel_pmu_init(void) + + x86_pmu.hw_config = hsw_hw_config; + x86_pmu.get_event_constraints = hsw_get_event_constraints; +- x86_pmu.cpu_events = hsw_events_attrs; ++ x86_pmu.cpu_events = get_hsw_events_attrs(); + x86_pmu.limit_period = bdw_limit_period; + extra_attr = boot_cpu_has(X86_FEATURE_RTM) ? + hsw_format_attr : nhm_format_attr; +@@ -4279,7 +4290,7 @@ __init int intel_pmu_init(void) + extra_attr = boot_cpu_has(X86_FEATURE_RTM) ? + hsw_format_attr : nhm_format_attr; + extra_attr = merge_attr(extra_attr, skl_format_attr); +- x86_pmu.cpu_events = hsw_events_attrs; ++ x86_pmu.cpu_events = get_hsw_events_attrs(); + intel_pmu_pebs_data_source_skl( + boot_cpu_data.x86_model == INTEL_FAM6_SKYLAKE_X); + pr_cont("Skylake events, "); +diff --git a/arch/x86/kernel/mpparse.c b/arch/x86/kernel/mpparse.c +index 410c5dadcee3..3a4b12809ab5 100644 +--- a/arch/x86/kernel/mpparse.c ++++ b/arch/x86/kernel/mpparse.c +@@ -431,6 +431,7 @@ static inline void __init construct_default_ISA_mptable(int mpc_default_type) + } + + static unsigned long mpf_base; ++static bool mpf_found; + + static unsigned long __init get_mpc_size(unsigned long physptr) + { +@@ -504,7 +505,7 @@ void __init default_get_smp_config(unsigned int early) + if (!smp_found_config) + return; + +- if (!mpf_base) ++ if (!mpf_found) + return; + + if (acpi_lapic && early) +@@ -593,6 +594,7 @@ static int __init smp_scan_config(unsigned long base, unsigned long length) + smp_found_config = 1; + #endif + mpf_base = base; ++ mpf_found = true; + + pr_info("found SMP MP-table at [mem %#010lx-%#010lx] mapped at [%p]\n", + base, base + sizeof(*mpf) - 1, mpf); +@@ -858,7 +860,7 @@ static int __init update_mp_table(void) + if (!enable_update_mptable) + return 0; + +- if (!mpf_base) ++ if (!mpf_found) + return 0; + + mpf = early_memremap(mpf_base, sizeof(*mpf)); +diff --git a/arch/x86/kvm/svm.c b/arch/x86/kvm/svm.c +index 0e68f0b3cbf7..ca209a4a7834 100644 +--- a/arch/x86/kvm/svm.c ++++ b/arch/x86/kvm/svm.c +@@ -3657,6 +3657,13 @@ static int svm_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr) + u32 ecx = msr->index; + u64 data = msr->data; + switch (ecx) { ++ case MSR_IA32_CR_PAT: ++ if (!kvm_mtrr_valid(vcpu, MSR_IA32_CR_PAT, data)) ++ return 1; ++ vcpu->arch.pat = data; ++ svm->vmcb->save.g_pat = data; ++ mark_dirty(svm->vmcb, VMCB_NPT); ++ break; + case MSR_IA32_TSC: + kvm_write_tsc(vcpu, msr); + break; +diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c +index a6f4f095f8f4..21cad7068cbf 100644 +--- a/arch/x86/kvm/vmx.c ++++ b/arch/x86/kvm/vmx.c +@@ -202,6 +202,10 @@ struct loaded_vmcs { + bool nmi_known_unmasked; + unsigned long vmcs_host_cr3; /* May not match real cr3 */ + unsigned long vmcs_host_cr4; /* May not match real cr4 */ ++ /* Support for vnmi-less CPUs */ ++ int soft_vnmi_blocked; ++ ktime_t entry_time; ++ s64 vnmi_blocked_time; + struct list_head loaded_vmcss_on_cpu_link; + }; + +@@ -1286,6 +1290,11 @@ static inline bool cpu_has_vmx_invpcid(void) + SECONDARY_EXEC_ENABLE_INVPCID; + } + ++static inline bool cpu_has_virtual_nmis(void) ++{ ++ return vmcs_config.pin_based_exec_ctrl & PIN_BASED_VIRTUAL_NMIS; ++} ++ + static inline bool cpu_has_vmx_wbinvd_exit(void) + { + return vmcs_config.cpu_based_2nd_exec_ctrl & +@@ -1343,11 +1352,6 @@ static inline bool nested_cpu_has2(struct vmcs12 *vmcs12, u32 bit) + (vmcs12->secondary_vm_exec_control & bit); + } + +-static inline bool nested_cpu_has_virtual_nmis(struct vmcs12 *vmcs12) +-{ +- return vmcs12->pin_based_vm_exec_control & PIN_BASED_VIRTUAL_NMIS; +-} +- + static inline bool nested_cpu_has_preemption_timer(struct vmcs12 *vmcs12) + { + return vmcs12->pin_based_vm_exec_control & +@@ -3699,9 +3703,9 @@ static __init int setup_vmcs_config(struct vmcs_config *vmcs_conf) + &_vmexit_control) < 0) + return -EIO; + +- min = PIN_BASED_EXT_INTR_MASK | PIN_BASED_NMI_EXITING | +- PIN_BASED_VIRTUAL_NMIS; +- opt = PIN_BASED_POSTED_INTR | PIN_BASED_VMX_PREEMPTION_TIMER; ++ min = PIN_BASED_EXT_INTR_MASK | PIN_BASED_NMI_EXITING; ++ opt = PIN_BASED_VIRTUAL_NMIS | PIN_BASED_POSTED_INTR | ++ PIN_BASED_VMX_PREEMPTION_TIMER; + if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_PINBASED_CTLS, + &_pin_based_exec_control) < 0) + return -EIO; +@@ -5667,7 +5671,8 @@ static void enable_irq_window(struct kvm_vcpu *vcpu) + + static void enable_nmi_window(struct kvm_vcpu *vcpu) + { +- if (vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & GUEST_INTR_STATE_STI) { ++ if (!cpu_has_virtual_nmis() || ++ vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & GUEST_INTR_STATE_STI) { + enable_irq_window(vcpu); + return; + } +@@ -5707,6 +5712,19 @@ static void vmx_inject_nmi(struct kvm_vcpu *vcpu) + { + struct vcpu_vmx *vmx = to_vmx(vcpu); + ++ if (!cpu_has_virtual_nmis()) { ++ /* ++ * Tracking the NMI-blocked state in software is built upon ++ * finding the next open IRQ window. This, in turn, depends on ++ * well-behaving guests: They have to keep IRQs disabled at ++ * least as long as the NMI handler runs. Otherwise we may ++ * cause NMI nesting, maybe breaking the guest. But as this is ++ * highly unlikely, we can live with the residual risk. ++ */ ++ vmx->loaded_vmcs->soft_vnmi_blocked = 1; ++ vmx->loaded_vmcs->vnmi_blocked_time = 0; ++ } ++ + ++vcpu->stat.nmi_injections; + vmx->loaded_vmcs->nmi_known_unmasked = false; + +@@ -5725,6 +5743,8 @@ static bool vmx_get_nmi_mask(struct kvm_vcpu *vcpu) + struct vcpu_vmx *vmx = to_vmx(vcpu); + bool masked; + ++ if (!cpu_has_virtual_nmis()) ++ return vmx->loaded_vmcs->soft_vnmi_blocked; + if (vmx->loaded_vmcs->nmi_known_unmasked) + return false; + masked = vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & GUEST_INTR_STATE_NMI; +@@ -5736,13 +5756,20 @@ static void vmx_set_nmi_mask(struct kvm_vcpu *vcpu, bool masked) + { + struct vcpu_vmx *vmx = to_vmx(vcpu); + +- vmx->loaded_vmcs->nmi_known_unmasked = !masked; +- if (masked) +- vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO, +- GUEST_INTR_STATE_NMI); +- else +- vmcs_clear_bits(GUEST_INTERRUPTIBILITY_INFO, +- GUEST_INTR_STATE_NMI); ++ if (!cpu_has_virtual_nmis()) { ++ if (vmx->loaded_vmcs->soft_vnmi_blocked != masked) { ++ vmx->loaded_vmcs->soft_vnmi_blocked = masked; ++ vmx->loaded_vmcs->vnmi_blocked_time = 0; ++ } ++ } else { ++ vmx->loaded_vmcs->nmi_known_unmasked = !masked; ++ if (masked) ++ vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO, ++ GUEST_INTR_STATE_NMI); ++ else ++ vmcs_clear_bits(GUEST_INTERRUPTIBILITY_INFO, ++ GUEST_INTR_STATE_NMI); ++ } + } + + static int vmx_nmi_allowed(struct kvm_vcpu *vcpu) +@@ -5750,6 +5777,10 @@ static int vmx_nmi_allowed(struct kvm_vcpu *vcpu) + if (to_vmx(vcpu)->nested.nested_run_pending) + return 0; + ++ if (!cpu_has_virtual_nmis() && ++ to_vmx(vcpu)->loaded_vmcs->soft_vnmi_blocked) ++ return 0; ++ + return !(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & + (GUEST_INTR_STATE_MOV_SS | GUEST_INTR_STATE_STI + | GUEST_INTR_STATE_NMI)); +@@ -6478,6 +6509,7 @@ static int handle_ept_violation(struct kvm_vcpu *vcpu) + * AAK134, BY25. + */ + if (!(to_vmx(vcpu)->idt_vectoring_info & VECTORING_INFO_VALID_MASK) && ++ cpu_has_virtual_nmis() && + (exit_qualification & INTR_INFO_UNBLOCK_NMI)) + vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO, GUEST_INTR_STATE_NMI); + +@@ -6961,7 +6993,7 @@ static struct loaded_vmcs *nested_get_current_vmcs02(struct vcpu_vmx *vmx) + } + + /* Create a new VMCS */ +- item = kmalloc(sizeof(struct vmcs02_list), GFP_KERNEL); ++ item = kzalloc(sizeof(struct vmcs02_list), GFP_KERNEL); + if (!item) + return NULL; + item->vmcs02.vmcs = alloc_vmcs(); +@@ -7978,6 +8010,7 @@ static int handle_pml_full(struct kvm_vcpu *vcpu) + * "blocked by NMI" bit has to be set before next VM entry. + */ + if (!(to_vmx(vcpu)->idt_vectoring_info & VECTORING_INFO_VALID_MASK) && ++ cpu_has_virtual_nmis() && + (exit_qualification & INTR_INFO_UNBLOCK_NMI)) + vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO, + GUEST_INTR_STATE_NMI); +@@ -8822,6 +8855,25 @@ static int vmx_handle_exit(struct kvm_vcpu *vcpu) + return 0; + } + ++ if (unlikely(!cpu_has_virtual_nmis() && ++ vmx->loaded_vmcs->soft_vnmi_blocked)) { ++ if (vmx_interrupt_allowed(vcpu)) { ++ vmx->loaded_vmcs->soft_vnmi_blocked = 0; ++ } else if (vmx->loaded_vmcs->vnmi_blocked_time > 1000000000LL && ++ vcpu->arch.nmi_pending) { ++ /* ++ * This CPU don't support us in finding the end of an ++ * NMI-blocked window if the guest runs with IRQs ++ * disabled. So we pull the trigger after 1 s of ++ * futile waiting, but inform the user about this. ++ */ ++ printk(KERN_WARNING "%s: Breaking out of NMI-blocked " ++ "state on VCPU %d after 1 s timeout\n", ++ __func__, vcpu->vcpu_id); ++ vmx->loaded_vmcs->soft_vnmi_blocked = 0; ++ } ++ } ++ + if (exit_reason < kvm_vmx_max_exit_handlers + && kvm_vmx_exit_handlers[exit_reason]) + return kvm_vmx_exit_handlers[exit_reason](vcpu); +@@ -9104,33 +9156,38 @@ static void vmx_recover_nmi_blocking(struct vcpu_vmx *vmx) + + idtv_info_valid = vmx->idt_vectoring_info & VECTORING_INFO_VALID_MASK; + +- if (vmx->loaded_vmcs->nmi_known_unmasked) +- return; +- /* +- * Can't use vmx->exit_intr_info since we're not sure what +- * the exit reason is. +- */ +- exit_intr_info = vmcs_read32(VM_EXIT_INTR_INFO); +- unblock_nmi = (exit_intr_info & INTR_INFO_UNBLOCK_NMI) != 0; +- vector = exit_intr_info & INTR_INFO_VECTOR_MASK; +- /* +- * SDM 3: 27.7.1.2 (September 2008) +- * Re-set bit "block by NMI" before VM entry if vmexit caused by +- * a guest IRET fault. +- * SDM 3: 23.2.2 (September 2008) +- * Bit 12 is undefined in any of the following cases: +- * If the VM exit sets the valid bit in the IDT-vectoring +- * information field. +- * If the VM exit is due to a double fault. +- */ +- if ((exit_intr_info & INTR_INFO_VALID_MASK) && unblock_nmi && +- vector != DF_VECTOR && !idtv_info_valid) +- vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO, +- GUEST_INTR_STATE_NMI); +- else +- vmx->loaded_vmcs->nmi_known_unmasked = +- !(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) +- & GUEST_INTR_STATE_NMI); ++ if (cpu_has_virtual_nmis()) { ++ if (vmx->loaded_vmcs->nmi_known_unmasked) ++ return; ++ /* ++ * Can't use vmx->exit_intr_info since we're not sure what ++ * the exit reason is. ++ */ ++ exit_intr_info = vmcs_read32(VM_EXIT_INTR_INFO); ++ unblock_nmi = (exit_intr_info & INTR_INFO_UNBLOCK_NMI) != 0; ++ vector = exit_intr_info & INTR_INFO_VECTOR_MASK; ++ /* ++ * SDM 3: 27.7.1.2 (September 2008) ++ * Re-set bit "block by NMI" before VM entry if vmexit caused by ++ * a guest IRET fault. ++ * SDM 3: 23.2.2 (September 2008) ++ * Bit 12 is undefined in any of the following cases: ++ * If the VM exit sets the valid bit in the IDT-vectoring ++ * information field. ++ * If the VM exit is due to a double fault. ++ */ ++ if ((exit_intr_info & INTR_INFO_VALID_MASK) && unblock_nmi && ++ vector != DF_VECTOR && !idtv_info_valid) ++ vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO, ++ GUEST_INTR_STATE_NMI); ++ else ++ vmx->loaded_vmcs->nmi_known_unmasked = ++ !(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) ++ & GUEST_INTR_STATE_NMI); ++ } else if (unlikely(vmx->loaded_vmcs->soft_vnmi_blocked)) ++ vmx->loaded_vmcs->vnmi_blocked_time += ++ ktime_to_ns(ktime_sub(ktime_get(), ++ vmx->loaded_vmcs->entry_time)); + } + + static void __vmx_complete_interrupts(struct kvm_vcpu *vcpu, +@@ -9247,6 +9304,11 @@ static void __noclone vmx_vcpu_run(struct kvm_vcpu *vcpu) + struct vcpu_vmx *vmx = to_vmx(vcpu); + unsigned long debugctlmsr, cr3, cr4; + ++ /* Record the guest's net vcpu time for enforced NMI injections. */ ++ if (unlikely(!cpu_has_virtual_nmis() && ++ vmx->loaded_vmcs->soft_vnmi_blocked)) ++ vmx->loaded_vmcs->entry_time = ktime_get(); ++ + /* Don't enter VMX if guest state is invalid, let the exit handler + start emulation until we arrive back to a valid state */ + if (vmx->emulation_required) +@@ -11325,6 +11387,8 @@ static void load_vmcs12_host_state(struct kvm_vcpu *vcpu, + vmcs_writel(GUEST_SYSENTER_EIP, vmcs12->host_ia32_sysenter_eip); + vmcs_writel(GUEST_IDTR_BASE, vmcs12->host_idtr_base); + vmcs_writel(GUEST_GDTR_BASE, vmcs12->host_gdtr_base); ++ vmcs_write32(GUEST_IDTR_LIMIT, 0xFFFF); ++ vmcs_write32(GUEST_GDTR_LIMIT, 0xFFFF); + + /* If not VM_EXIT_CLEAR_BNDCFGS, the L2 value propagates to L1. */ + if (vmcs12->vm_exit_controls & VM_EXIT_CLEAR_BNDCFGS) +diff --git a/arch/x86/lib/x86-opcode-map.txt b/arch/x86/lib/x86-opcode-map.txt +index 12e377184ee4..c4d55919fac1 100644 +--- a/arch/x86/lib/x86-opcode-map.txt ++++ b/arch/x86/lib/x86-opcode-map.txt +@@ -896,7 +896,7 @@ EndTable + + GrpTable: Grp3_1 + 0: TEST Eb,Ib +-1: ++1: TEST Eb,Ib + 2: NOT Eb + 3: NEG Eb + 4: MUL AL,Eb +diff --git a/block/blk-core.c b/block/blk-core.c +index 048be4aa6024..33ee583cfe45 100644 +--- a/block/blk-core.c ++++ b/block/blk-core.c +@@ -333,6 +333,7 @@ EXPORT_SYMBOL(blk_stop_queue); + void blk_sync_queue(struct request_queue *q) + { + del_timer_sync(&q->timeout); ++ cancel_work_sync(&q->timeout_work); + + if (q->mq_ops) { + struct blk_mq_hw_ctx *hctx; +@@ -844,6 +845,7 @@ struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id) + setup_timer(&q->backing_dev_info->laptop_mode_wb_timer, + laptop_mode_timer_fn, (unsigned long) q); + setup_timer(&q->timeout, blk_rq_timed_out_timer, (unsigned long) q); ++ INIT_WORK(&q->timeout_work, NULL); + INIT_LIST_HEAD(&q->queue_head); + INIT_LIST_HEAD(&q->timeout_list); + INIT_LIST_HEAD(&q->icq_list); +diff --git a/block/blk-timeout.c b/block/blk-timeout.c +index 17ec83bb0900..6427be7ac363 100644 +--- a/block/blk-timeout.c ++++ b/block/blk-timeout.c +@@ -134,8 +134,6 @@ void blk_timeout_work(struct work_struct *work) + struct request *rq, *tmp; + int next_set = 0; + +- if (blk_queue_enter(q, true)) +- return; + spin_lock_irqsave(q->queue_lock, flags); + + list_for_each_entry_safe(rq, tmp, &q->timeout_list, timeout_list) +@@ -145,7 +143,6 @@ void blk_timeout_work(struct work_struct *work) + mod_timer(&q->timeout, round_jiffies_up(next)); + + spin_unlock_irqrestore(q->queue_lock, flags); +- blk_queue_exit(q); + } + + /** +diff --git a/drivers/acpi/device_pm.c b/drivers/acpi/device_pm.c +index fbcc73f7a099..18af71057b44 100644 +--- a/drivers/acpi/device_pm.c ++++ b/drivers/acpi/device_pm.c +@@ -387,6 +387,7 @@ EXPORT_SYMBOL(acpi_bus_power_manageable); + + #ifdef CONFIG_PM + static DEFINE_MUTEX(acpi_pm_notifier_lock); ++static DEFINE_MUTEX(acpi_pm_notifier_install_lock); + + void acpi_pm_wakeup_event(struct device *dev) + { +@@ -443,24 +444,25 @@ acpi_status acpi_add_pm_notifier(struct acpi_device *adev, struct device *dev, + if (!dev && !func) + return AE_BAD_PARAMETER; + +- mutex_lock(&acpi_pm_notifier_lock); ++ mutex_lock(&acpi_pm_notifier_install_lock); + + if (adev->wakeup.flags.notifier_present) + goto out; + +- adev->wakeup.ws = wakeup_source_register(dev_name(&adev->dev)); +- adev->wakeup.context.dev = dev; +- adev->wakeup.context.func = func; +- + status = acpi_install_notify_handler(adev->handle, ACPI_SYSTEM_NOTIFY, + acpi_pm_notify_handler, NULL); + if (ACPI_FAILURE(status)) + goto out; + ++ mutex_lock(&acpi_pm_notifier_lock); ++ adev->wakeup.ws = wakeup_source_register(dev_name(&adev->dev)); ++ adev->wakeup.context.dev = dev; ++ adev->wakeup.context.func = func; + adev->wakeup.flags.notifier_present = true; ++ mutex_unlock(&acpi_pm_notifier_lock); + + out: +- mutex_unlock(&acpi_pm_notifier_lock); ++ mutex_unlock(&acpi_pm_notifier_install_lock); + return status; + } + +@@ -472,7 +474,7 @@ acpi_status acpi_remove_pm_notifier(struct acpi_device *adev) + { + acpi_status status = AE_BAD_PARAMETER; + +- mutex_lock(&acpi_pm_notifier_lock); ++ mutex_lock(&acpi_pm_notifier_install_lock); + + if (!adev->wakeup.flags.notifier_present) + goto out; +@@ -483,14 +485,15 @@ acpi_status acpi_remove_pm_notifier(struct acpi_device *adev) + if (ACPI_FAILURE(status)) + goto out; + ++ mutex_lock(&acpi_pm_notifier_lock); + adev->wakeup.context.func = NULL; + adev->wakeup.context.dev = NULL; + wakeup_source_unregister(adev->wakeup.ws); +- + adev->wakeup.flags.notifier_present = false; ++ mutex_unlock(&acpi_pm_notifier_lock); + + out: +- mutex_unlock(&acpi_pm_notifier_lock); ++ mutex_unlock(&acpi_pm_notifier_install_lock); + return status; + } + +diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c +index 236b14324780..82b3ce5e937e 100644 +--- a/drivers/acpi/ec.c ++++ b/drivers/acpi/ec.c +@@ -486,8 +486,11 @@ static inline void __acpi_ec_enable_event(struct acpi_ec *ec) + { + if (!test_and_set_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags)) + ec_log_drv("event unblocked"); +- if (!test_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) +- advance_transaction(ec); ++ /* ++ * Unconditionally invoke this once after enabling the event ++ * handling mechanism to detect the pending events. ++ */ ++ advance_transaction(ec); + } + + static inline void __acpi_ec_disable_event(struct acpi_ec *ec) +@@ -1456,11 +1459,10 @@ static int ec_install_handlers(struct acpi_ec *ec, bool handle_events) + if (test_bit(EC_FLAGS_STARTED, &ec->flags) && + ec->reference_count >= 1) + acpi_ec_enable_gpe(ec, true); +- +- /* EC is fully operational, allow queries */ +- acpi_ec_enable_event(ec); + } + } ++ /* EC is fully operational, allow queries */ ++ acpi_ec_enable_event(ec); + + return 0; + } +diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c +index e4effef0c83f..ea20e0eb4d5a 100644 +--- a/drivers/ata/libata-eh.c ++++ b/drivers/ata/libata-eh.c +@@ -2264,8 +2264,8 @@ static void ata_eh_link_autopsy(struct ata_link *link) + if (dev->flags & ATA_DFLAG_DUBIOUS_XFER) + eflags |= ATA_EFLAG_DUBIOUS_XFER; + ehc->i.action |= ata_eh_speed_down(dev, eflags, all_err_mask); ++ trace_ata_eh_link_autopsy(dev, ehc->i.action, all_err_mask); + } +- trace_ata_eh_link_autopsy(dev, ehc->i.action, all_err_mask); + DPRINTK("EXIT\n"); + } + +diff --git a/drivers/base/power/opp/of.c b/drivers/base/power/opp/of.c +index 0b718886479b..87509cb69f79 100644 +--- a/drivers/base/power/opp/of.c ++++ b/drivers/base/power/opp/of.c +@@ -397,6 +397,7 @@ static int _of_add_opp_table_v2(struct device *dev, struct device_node *opp_np) + dev_err(dev, "%s: Failed to add OPP, %d\n", __func__, + ret); + _dev_pm_opp_remove_table(opp_table, dev, false); ++ of_node_put(np); + goto put_opp_table; + } + } +diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c +index 9adfb5445f8d..5f2a4240a204 100644 +--- a/drivers/block/nbd.c ++++ b/drivers/block/nbd.c +@@ -288,15 +288,6 @@ static enum blk_eh_timer_return nbd_xmit_timeout(struct request *req, + cmd->status = BLK_STS_TIMEOUT; + return BLK_EH_HANDLED; + } +- +- /* If we are waiting on our dead timer then we could get timeout +- * callbacks for our request. For this we just want to reset the timer +- * and let the queue side take care of everything. +- */ +- if (!completion_done(&cmd->send_complete)) { +- nbd_config_put(nbd); +- return BLK_EH_RESET_TIMER; +- } + config = nbd->config; + + if (config->num_connections > 1) { +@@ -723,9 +714,9 @@ static int wait_for_reconnect(struct nbd_device *nbd) + return 0; + if (test_bit(NBD_DISCONNECTED, &config->runtime_flags)) + return 0; +- wait_event_interruptible_timeout(config->conn_wait, +- atomic_read(&config->live_connections), +- config->dead_conn_timeout); ++ wait_event_timeout(config->conn_wait, ++ atomic_read(&config->live_connections), ++ config->dead_conn_timeout); + return atomic_read(&config->live_connections); + } + +@@ -740,6 +731,7 @@ static int nbd_handle_cmd(struct nbd_cmd *cmd, int index) + if (!refcount_inc_not_zero(&nbd->config_refs)) { + dev_err_ratelimited(disk_to_dev(nbd->disk), + "Socks array is empty\n"); ++ blk_mq_start_request(req); + return -EINVAL; + } + config = nbd->config; +@@ -748,6 +740,7 @@ static int nbd_handle_cmd(struct nbd_cmd *cmd, int index) + dev_err_ratelimited(disk_to_dev(nbd->disk), + "Attempted send on invalid socket\n"); + nbd_config_put(nbd); ++ blk_mq_start_request(req); + return -EINVAL; + } + cmd->status = BLK_STS_OK; +@@ -771,6 +764,7 @@ static int nbd_handle_cmd(struct nbd_cmd *cmd, int index) + */ + sock_shutdown(nbd); + nbd_config_put(nbd); ++ blk_mq_start_request(req); + return -EIO; + } + goto again; +@@ -781,6 +775,7 @@ static int nbd_handle_cmd(struct nbd_cmd *cmd, int index) + * here so that it gets put _after_ the request that is already on the + * dispatch list. + */ ++ blk_mq_start_request(req); + if (unlikely(nsock->pending && nsock->pending != req)) { + blk_mq_requeue_request(req, true); + ret = 0; +@@ -793,10 +788,10 @@ static int nbd_handle_cmd(struct nbd_cmd *cmd, int index) + ret = nbd_send_cmd(nbd, cmd, index); + if (ret == -EAGAIN) { + dev_err_ratelimited(disk_to_dev(nbd->disk), +- "Request send failed trying another connection\n"); ++ "Request send failed, requeueing\n"); + nbd_mark_nsock_dead(nbd, nsock, 1); +- mutex_unlock(&nsock->tx_lock); +- goto again; ++ blk_mq_requeue_request(req, true); ++ ret = 0; + } + out: + mutex_unlock(&nsock->tx_lock); +@@ -820,7 +815,6 @@ static blk_status_t nbd_queue_rq(struct blk_mq_hw_ctx *hctx, + * done sending everything over the wire. + */ + init_completion(&cmd->send_complete); +- blk_mq_start_request(bd->rq); + + /* We can be called directly from the user space process, which means we + * could possibly have signals pending so our sendmsg will fail. In +diff --git a/drivers/bluetooth/btqcomsmd.c b/drivers/bluetooth/btqcomsmd.c +index d00c4fdae924..bd810d01538a 100644 +--- a/drivers/bluetooth/btqcomsmd.c ++++ b/drivers/bluetooth/btqcomsmd.c +@@ -26,6 +26,7 @@ + struct btqcomsmd { + struct hci_dev *hdev; + ++ bdaddr_t bdaddr; + struct rpmsg_endpoint *acl_channel; + struct rpmsg_endpoint *cmd_channel; + }; +@@ -100,6 +101,38 @@ static int btqcomsmd_close(struct hci_dev *hdev) + return 0; + } + ++static int btqcomsmd_setup(struct hci_dev *hdev) ++{ ++ struct btqcomsmd *btq = hci_get_drvdata(hdev); ++ struct sk_buff *skb; ++ int err; ++ ++ skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT); ++ if (IS_ERR(skb)) ++ return PTR_ERR(skb); ++ kfree_skb(skb); ++ ++ /* Devices do not have persistent storage for BD address. If no ++ * BD address has been retrieved during probe, mark the device ++ * as having an invalid BD address. ++ */ ++ if (!bacmp(&btq->bdaddr, BDADDR_ANY)) { ++ set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks); ++ return 0; ++ } ++ ++ /* When setting a configured BD address fails, mark the device ++ * as having an invalid BD address. ++ */ ++ err = qca_set_bdaddr_rome(hdev, &btq->bdaddr); ++ if (err) { ++ set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks); ++ return 0; ++ } ++ ++ return 0; ++} ++ + static int btqcomsmd_probe(struct platform_device *pdev) + { + struct btqcomsmd *btq; +@@ -135,6 +168,7 @@ static int btqcomsmd_probe(struct platform_device *pdev) + hdev->open = btqcomsmd_open; + hdev->close = btqcomsmd_close; + hdev->send = btqcomsmd_send; ++ hdev->setup = btqcomsmd_setup; + hdev->set_bdaddr = qca_set_bdaddr_rome; + + ret = hci_register_dev(hdev); +diff --git a/drivers/clk/ti/clk-dra7-atl.c b/drivers/clk/ti/clk-dra7-atl.c +index 13eb04f72389..148815470431 100644 +--- a/drivers/clk/ti/clk-dra7-atl.c ++++ b/drivers/clk/ti/clk-dra7-atl.c +@@ -274,8 +274,7 @@ static int of_dra7_atl_clk_probe(struct platform_device *pdev) + + /* Get configuration for the ATL instances */ + snprintf(prop, sizeof(prop), "atl%u", i); +- of_node_get(node); +- cfg_node = of_find_node_by_name(node, prop); ++ cfg_node = of_get_child_by_name(node, prop); + if (cfg_node) { + ret = of_property_read_u32(cfg_node, "bws", + &cdesc->bws); +diff --git a/drivers/dax/super.c b/drivers/dax/super.c +index 557b93703532..c4cd034a3820 100644 +--- a/drivers/dax/super.c ++++ b/drivers/dax/super.c +@@ -344,6 +344,9 @@ static struct inode *dax_alloc_inode(struct super_block *sb) + struct inode *inode; + + dax_dev = kmem_cache_alloc(dax_cache, GFP_KERNEL); ++ if (!dax_dev) ++ return NULL; ++ + inode = &dax_dev->inode; + inode->i_rdev = 0; + return inode; +diff --git a/drivers/infiniband/core/cm.c b/drivers/infiniband/core/cm.c +index 4c4b46586af2..2af79e4f3235 100644 +--- a/drivers/infiniband/core/cm.c ++++ b/drivers/infiniband/core/cm.c +@@ -1575,7 +1575,7 @@ static void cm_format_req_event(struct cm_work *work, + param->bth_pkey = cm_get_bth_pkey(work); + param->port = cm_id_priv->av.port->port_num; + param->primary_path = &work->path[0]; +- if (req_msg->alt_local_lid) ++ if (cm_req_has_alt_path(req_msg)) + param->alternate_path = &work->path[1]; + else + param->alternate_path = NULL; +@@ -1856,7 +1856,8 @@ static int cm_req_handler(struct cm_work *work) + cm_process_routed_req(req_msg, work->mad_recv_wc->wc); + + memset(&work->path[0], 0, sizeof(work->path[0])); +- memset(&work->path[1], 0, sizeof(work->path[1])); ++ if (cm_req_has_alt_path(req_msg)) ++ memset(&work->path[1], 0, sizeof(work->path[1])); + grh = rdma_ah_read_grh(&cm_id_priv->av.ah_attr); + ret = ib_get_cached_gid(work->port->cm_dev->ib_device, + work->port->port_num, +@@ -3817,14 +3818,16 @@ static void cm_recv_handler(struct ib_mad_agent *mad_agent, + struct cm_port *port = mad_agent->context; + struct cm_work *work; + enum ib_cm_event_type event; ++ bool alt_path = false; + u16 attr_id; + int paths = 0; + int going_down = 0; + + switch (mad_recv_wc->recv_buf.mad->mad_hdr.attr_id) { + case CM_REQ_ATTR_ID: +- paths = 1 + (((struct cm_req_msg *) mad_recv_wc->recv_buf.mad)-> +- alt_local_lid != 0); ++ alt_path = cm_req_has_alt_path((struct cm_req_msg *) ++ mad_recv_wc->recv_buf.mad); ++ paths = 1 + (alt_path != 0); + event = IB_CM_REQ_RECEIVED; + break; + case CM_MRA_ATTR_ID: +diff --git a/drivers/infiniband/core/mad.c b/drivers/infiniband/core/mad.c +index f8f53bb90837..cb91245e9163 100644 +--- a/drivers/infiniband/core/mad.c ++++ b/drivers/infiniband/core/mad.c +@@ -1974,14 +1974,15 @@ static void ib_mad_complete_recv(struct ib_mad_agent_private *mad_agent_priv, + unsigned long flags; + int ret; + ++ INIT_LIST_HEAD(&mad_recv_wc->rmpp_list); + ret = ib_mad_enforce_security(mad_agent_priv, + mad_recv_wc->wc->pkey_index); + if (ret) { + ib_free_recv_mad(mad_recv_wc); + deref_mad_agent(mad_agent_priv); ++ return; + } + +- INIT_LIST_HEAD(&mad_recv_wc->rmpp_list); + list_add(&mad_recv_wc->recv_buf.list, &mad_recv_wc->rmpp_list); + if (ib_mad_kernel_rmpp_agent(&mad_agent_priv->agent)) { + mad_recv_wc = ib_process_rmpp_recv_wc(mad_agent_priv, +diff --git a/drivers/infiniband/core/security.c b/drivers/infiniband/core/security.c +index 88bdafb297f5..28607bb42d87 100644 +--- a/drivers/infiniband/core/security.c ++++ b/drivers/infiniband/core/security.c +@@ -87,16 +87,14 @@ static int enforce_qp_pkey_security(u16 pkey, + if (ret) + return ret; + +- if (qp_sec->qp == qp_sec->qp->real_qp) { +- list_for_each_entry(shared_qp_sec, +- &qp_sec->shared_qp_list, +- shared_qp_list) { +- ret = security_ib_pkey_access(shared_qp_sec->security, +- subnet_prefix, +- pkey); +- if (ret) +- return ret; +- } ++ list_for_each_entry(shared_qp_sec, ++ &qp_sec->shared_qp_list, ++ shared_qp_list) { ++ ret = security_ib_pkey_access(shared_qp_sec->security, ++ subnet_prefix, ++ pkey); ++ if (ret) ++ return ret; + } + return 0; + } +@@ -560,15 +558,22 @@ int ib_security_modify_qp(struct ib_qp *qp, + int ret = 0; + struct ib_ports_pkeys *tmp_pps; + struct ib_ports_pkeys *new_pps; +- bool special_qp = (qp->qp_type == IB_QPT_SMI || +- qp->qp_type == IB_QPT_GSI || +- qp->qp_type >= IB_QPT_RESERVED1); ++ struct ib_qp *real_qp = qp->real_qp; ++ bool special_qp = (real_qp->qp_type == IB_QPT_SMI || ++ real_qp->qp_type == IB_QPT_GSI || ++ real_qp->qp_type >= IB_QPT_RESERVED1); + bool pps_change = ((qp_attr_mask & (IB_QP_PKEY_INDEX | IB_QP_PORT)) || + (qp_attr_mask & IB_QP_ALT_PATH)); + ++ /* The port/pkey settings are maintained only for the real QP. Open ++ * handles on the real QP will be in the shared_qp_list. When ++ * enforcing security on the real QP all the shared QPs will be ++ * checked as well. ++ */ ++ + if (pps_change && !special_qp) { +- mutex_lock(&qp->qp_sec->mutex); +- new_pps = get_new_pps(qp, ++ mutex_lock(&real_qp->qp_sec->mutex); ++ new_pps = get_new_pps(real_qp, + qp_attr, + qp_attr_mask); + +@@ -586,14 +591,14 @@ int ib_security_modify_qp(struct ib_qp *qp, + + if (!ret) + ret = check_qp_port_pkey_settings(new_pps, +- qp->qp_sec); ++ real_qp->qp_sec); + } + + if (!ret) +- ret = qp->device->modify_qp(qp->real_qp, +- qp_attr, +- qp_attr_mask, +- udata); ++ ret = real_qp->device->modify_qp(real_qp, ++ qp_attr, ++ qp_attr_mask, ++ udata); + + if (pps_change && !special_qp) { + /* Clean up the lists and free the appropriate +@@ -602,8 +607,8 @@ int ib_security_modify_qp(struct ib_qp *qp, + if (ret) { + tmp_pps = new_pps; + } else { +- tmp_pps = qp->qp_sec->ports_pkeys; +- qp->qp_sec->ports_pkeys = new_pps; ++ tmp_pps = real_qp->qp_sec->ports_pkeys; ++ real_qp->qp_sec->ports_pkeys = new_pps; + } + + if (tmp_pps) { +@@ -611,7 +616,7 @@ int ib_security_modify_qp(struct ib_qp *qp, + port_pkey_list_remove(&tmp_pps->alt); + } + kfree(tmp_pps); +- mutex_unlock(&qp->qp_sec->mutex); ++ mutex_unlock(&real_qp->qp_sec->mutex); + } + return ret; + } +diff --git a/drivers/infiniband/hw/hfi1/chip.c b/drivers/infiniband/hw/hfi1/chip.c +index 0be42787759f..312444386f54 100644 +--- a/drivers/infiniband/hw/hfi1/chip.c ++++ b/drivers/infiniband/hw/hfi1/chip.c +@@ -13074,7 +13074,7 @@ static int request_msix_irqs(struct hfi1_devdata *dd) + first_sdma = last_general; + last_sdma = first_sdma + dd->num_sdma; + first_rx = last_sdma; +- last_rx = first_rx + dd->n_krcv_queues + HFI1_NUM_VNIC_CTXT; ++ last_rx = first_rx + dd->n_krcv_queues + dd->num_vnic_contexts; + + /* VNIC MSIx interrupts get mapped when VNIC contexts are created */ + dd->first_dyn_msix_idx = first_rx + dd->n_krcv_queues; +@@ -13294,8 +13294,9 @@ static int set_up_interrupts(struct hfi1_devdata *dd) + * slow source, SDMACleanupDone) + * N interrupts - one per used SDMA engine + * M interrupt - one per kernel receive context ++ * V interrupt - one for each VNIC context + */ +- total = 1 + dd->num_sdma + dd->n_krcv_queues + HFI1_NUM_VNIC_CTXT; ++ total = 1 + dd->num_sdma + dd->n_krcv_queues + dd->num_vnic_contexts; + + /* ask for MSI-X interrupts */ + request = request_msix(dd, total); +@@ -13356,10 +13357,12 @@ static int set_up_interrupts(struct hfi1_devdata *dd) + * in array of contexts + * freectxts - number of free user contexts + * num_send_contexts - number of PIO send contexts being used ++ * num_vnic_contexts - number of contexts reserved for VNIC + */ + static int set_up_context_variables(struct hfi1_devdata *dd) + { + unsigned long num_kernel_contexts; ++ u16 num_vnic_contexts = HFI1_NUM_VNIC_CTXT; + int total_contexts; + int ret; + unsigned ngroups; +@@ -13393,6 +13396,14 @@ static int set_up_context_variables(struct hfi1_devdata *dd) + num_kernel_contexts); + num_kernel_contexts = dd->chip_send_contexts - num_vls - 1; + } ++ ++ /* Accommodate VNIC contexts if possible */ ++ if ((num_kernel_contexts + num_vnic_contexts) > dd->chip_rcv_contexts) { ++ dd_dev_err(dd, "No receive contexts available for VNIC\n"); ++ num_vnic_contexts = 0; ++ } ++ total_contexts = num_kernel_contexts + num_vnic_contexts; ++ + /* + * User contexts: + * - default to 1 user context per real (non-HT) CPU core if +@@ -13402,19 +13413,16 @@ static int set_up_context_variables(struct hfi1_devdata *dd) + num_user_contexts = + cpumask_weight(&node_affinity.real_cpu_mask); + +- total_contexts = num_kernel_contexts + num_user_contexts; +- + /* + * Adjust the counts given a global max. + */ +- if (total_contexts > dd->chip_rcv_contexts) { ++ if (total_contexts + num_user_contexts > dd->chip_rcv_contexts) { + dd_dev_err(dd, + "Reducing # user receive contexts to: %d, from %d\n", +- (int)(dd->chip_rcv_contexts - num_kernel_contexts), ++ (int)(dd->chip_rcv_contexts - total_contexts), + (int)num_user_contexts); +- num_user_contexts = dd->chip_rcv_contexts - num_kernel_contexts; + /* recalculate */ +- total_contexts = num_kernel_contexts + num_user_contexts; ++ num_user_contexts = dd->chip_rcv_contexts - total_contexts; + } + + /* each user context requires an entry in the RMT */ +@@ -13427,25 +13435,24 @@ static int set_up_context_variables(struct hfi1_devdata *dd) + user_rmt_reduced); + /* recalculate */ + num_user_contexts = user_rmt_reduced; +- total_contexts = num_kernel_contexts + num_user_contexts; + } + +- /* Accommodate VNIC contexts */ +- if ((total_contexts + HFI1_NUM_VNIC_CTXT) <= dd->chip_rcv_contexts) +- total_contexts += HFI1_NUM_VNIC_CTXT; ++ total_contexts += num_user_contexts; + + /* the first N are kernel contexts, the rest are user/vnic contexts */ + dd->num_rcv_contexts = total_contexts; + dd->n_krcv_queues = num_kernel_contexts; + dd->first_dyn_alloc_ctxt = num_kernel_contexts; ++ dd->num_vnic_contexts = num_vnic_contexts; + dd->num_user_contexts = num_user_contexts; + dd->freectxts = num_user_contexts; + dd_dev_info(dd, +- "rcv contexts: chip %d, used %d (kernel %d, user %d)\n", ++ "rcv contexts: chip %d, used %d (kernel %d, vnic %u, user %u)\n", + (int)dd->chip_rcv_contexts, + (int)dd->num_rcv_contexts, + (int)dd->n_krcv_queues, +- (int)dd->num_rcv_contexts - dd->n_krcv_queues); ++ dd->num_vnic_contexts, ++ dd->num_user_contexts); + + /* + * Receive array allocation: +diff --git a/drivers/infiniband/hw/hfi1/hfi.h b/drivers/infiniband/hw/hfi1/hfi.h +index 3ac9c307a285..6ff44dc606eb 100644 +--- a/drivers/infiniband/hw/hfi1/hfi.h ++++ b/drivers/infiniband/hw/hfi1/hfi.h +@@ -1047,6 +1047,8 @@ struct hfi1_devdata { + u64 z_send_schedule; + + u64 __percpu *send_schedule; ++ /* number of reserved contexts for VNIC usage */ ++ u16 num_vnic_contexts; + /* number of receive contexts in use by the driver */ + u32 num_rcv_contexts; + /* number of pio send contexts in use by the driver */ +diff --git a/drivers/infiniband/hw/hfi1/sysfs.c b/drivers/infiniband/hw/hfi1/sysfs.c +index 6d2702ef34ac..25e867393463 100644 +--- a/drivers/infiniband/hw/hfi1/sysfs.c ++++ b/drivers/infiniband/hw/hfi1/sysfs.c +@@ -543,7 +543,7 @@ static ssize_t show_nctxts(struct device *device, + * give a more accurate picture of total contexts available. + */ + return scnprintf(buf, PAGE_SIZE, "%u\n", +- min(dd->num_rcv_contexts - dd->first_dyn_alloc_ctxt, ++ min(dd->num_user_contexts, + (u32)dd->sc_sizes[SC_USER].count)); + } + +diff --git a/drivers/infiniband/hw/hfi1/vnic_main.c b/drivers/infiniband/hw/hfi1/vnic_main.c +index f419cbb05928..1a17708be46a 100644 +--- a/drivers/infiniband/hw/hfi1/vnic_main.c ++++ b/drivers/infiniband/hw/hfi1/vnic_main.c +@@ -840,6 +840,9 @@ struct net_device *hfi1_vnic_alloc_rn(struct ib_device *device, + struct rdma_netdev *rn; + int i, size, rc; + ++ if (!dd->num_vnic_contexts) ++ return ERR_PTR(-ENOMEM); ++ + if (!port_num || (port_num > dd->num_pports)) + return ERR_PTR(-EINVAL); + +@@ -848,7 +851,7 @@ struct net_device *hfi1_vnic_alloc_rn(struct ib_device *device, + + size = sizeof(struct opa_vnic_rdma_netdev) + sizeof(*vinfo); + netdev = alloc_netdev_mqs(size, name, name_assign_type, setup, +- dd->chip_sdma_engines, HFI1_NUM_VNIC_CTXT); ++ dd->chip_sdma_engines, dd->num_vnic_contexts); + if (!netdev) + return ERR_PTR(-ENOMEM); + +@@ -856,7 +859,7 @@ struct net_device *hfi1_vnic_alloc_rn(struct ib_device *device, + vinfo = opa_vnic_dev_priv(netdev); + vinfo->dd = dd; + vinfo->num_tx_q = dd->chip_sdma_engines; +- vinfo->num_rx_q = HFI1_NUM_VNIC_CTXT; ++ vinfo->num_rx_q = dd->num_vnic_contexts; + vinfo->netdev = netdev; + rn->free_rdma_netdev = hfi1_vnic_free_rn; + rn->set_id = hfi1_vnic_set_vesw_id; +diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c +index fa5ccdb3bb2a..60d7b493ed2d 100644 +--- a/drivers/infiniband/ulp/srp/ib_srp.c ++++ b/drivers/infiniband/ulp/srp/ib_srp.c +@@ -665,12 +665,19 @@ static void srp_path_rec_completion(int status, + static int srp_lookup_path(struct srp_rdma_ch *ch) + { + struct srp_target_port *target = ch->target; +- int ret; ++ int ret = -ENODEV; + + ch->path.numb_path = 1; + + init_completion(&ch->done); + ++ /* ++ * Avoid that the SCSI host can be removed by srp_remove_target() ++ * before srp_path_rec_completion() is called. ++ */ ++ if (!scsi_host_get(target->scsi_host)) ++ goto out; ++ + ch->path_query_id = ib_sa_path_rec_get(&srp_sa_client, + target->srp_host->srp_dev->dev, + target->srp_host->port, +@@ -684,18 +691,24 @@ static int srp_lookup_path(struct srp_rdma_ch *ch) + GFP_KERNEL, + srp_path_rec_completion, + ch, &ch->path_query); +- if (ch->path_query_id < 0) +- return ch->path_query_id; ++ ret = ch->path_query_id; ++ if (ret < 0) ++ goto put; + + ret = wait_for_completion_interruptible(&ch->done); + if (ret < 0) +- return ret; ++ goto put; + +- if (ch->status < 0) ++ ret = ch->status; ++ if (ret < 0) + shost_printk(KERN_WARNING, target->scsi_host, + PFX "Path record query failed\n"); + +- return ch->status; ++put: ++ scsi_host_put(target->scsi_host); ++ ++out: ++ return ret; + } + + static int srp_send_req(struct srp_rdma_ch *ch, bool multich) +diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.c b/drivers/infiniband/ulp/srpt/ib_srpt.c +index 9e8e9220f816..95178b4e3565 100644 +--- a/drivers/infiniband/ulp/srpt/ib_srpt.c ++++ b/drivers/infiniband/ulp/srpt/ib_srpt.c +@@ -2777,7 +2777,7 @@ static int srpt_parse_i_port_id(u8 i_port_id[16], const char *name) + { + const char *p; + unsigned len, count, leading_zero_bytes; +- int ret, rc; ++ int ret; + + p = name; + if (strncasecmp(p, "0x", 2) == 0) +@@ -2789,10 +2789,9 @@ static int srpt_parse_i_port_id(u8 i_port_id[16], const char *name) + count = min(len / 2, 16U); + leading_zero_bytes = 16 - count; + memset(i_port_id, 0, leading_zero_bytes); +- rc = hex2bin(i_port_id + leading_zero_bytes, p, count); +- if (rc < 0) +- pr_debug("hex2bin failed for srpt_parse_i_port_id: %d\n", rc); +- ret = 0; ++ ret = hex2bin(i_port_id + leading_zero_bytes, p, count); ++ if (ret < 0) ++ pr_debug("hex2bin failed for srpt_parse_i_port_id: %d\n", ret); + out: + return ret; + } +diff --git a/drivers/irqchip/irq-gic-v3.c b/drivers/irqchip/irq-gic-v3.c +index b5df99c6f680..3b35271114ee 100644 +--- a/drivers/irqchip/irq-gic-v3.c ++++ b/drivers/irqchip/irq-gic-v3.c +@@ -1071,18 +1071,18 @@ static void __init gic_populate_ppi_partitions(struct device_node *gic_node) + int nr_parts; + struct partition_affinity *parts; + +- parts_node = of_find_node_by_name(gic_node, "ppi-partitions"); ++ parts_node = of_get_child_by_name(gic_node, "ppi-partitions"); + if (!parts_node) + return; + + nr_parts = of_get_child_count(parts_node); + + if (!nr_parts) +- return; ++ goto out_put_node; + + parts = kzalloc(sizeof(*parts) * nr_parts, GFP_KERNEL); + if (WARN_ON(!parts)) +- return; ++ goto out_put_node; + + for_each_child_of_node(parts_node, child_part) { + struct partition_affinity *part; +@@ -1149,6 +1149,9 @@ static void __init gic_populate_ppi_partitions(struct device_node *gic_node) + + gic_data.ppi_descs[i] = desc; + } ++ ++out_put_node: ++ of_node_put(parts_node); + } + + static void __init gic_of_setup_kvm_info(struct device_node *node) +diff --git a/drivers/mailbox/bcm-flexrm-mailbox.c b/drivers/mailbox/bcm-flexrm-mailbox.c +index ae6146311934..f052a3eb2098 100644 +--- a/drivers/mailbox/bcm-flexrm-mailbox.c ++++ b/drivers/mailbox/bcm-flexrm-mailbox.c +@@ -1365,8 +1365,8 @@ static void flexrm_shutdown(struct mbox_chan *chan) + /* Disable/inactivate ring */ + writel_relaxed(0x0, ring->regs + RING_CONTROL); + +- /* Flush ring with timeout of 1s */ +- timeout = 1000; ++ /* Set ring flush state */ ++ timeout = 1000; /* timeout of 1s */ + writel_relaxed(BIT(CONTROL_FLUSH_SHIFT), + ring->regs + RING_CONTROL); + do { +@@ -1374,7 +1374,23 @@ static void flexrm_shutdown(struct mbox_chan *chan) + FLUSH_DONE_MASK) + break; + mdelay(1); +- } while (timeout--); ++ } while (--timeout); ++ if (!timeout) ++ dev_err(ring->mbox->dev, ++ "setting ring%d flush state timedout\n", ring->num); ++ ++ /* Clear ring flush state */ ++ timeout = 1000; /* timeout of 1s */ ++ writel_relaxed(0x0, ring + RING_CONTROL); ++ do { ++ if (!(readl_relaxed(ring + RING_FLUSH_DONE) & ++ FLUSH_DONE_MASK)) ++ break; ++ mdelay(1); ++ } while (--timeout); ++ if (!timeout) ++ dev_err(ring->mbox->dev, ++ "clearing ring%d flush state timedout\n", ring->num); + + /* Abort all in-flight requests */ + for (reqid = 0; reqid < RING_MAX_REQ_COUNT; reqid++) { +diff --git a/drivers/md/bcache/alloc.c b/drivers/md/bcache/alloc.c +index 08035634795c..c9934139d609 100644 +--- a/drivers/md/bcache/alloc.c ++++ b/drivers/md/bcache/alloc.c +@@ -407,7 +407,8 @@ long bch_bucket_alloc(struct cache *ca, unsigned reserve, bool wait) + + finish_wait(&ca->set->bucket_wait, &w); + out: +- wake_up_process(ca->alloc_thread); ++ if (ca->alloc_thread) ++ wake_up_process(ca->alloc_thread); + + trace_bcache_alloc(ca, reserve); + +diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c +index d2121637b4ab..cae57b5be817 100644 +--- a/drivers/md/bitmap.c ++++ b/drivers/md/bitmap.c +@@ -625,7 +625,7 @@ static int bitmap_read_sb(struct bitmap *bitmap) + err = read_sb_page(bitmap->mddev, + offset, + sb_page, +- 0, PAGE_SIZE); ++ 0, sizeof(bitmap_super_t)); + } + if (err) + return err; +@@ -2123,7 +2123,7 @@ int bitmap_resize(struct bitmap *bitmap, sector_t blocks, + if (store.sb_page && bitmap->storage.sb_page) + memcpy(page_address(store.sb_page), + page_address(bitmap->storage.sb_page), +- PAGE_SIZE); ++ sizeof(bitmap_super_t)); + bitmap_file_unmap(&bitmap->storage); + bitmap->storage = store; + +diff --git a/drivers/md/dm-bufio.c b/drivers/md/dm-bufio.c +index d216a8f7bc22..8e3adcb46851 100644 +--- a/drivers/md/dm-bufio.c ++++ b/drivers/md/dm-bufio.c +@@ -974,7 +974,8 @@ static void __get_memory_limit(struct dm_bufio_client *c, + buffers = c->minimum_buffers; + + *limit_buffers = buffers; +- *threshold_buffers = buffers * DM_BUFIO_WRITEBACK_PERCENT / 100; ++ *threshold_buffers = mult_frac(buffers, ++ DM_BUFIO_WRITEBACK_PERCENT, 100); + } + + /* +@@ -1910,19 +1911,15 @@ static int __init dm_bufio_init(void) + memset(&dm_bufio_caches, 0, sizeof dm_bufio_caches); + memset(&dm_bufio_cache_names, 0, sizeof dm_bufio_cache_names); + +- mem = (__u64)((totalram_pages - totalhigh_pages) * +- DM_BUFIO_MEMORY_PERCENT / 100) << PAGE_SHIFT; ++ mem = (__u64)mult_frac(totalram_pages - totalhigh_pages, ++ DM_BUFIO_MEMORY_PERCENT, 100) << PAGE_SHIFT; + + if (mem > ULONG_MAX) + mem = ULONG_MAX; + + #ifdef CONFIG_MMU +- /* +- * Get the size of vmalloc space the same way as VMALLOC_TOTAL +- * in fs/proc/internal.h +- */ +- if (mem > (VMALLOC_END - VMALLOC_START) * DM_BUFIO_VMALLOC_PERCENT / 100) +- mem = (VMALLOC_END - VMALLOC_START) * DM_BUFIO_VMALLOC_PERCENT / 100; ++ if (mem > mult_frac(VMALLOC_TOTAL, DM_BUFIO_VMALLOC_PERCENT, 100)) ++ mem = mult_frac(VMALLOC_TOTAL, DM_BUFIO_VMALLOC_PERCENT, 100); + #endif + + dm_bufio_default_cache_size = mem; +diff --git a/drivers/md/dm-cache-target.c b/drivers/md/dm-cache-target.c +index 8785134c9f1f..0b7edfd0b454 100644 +--- a/drivers/md/dm-cache-target.c ++++ b/drivers/md/dm-cache-target.c +@@ -1201,6 +1201,18 @@ static void background_work_end(struct cache *cache) + + /*----------------------------------------------------------------*/ + ++static bool bio_writes_complete_block(struct cache *cache, struct bio *bio) ++{ ++ return (bio_data_dir(bio) == WRITE) && ++ (bio->bi_iter.bi_size == (cache->sectors_per_block << SECTOR_SHIFT)); ++} ++ ++static bool optimisable_bio(struct cache *cache, struct bio *bio, dm_oblock_t block) ++{ ++ return writeback_mode(&cache->features) && ++ (is_discarded_oblock(cache, block) || bio_writes_complete_block(cache, bio)); ++} ++ + static void quiesce(struct dm_cache_migration *mg, + void (*continuation)(struct work_struct *)) + { +@@ -1474,12 +1486,50 @@ static void mg_upgrade_lock(struct work_struct *ws) + } + } + ++static void mg_full_copy(struct work_struct *ws) ++{ ++ struct dm_cache_migration *mg = ws_to_mg(ws); ++ struct cache *cache = mg->cache; ++ struct policy_work *op = mg->op; ++ bool is_policy_promote = (op->op == POLICY_PROMOTE); ++ ++ if ((!is_policy_promote && !is_dirty(cache, op->cblock)) || ++ is_discarded_oblock(cache, op->oblock)) { ++ mg_upgrade_lock(ws); ++ return; ++ } ++ ++ init_continuation(&mg->k, mg_upgrade_lock); ++ ++ if (copy(mg, is_policy_promote)) { ++ DMERR_LIMIT("%s: migration copy failed", cache_device_name(cache)); ++ mg->k.input = BLK_STS_IOERR; ++ mg_complete(mg, false); ++ } ++} ++ + static void mg_copy(struct work_struct *ws) + { +- int r; + struct dm_cache_migration *mg = ws_to_mg(ws); + + if (mg->overwrite_bio) { ++ /* ++ * No exclusive lock was held when we last checked if the bio ++ * was optimisable. So we have to check again in case things ++ * have changed (eg, the block may no longer be discarded). ++ */ ++ if (!optimisable_bio(mg->cache, mg->overwrite_bio, mg->op->oblock)) { ++ /* ++ * Fallback to a real full copy after doing some tidying up. ++ */ ++ bool rb = bio_detain_shared(mg->cache, mg->op->oblock, mg->overwrite_bio); ++ BUG_ON(rb); /* An exclussive lock must _not_ be held for this block */ ++ mg->overwrite_bio = NULL; ++ inc_io_migrations(mg->cache); ++ mg_full_copy(ws); ++ return; ++ } ++ + /* + * It's safe to do this here, even though it's new data + * because all IO has been locked out of the block. +@@ -1489,26 +1539,8 @@ static void mg_copy(struct work_struct *ws) + */ + overwrite(mg, mg_update_metadata_after_copy); + +- } else { +- struct cache *cache = mg->cache; +- struct policy_work *op = mg->op; +- bool is_policy_promote = (op->op == POLICY_PROMOTE); +- +- if ((!is_policy_promote && !is_dirty(cache, op->cblock)) || +- is_discarded_oblock(cache, op->oblock)) { +- mg_upgrade_lock(ws); +- return; +- } +- +- init_continuation(&mg->k, mg_upgrade_lock); +- +- r = copy(mg, is_policy_promote); +- if (r) { +- DMERR_LIMIT("%s: migration copy failed", cache_device_name(cache)); +- mg->k.input = BLK_STS_IOERR; +- mg_complete(mg, false); +- } +- } ++ } else ++ mg_full_copy(ws); + } + + static int mg_lock_writes(struct dm_cache_migration *mg) +@@ -1748,18 +1780,6 @@ static void inc_miss_counter(struct cache *cache, struct bio *bio) + + /*----------------------------------------------------------------*/ + +-static bool bio_writes_complete_block(struct cache *cache, struct bio *bio) +-{ +- return (bio_data_dir(bio) == WRITE) && +- (bio->bi_iter.bi_size == (cache->sectors_per_block << SECTOR_SHIFT)); +-} +- +-static bool optimisable_bio(struct cache *cache, struct bio *bio, dm_oblock_t block) +-{ +- return writeback_mode(&cache->features) && +- (is_discarded_oblock(cache, block) || bio_writes_complete_block(cache, bio)); +-} +- + static int map_bio(struct cache *cache, struct bio *bio, dm_oblock_t block, + bool *commit_needed) + { +diff --git a/drivers/md/dm-core.h b/drivers/md/dm-core.h +index 203144762f36..6a14f945783c 100644 +--- a/drivers/md/dm-core.h ++++ b/drivers/md/dm-core.h +@@ -29,7 +29,6 @@ struct dm_kobject_holder { + * DM targets must _not_ deference a mapped_device to directly access its members! + */ + struct mapped_device { +- struct srcu_struct io_barrier; + struct mutex suspend_lock; + + /* +@@ -127,6 +126,8 @@ struct mapped_device { + struct blk_mq_tag_set *tag_set; + bool use_blk_mq:1; + bool init_tio_pdu:1; ++ ++ struct srcu_struct io_barrier; + }; + + void dm_init_md_queue(struct mapped_device *md); +diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c +index 96ab46512e1f..9fc12f556534 100644 +--- a/drivers/md/dm-crypt.c ++++ b/drivers/md/dm-crypt.c +@@ -1075,7 +1075,7 @@ static int crypt_convert_block_aead(struct crypt_config *cc, + BUG_ON(cc->integrity_iv_size && cc->integrity_iv_size != cc->iv_size); + + /* Reject unexpected unaligned bio. */ +- if (unlikely(bv_in.bv_offset & (cc->sector_size - 1))) ++ if (unlikely(bv_in.bv_len & (cc->sector_size - 1))) + return -EIO; + + dmreq = dmreq_of_req(cc, req); +@@ -1168,7 +1168,7 @@ static int crypt_convert_block_skcipher(struct crypt_config *cc, + int r = 0; + + /* Reject unexpected unaligned bio. */ +- if (unlikely(bv_in.bv_offset & (cc->sector_size - 1))) ++ if (unlikely(bv_in.bv_len & (cc->sector_size - 1))) + return -EIO; + + dmreq = dmreq_of_req(cc, req); +diff --git a/drivers/md/dm-integrity.c b/drivers/md/dm-integrity.c +index 096fe9b66c50..5e6737a44468 100644 +--- a/drivers/md/dm-integrity.c ++++ b/drivers/md/dm-integrity.c +@@ -1376,7 +1376,7 @@ static int dm_integrity_map(struct dm_target *ti, struct bio *bio) + struct bvec_iter iter; + struct bio_vec bv; + bio_for_each_segment(bv, bio, iter) { +- if (unlikely((bv.bv_offset | bv.bv_len) & ((ic->sectors_per_block << SECTOR_SHIFT) - 1))) { ++ if (unlikely(bv.bv_len & ((ic->sectors_per_block << SECTOR_SHIFT) - 1))) { + DMERR("Bio vector (%u,%u) is not aligned on %u-sector boundary", + bv.bv_offset, bv.bv_len, ic->sectors_per_block); + return DM_MAPIO_KILL; +diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c +index 11f273d2f018..e8094d8fbe0d 100644 +--- a/drivers/md/dm-mpath.c ++++ b/drivers/md/dm-mpath.c +@@ -499,8 +499,6 @@ static int multipath_clone_and_map(struct dm_target *ti, struct request *rq, + if (IS_ERR(clone)) { + /* EBUSY, ENODEV or EWOULDBLOCK: requeue */ + bool queue_dying = blk_queue_dying(q); +- DMERR_LIMIT("blk_get_request() returned %ld%s - requeuing", +- PTR_ERR(clone), queue_dying ? " (path offline)" : ""); + if (queue_dying) { + atomic_inc(&m->pg_init_in_progress); + activate_or_offline_path(pgpath); +diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c +index ef7b8f201f73..4287fc9f3527 100644 +--- a/drivers/md/dm-table.c ++++ b/drivers/md/dm-table.c +@@ -1758,13 +1758,12 @@ static bool dm_table_supports_write_zeroes(struct dm_table *t) + return true; + } + +- +-static int device_discard_capable(struct dm_target *ti, struct dm_dev *dev, +- sector_t start, sector_t len, void *data) ++static int device_not_discard_capable(struct dm_target *ti, struct dm_dev *dev, ++ sector_t start, sector_t len, void *data) + { + struct request_queue *q = bdev_get_queue(dev->bdev); + +- return q && blk_queue_discard(q); ++ return q && !blk_queue_discard(q); + } + + static bool dm_table_supports_discards(struct dm_table *t) +@@ -1772,28 +1771,24 @@ static bool dm_table_supports_discards(struct dm_table *t) + struct dm_target *ti; + unsigned i; + +- /* +- * Unless any target used by the table set discards_supported, +- * require at least one underlying device to support discards. +- * t->devices includes internal dm devices such as mirror logs +- * so we need to use iterate_devices here, which targets +- * supporting discard selectively must provide. +- */ + for (i = 0; i < dm_table_get_num_targets(t); i++) { + ti = dm_table_get_target(t, i); + + if (!ti->num_discard_bios) +- continue; +- +- if (ti->discards_supported) +- return true; ++ return false; + +- if (ti->type->iterate_devices && +- ti->type->iterate_devices(ti, device_discard_capable, NULL)) +- return true; ++ /* ++ * Either the target provides discard support (as implied by setting ++ * 'discards_supported') or it relies on _all_ data devices having ++ * discard support. ++ */ ++ if (!ti->discards_supported && ++ (!ti->type->iterate_devices || ++ ti->type->iterate_devices(ti, device_not_discard_capable, NULL))) ++ return false; + } + +- return false; ++ return true; + } + + void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q, +diff --git a/drivers/md/dm-zoned-target.c b/drivers/md/dm-zoned-target.c +index b87c1741da4b..6d7bda6f8190 100644 +--- a/drivers/md/dm-zoned-target.c ++++ b/drivers/md/dm-zoned-target.c +@@ -660,6 +660,7 @@ static int dmz_get_zoned_device(struct dm_target *ti, char *path) + struct dmz_target *dmz = ti->private; + struct request_queue *q; + struct dmz_dev *dev; ++ sector_t aligned_capacity; + int ret; + + /* Get the target device */ +@@ -685,15 +686,17 @@ static int dmz_get_zoned_device(struct dm_target *ti, char *path) + goto err; + } + ++ q = bdev_get_queue(dev->bdev); + dev->capacity = i_size_read(dev->bdev->bd_inode) >> SECTOR_SHIFT; +- if (ti->begin || (ti->len != dev->capacity)) { ++ aligned_capacity = dev->capacity & ~(blk_queue_zone_sectors(q) - 1); ++ if (ti->begin || ++ ((ti->len != dev->capacity) && (ti->len != aligned_capacity))) { + ti->error = "Partial mapping not supported"; + ret = -EINVAL; + goto err; + } + +- q = bdev_get_queue(dev->bdev); +- dev->zone_nr_sectors = q->limits.chunk_sectors; ++ dev->zone_nr_sectors = blk_queue_zone_sectors(q); + dev->zone_nr_sectors_shift = ilog2(dev->zone_nr_sectors); + + dev->zone_nr_blocks = dmz_sect2blk(dev->zone_nr_sectors); +@@ -929,8 +932,10 @@ static int dmz_iterate_devices(struct dm_target *ti, + iterate_devices_callout_fn fn, void *data) + { + struct dmz_target *dmz = ti->private; ++ struct dmz_dev *dev = dmz->dev; ++ sector_t capacity = dev->capacity & ~(dev->zone_nr_sectors - 1); + +- return fn(ti, dmz->ddev, 0, dmz->dev->capacity, data); ++ return fn(ti, dmz->ddev, 0, capacity, data); + } + + static struct target_type dmz_type = { +diff --git a/drivers/md/dm.c b/drivers/md/dm.c +index 4be85324f44d..804419635cc7 100644 +--- a/drivers/md/dm.c ++++ b/drivers/md/dm.c +@@ -1695,7 +1695,7 @@ static struct mapped_device *alloc_dev(int minor) + struct mapped_device *md; + void *old_md; + +- md = kzalloc_node(sizeof(*md), GFP_KERNEL, numa_node_id); ++ md = kvzalloc_node(sizeof(*md), GFP_KERNEL, numa_node_id); + if (!md) { + DMWARN("unable to allocate device, out of memory."); + return NULL; +@@ -1795,7 +1795,7 @@ static struct mapped_device *alloc_dev(int minor) + bad_minor: + module_put(THIS_MODULE); + bad_module_get: +- kfree(md); ++ kvfree(md); + return NULL; + } + +@@ -1814,7 +1814,7 @@ static void free_dev(struct mapped_device *md) + free_minor(minor); + + module_put(THIS_MODULE); +- kfree(md); ++ kvfree(md); + } + + static void __bind_mempools(struct mapped_device *md, struct dm_table *t) +@@ -2709,11 +2709,15 @@ struct mapped_device *dm_get_from_kobject(struct kobject *kobj) + + md = container_of(kobj, struct mapped_device, kobj_holder.kobj); + +- if (test_bit(DMF_FREEING, &md->flags) || +- dm_deleting_md(md)) +- return NULL; +- ++ spin_lock(&_minor_lock); ++ if (test_bit(DMF_FREEING, &md->flags) || dm_deleting_md(md)) { ++ md = NULL; ++ goto out; ++ } + dm_get(md); ++out: ++ spin_unlock(&_minor_lock); ++ + return md; + } + +diff --git a/drivers/md/md.c b/drivers/md/md.c +index 0ff1bbf6c90e..e019cf8c0d13 100644 +--- a/drivers/md/md.c ++++ b/drivers/md/md.c +@@ -8039,7 +8039,8 @@ bool md_write_start(struct mddev *mddev, struct bio *bi) + if (did_change) + sysfs_notify_dirent_safe(mddev->sysfs_state); + wait_event(mddev->sb_wait, +- !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags) && !mddev->suspended); ++ !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags) || ++ mddev->suspended); + if (test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)) { + percpu_ref_put(&mddev->writes_pending); + return false; +@@ -8110,7 +8111,6 @@ void md_allow_write(struct mddev *mddev) + sysfs_notify_dirent_safe(mddev->sysfs_state); + /* wait for the dirty state to be recorded in the metadata */ + wait_event(mddev->sb_wait, +- !test_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags) && + !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)); + } else + spin_unlock(&mddev->lock); +diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c +index f3f3e40dc9d8..e4e8f9e565b7 100644 +--- a/drivers/md/raid1.c ++++ b/drivers/md/raid1.c +@@ -990,14 +990,6 @@ static void wait_barrier(struct r1conf *conf, sector_t sector_nr) + _wait_barrier(conf, idx); + } + +-static void wait_all_barriers(struct r1conf *conf) +-{ +- int idx; +- +- for (idx = 0; idx < BARRIER_BUCKETS_NR; idx++) +- _wait_barrier(conf, idx); +-} +- + static void _allow_barrier(struct r1conf *conf, int idx) + { + atomic_dec(&conf->nr_pending[idx]); +@@ -1011,14 +1003,6 @@ static void allow_barrier(struct r1conf *conf, sector_t sector_nr) + _allow_barrier(conf, idx); + } + +-static void allow_all_barriers(struct r1conf *conf) +-{ +- int idx; +- +- for (idx = 0; idx < BARRIER_BUCKETS_NR; idx++) +- _allow_barrier(conf, idx); +-} +- + /* conf->resync_lock should be held */ + static int get_unqueued_pending(struct r1conf *conf) + { +@@ -1654,8 +1638,12 @@ static void print_conf(struct r1conf *conf) + + static void close_sync(struct r1conf *conf) + { +- wait_all_barriers(conf); +- allow_all_barriers(conf); ++ int idx; ++ ++ for (idx = 0; idx < BARRIER_BUCKETS_NR; idx++) { ++ _wait_barrier(conf, idx); ++ _allow_barrier(conf, idx); ++ } + + mempool_destroy(conf->r1buf_pool); + conf->r1buf_pool = NULL; +diff --git a/drivers/media/platform/qcom/venus/core.h b/drivers/media/platform/qcom/venus/core.h +index cba092bcb76d..a0fe80df0cbd 100644 +--- a/drivers/media/platform/qcom/venus/core.h ++++ b/drivers/media/platform/qcom/venus/core.h +@@ -194,7 +194,6 @@ struct venus_buffer { + * @fh: a holder of v4l file handle structure + * @streamon_cap: stream on flag for capture queue + * @streamon_out: stream on flag for output queue +- * @cmd_stop: a flag to signal encoder/decoder commands + * @width: current capture width + * @height: current capture height + * @out_width: current output width +@@ -258,7 +257,6 @@ struct venus_inst { + } controls; + struct v4l2_fh fh; + unsigned int streamon_cap, streamon_out; +- bool cmd_stop; + u32 width; + u32 height; + u32 out_width; +diff --git a/drivers/media/platform/qcom/venus/helpers.c b/drivers/media/platform/qcom/venus/helpers.c +index 9b2a401a4891..0ce9559a2924 100644 +--- a/drivers/media/platform/qcom/venus/helpers.c ++++ b/drivers/media/platform/qcom/venus/helpers.c +@@ -623,13 +623,6 @@ void venus_helper_vb2_buf_queue(struct vb2_buffer *vb) + + mutex_lock(&inst->lock); + +- if (inst->cmd_stop) { +- vbuf->flags |= V4L2_BUF_FLAG_LAST; +- v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_DONE); +- inst->cmd_stop = false; +- goto unlock; +- } +- + v4l2_m2m_buf_queue(m2m_ctx, vbuf); + + if (!(inst->streamon_out & inst->streamon_cap)) +diff --git a/drivers/media/platform/qcom/venus/hfi.c b/drivers/media/platform/qcom/venus/hfi.c +index c09490876516..ba29fd4d4984 100644 +--- a/drivers/media/platform/qcom/venus/hfi.c ++++ b/drivers/media/platform/qcom/venus/hfi.c +@@ -484,6 +484,7 @@ int hfi_session_process_buf(struct venus_inst *inst, struct hfi_frame_data *fd) + + return -EINVAL; + } ++EXPORT_SYMBOL_GPL(hfi_session_process_buf); + + irqreturn_t hfi_isr_thread(int irq, void *dev_id) + { +diff --git a/drivers/media/platform/qcom/venus/hfi_venus.c b/drivers/media/platform/qcom/venus/hfi_venus.c +index 1caae8feaa36..734ce11b0ed0 100644 +--- a/drivers/media/platform/qcom/venus/hfi_venus.c ++++ b/drivers/media/platform/qcom/venus/hfi_venus.c +@@ -344,7 +344,7 @@ static int venus_alloc(struct venus_hfi_device *hdev, struct mem_desc *desc, + desc->attrs = DMA_ATTR_WRITE_COMBINE; + desc->size = ALIGN(size, SZ_4K); + +- desc->kva = dma_alloc_attrs(dev, size, &desc->da, GFP_KERNEL, ++ desc->kva = dma_alloc_attrs(dev, desc->size, &desc->da, GFP_KERNEL, + desc->attrs); + if (!desc->kva) + return -ENOMEM; +@@ -710,10 +710,8 @@ static int venus_interface_queues_init(struct venus_hfi_device *hdev) + if (ret) + return ret; + +- hdev->ifaceq_table.kva = desc.kva; +- hdev->ifaceq_table.da = desc.da; +- hdev->ifaceq_table.size = IFACEQ_TABLE_SIZE; +- offset = hdev->ifaceq_table.size; ++ hdev->ifaceq_table = desc; ++ offset = IFACEQ_TABLE_SIZE; + + for (i = 0; i < IFACEQ_NUM; i++) { + queue = &hdev->queues[i]; +@@ -755,9 +753,7 @@ static int venus_interface_queues_init(struct venus_hfi_device *hdev) + if (ret) { + hdev->sfr.da = 0; + } else { +- hdev->sfr.da = desc.da; +- hdev->sfr.kva = desc.kva; +- hdev->sfr.size = ALIGNED_SFR_SIZE; ++ hdev->sfr = desc; + sfr = hdev->sfr.kva; + sfr->buf_size = ALIGNED_SFR_SIZE; + } +diff --git a/drivers/media/platform/qcom/venus/vdec.c b/drivers/media/platform/qcom/venus/vdec.c +index da611a5eb670..c9e9576bb08a 100644 +--- a/drivers/media/platform/qcom/venus/vdec.c ++++ b/drivers/media/platform/qcom/venus/vdec.c +@@ -469,8 +469,14 @@ static int vdec_subscribe_event(struct v4l2_fh *fh, + static int + vdec_try_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *cmd) + { +- if (cmd->cmd != V4L2_DEC_CMD_STOP) ++ switch (cmd->cmd) { ++ case V4L2_DEC_CMD_STOP: ++ if (cmd->flags & V4L2_DEC_CMD_STOP_TO_BLACK) ++ return -EINVAL; ++ break; ++ default: + return -EINVAL; ++ } + + return 0; + } +@@ -479,6 +485,7 @@ static int + vdec_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *cmd) + { + struct venus_inst *inst = to_inst(file); ++ struct hfi_frame_data fdata = {0}; + int ret; + + ret = vdec_try_decoder_cmd(file, fh, cmd); +@@ -486,12 +493,23 @@ vdec_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *cmd) + return ret; + + mutex_lock(&inst->lock); +- inst->cmd_stop = true; +- mutex_unlock(&inst->lock); + +- hfi_session_flush(inst); ++ /* ++ * Implement V4L2_DEC_CMD_STOP by enqueue an empty buffer on decoder ++ * input to signal EOS. ++ */ ++ if (!(inst->streamon_out & inst->streamon_cap)) ++ goto unlock; ++ ++ fdata.buffer_type = HFI_BUFFER_INPUT; ++ fdata.flags |= HFI_BUFFERFLAG_EOS; ++ fdata.device_addr = 0xdeadbeef; + +- return 0; ++ ret = hfi_session_process_buf(inst, &fdata); ++ ++unlock: ++ mutex_unlock(&inst->lock); ++ return ret; + } + + static const struct v4l2_ioctl_ops vdec_ioctl_ops = { +@@ -718,7 +736,6 @@ static int vdec_start_streaming(struct vb2_queue *q, unsigned int count) + inst->reconfig = false; + inst->sequence_cap = 0; + inst->sequence_out = 0; +- inst->cmd_stop = false; + + ret = vdec_init_session(inst); + if (ret) +@@ -807,11 +824,6 @@ static void vdec_buf_done(struct venus_inst *inst, unsigned int buf_type, + vb->timestamp = timestamp_us * NSEC_PER_USEC; + vbuf->sequence = inst->sequence_cap++; + +- if (inst->cmd_stop) { +- vbuf->flags |= V4L2_BUF_FLAG_LAST; +- inst->cmd_stop = false; +- } +- + if (vbuf->flags & V4L2_BUF_FLAG_LAST) { + const struct v4l2_event ev = { .type = V4L2_EVENT_EOS }; + +diff --git a/drivers/media/platform/qcom/venus/venc.c b/drivers/media/platform/qcom/venus/venc.c +index 6f123a387cf9..3fcf0e9b7b29 100644 +--- a/drivers/media/platform/qcom/venus/venc.c ++++ b/drivers/media/platform/qcom/venus/venc.c +@@ -963,13 +963,12 @@ static void venc_buf_done(struct venus_inst *inst, unsigned int buf_type, + if (!vbuf) + return; + +- vb = &vbuf->vb2_buf; +- vb->planes[0].bytesused = bytesused; +- vb->planes[0].data_offset = data_offset; +- + vbuf->flags = flags; + + if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) { ++ vb = &vbuf->vb2_buf; ++ vb2_set_plane_payload(vb, 0, bytesused + data_offset); ++ vb->planes[0].data_offset = data_offset; + vb->timestamp = timestamp_us * NSEC_PER_USEC; + vbuf->sequence = inst->sequence_cap++; + } else { +diff --git a/drivers/media/rc/ir-lirc-codec.c b/drivers/media/rc/ir-lirc-codec.c +index d2223c04e9ad..4c8f456238bc 100644 +--- a/drivers/media/rc/ir-lirc-codec.c ++++ b/drivers/media/rc/ir-lirc-codec.c +@@ -298,11 +298,14 @@ static long ir_lirc_ioctl(struct file *filep, unsigned int cmd, + if (!dev->max_timeout) + return -ENOTTY; + ++ /* Check for multiply overflow */ ++ if (val > U32_MAX / 1000) ++ return -EINVAL; ++ + tmp = val * 1000; + +- if (tmp < dev->min_timeout || +- tmp > dev->max_timeout) +- return -EINVAL; ++ if (tmp < dev->min_timeout || tmp > dev->max_timeout) ++ return -EINVAL; + + if (dev->s_timeout) + ret = dev->s_timeout(dev, tmp); +diff --git a/drivers/media/rc/ir-nec-decoder.c b/drivers/media/rc/ir-nec-decoder.c +index 817c18f2ddd1..a95d09acc22a 100644 +--- a/drivers/media/rc/ir-nec-decoder.c ++++ b/drivers/media/rc/ir-nec-decoder.c +@@ -87,8 +87,6 @@ static int ir_nec_decode(struct rc_dev *dev, struct ir_raw_event ev) + data->state = STATE_BIT_PULSE; + return 0; + } else if (eq_margin(ev.duration, NEC_REPEAT_SPACE, NEC_UNIT / 2)) { +- rc_repeat(dev); +- IR_dprintk(1, "Repeat last key\n"); + data->state = STATE_TRAILER_PULSE; + return 0; + } +@@ -151,19 +149,26 @@ static int ir_nec_decode(struct rc_dev *dev, struct ir_raw_event ev) + if (!geq_margin(ev.duration, NEC_TRAILER_SPACE, NEC_UNIT / 2)) + break; + +- address = bitrev8((data->bits >> 24) & 0xff); +- not_address = bitrev8((data->bits >> 16) & 0xff); +- command = bitrev8((data->bits >> 8) & 0xff); +- not_command = bitrev8((data->bits >> 0) & 0xff); ++ if (data->count == NEC_NBITS) { ++ address = bitrev8((data->bits >> 24) & 0xff); ++ not_address = bitrev8((data->bits >> 16) & 0xff); ++ command = bitrev8((data->bits >> 8) & 0xff); ++ not_command = bitrev8((data->bits >> 0) & 0xff); ++ ++ scancode = ir_nec_bytes_to_scancode(address, ++ not_address, ++ command, ++ not_command, ++ &rc_proto); + +- scancode = ir_nec_bytes_to_scancode(address, not_address, +- command, not_command, +- &rc_proto); ++ if (data->is_nec_x) ++ data->necx_repeat = true; + +- if (data->is_nec_x) +- data->necx_repeat = true; ++ rc_keydown(dev, rc_proto, scancode, 0); ++ } else { ++ rc_repeat(dev); ++ } + +- rc_keydown(dev, rc_proto, scancode, 0); + data->state = STATE_INACTIVE; + return 0; + } +diff --git a/drivers/media/usb/as102/as102_fw.c b/drivers/media/usb/as102/as102_fw.c +index 5a28ce3a1d49..38dbc128340d 100644 +--- a/drivers/media/usb/as102/as102_fw.c ++++ b/drivers/media/usb/as102/as102_fw.c +@@ -101,18 +101,23 @@ static int as102_firmware_upload(struct as10x_bus_adapter_t *bus_adap, + unsigned char *cmd, + const struct firmware *firmware) { + +- struct as10x_fw_pkt_t fw_pkt; ++ struct as10x_fw_pkt_t *fw_pkt; + int total_read_bytes = 0, errno = 0; + unsigned char addr_has_changed = 0; + ++ fw_pkt = kmalloc(sizeof(*fw_pkt), GFP_KERNEL); ++ if (!fw_pkt) ++ return -ENOMEM; ++ ++ + for (total_read_bytes = 0; total_read_bytes < firmware->size; ) { + int read_bytes = 0, data_len = 0; + + /* parse intel hex line */ + read_bytes = parse_hex_line( + (u8 *) (firmware->data + total_read_bytes), +- fw_pkt.raw.address, +- fw_pkt.raw.data, ++ fw_pkt->raw.address, ++ fw_pkt->raw.data, + &data_len, + &addr_has_changed); + +@@ -122,28 +127,28 @@ static int as102_firmware_upload(struct as10x_bus_adapter_t *bus_adap, + /* detect the end of file */ + total_read_bytes += read_bytes; + if (total_read_bytes == firmware->size) { +- fw_pkt.u.request[0] = 0x00; +- fw_pkt.u.request[1] = 0x03; ++ fw_pkt->u.request[0] = 0x00; ++ fw_pkt->u.request[1] = 0x03; + + /* send EOF command */ + errno = bus_adap->ops->upload_fw_pkt(bus_adap, + (uint8_t *) +- &fw_pkt, 2, 0); ++ fw_pkt, 2, 0); + if (errno < 0) + goto error; + } else { + if (!addr_has_changed) { + /* prepare command to send */ +- fw_pkt.u.request[0] = 0x00; +- fw_pkt.u.request[1] = 0x01; ++ fw_pkt->u.request[0] = 0x00; ++ fw_pkt->u.request[1] = 0x01; + +- data_len += sizeof(fw_pkt.u.request); +- data_len += sizeof(fw_pkt.raw.address); ++ data_len += sizeof(fw_pkt->u.request); ++ data_len += sizeof(fw_pkt->raw.address); + + /* send cmd to device */ + errno = bus_adap->ops->upload_fw_pkt(bus_adap, + (uint8_t *) +- &fw_pkt, ++ fw_pkt, + data_len, + 0); + if (errno < 0) +@@ -152,6 +157,7 @@ static int as102_firmware_upload(struct as10x_bus_adapter_t *bus_adap, + } + } + error: ++ kfree(fw_pkt); + return (errno == 0) ? total_read_bytes : errno; + } + +diff --git a/drivers/media/usb/cx231xx/cx231xx-cards.c b/drivers/media/usb/cx231xx/cx231xx-cards.c +index e0daa9b6c2a0..9b742d569fb5 100644 +--- a/drivers/media/usb/cx231xx/cx231xx-cards.c ++++ b/drivers/media/usb/cx231xx/cx231xx-cards.c +@@ -1684,7 +1684,7 @@ static int cx231xx_usb_probe(struct usb_interface *interface, + nr = dev->devno; + + assoc_desc = udev->actconfig->intf_assoc[0]; +- if (assoc_desc->bFirstInterface != ifnum) { ++ if (!assoc_desc || assoc_desc->bFirstInterface != ifnum) { + dev_err(d, "Not found matching IAD interface\n"); + retval = -ENODEV; + goto err_if; +diff --git a/drivers/media/v4l2-core/v4l2-ctrls.c b/drivers/media/v4l2-core/v4l2-ctrls.c +index dd1db678718c..8033d6f73501 100644 +--- a/drivers/media/v4l2-core/v4l2-ctrls.c ++++ b/drivers/media/v4l2-core/v4l2-ctrls.c +@@ -1227,6 +1227,16 @@ void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type, + } + EXPORT_SYMBOL(v4l2_ctrl_fill); + ++static u32 user_flags(const struct v4l2_ctrl *ctrl) ++{ ++ u32 flags = ctrl->flags; ++ ++ if (ctrl->is_ptr) ++ flags |= V4L2_CTRL_FLAG_HAS_PAYLOAD; ++ ++ return flags; ++} ++ + static void fill_event(struct v4l2_event *ev, struct v4l2_ctrl *ctrl, u32 changes) + { + memset(ev->reserved, 0, sizeof(ev->reserved)); +@@ -1234,7 +1244,7 @@ static void fill_event(struct v4l2_event *ev, struct v4l2_ctrl *ctrl, u32 change + ev->id = ctrl->id; + ev->u.ctrl.changes = changes; + ev->u.ctrl.type = ctrl->type; +- ev->u.ctrl.flags = ctrl->flags; ++ ev->u.ctrl.flags = user_flags(ctrl); + if (ctrl->is_ptr) + ev->u.ctrl.value64 = 0; + else +@@ -2577,10 +2587,8 @@ int v4l2_query_ext_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_query_ext_ctr + else + qc->id = ctrl->id; + strlcpy(qc->name, ctrl->name, sizeof(qc->name)); +- qc->flags = ctrl->flags; ++ qc->flags = user_flags(ctrl); + qc->type = ctrl->type; +- if (ctrl->is_ptr) +- qc->flags |= V4L2_CTRL_FLAG_HAS_PAYLOAD; + qc->elem_size = ctrl->elem_size; + qc->elems = ctrl->elems; + qc->nr_of_dims = ctrl->nr_of_dims; +diff --git a/drivers/mfd/lpc_ich.c b/drivers/mfd/lpc_ich.c +index 450ae36645aa..cf1120abbf52 100644 +--- a/drivers/mfd/lpc_ich.c ++++ b/drivers/mfd/lpc_ich.c +@@ -522,6 +522,7 @@ static struct lpc_ich_info lpc_chipset_info[] = { + .name = "Avoton SoC", + .iTCO_version = 3, + .gpio_version = AVOTON_GPIO, ++ .spi_type = INTEL_SPI_BYT, + }, + [LPC_BAYTRAIL] = { + .name = "Bay Trail SoC", +diff --git a/drivers/mtd/devices/docg3.c b/drivers/mtd/devices/docg3.c +index 84b16133554b..0806f72102c0 100644 +--- a/drivers/mtd/devices/docg3.c ++++ b/drivers/mtd/devices/docg3.c +@@ -1814,8 +1814,13 @@ static void __init doc_dbg_register(struct mtd_info *floor) + struct dentry *root = floor->dbg.dfs_dir; + struct docg3 *docg3 = floor->priv; + +- if (IS_ERR_OR_NULL(root)) ++ if (IS_ERR_OR_NULL(root)) { ++ if (IS_ENABLED(CONFIG_DEBUG_FS) && ++ !IS_ENABLED(CONFIG_MTD_PARTITIONED_MASTER)) ++ dev_warn(floor->dev.parent, ++ "CONFIG_MTD_PARTITIONED_MASTER must be enabled to expose debugfs stuff\n"); + return; ++ } + + debugfs_create_file("docg3_flashcontrol", S_IRUSR, root, docg3, + &flashcontrol_fops); +diff --git a/drivers/mtd/nand/atmel/nand-controller.c b/drivers/mtd/nand/atmel/nand-controller.c +index f25eca79f4e5..68c9d98a3347 100644 +--- a/drivers/mtd/nand/atmel/nand-controller.c ++++ b/drivers/mtd/nand/atmel/nand-controller.c +@@ -2547,6 +2547,7 @@ static struct platform_driver atmel_nand_controller_driver = { + .driver = { + .name = "atmel-nand-controller", + .of_match_table = of_match_ptr(atmel_nand_controller_of_ids), ++ .pm = &atmel_nand_controller_pm_ops, + }, + .probe = atmel_nand_controller_probe, + .remove = atmel_nand_controller_remove, +diff --git a/drivers/mtd/nand/mtk_ecc.c b/drivers/mtd/nand/mtk_ecc.c +index 7f3b065b6b8f..c51d214d169e 100644 +--- a/drivers/mtd/nand/mtk_ecc.c ++++ b/drivers/mtd/nand/mtk_ecc.c +@@ -115,6 +115,11 @@ static irqreturn_t mtk_ecc_irq(int irq, void *id) + op = ECC_DECODE; + dec = readw(ecc->regs + ECC_DECDONE); + if (dec & ecc->sectors) { ++ /* ++ * Clear decode IRQ status once again to ensure that ++ * there will be no extra IRQ. ++ */ ++ readw(ecc->regs + ECC_DECIRQ_STA); + ecc->sectors = 0; + complete(&ecc->done); + } else { +@@ -130,8 +135,6 @@ static irqreturn_t mtk_ecc_irq(int irq, void *id) + } + } + +- writel(0, ecc->regs + ECC_IRQ_REG(op)); +- + return IRQ_HANDLED; + } + +@@ -307,6 +310,12 @@ void mtk_ecc_disable(struct mtk_ecc *ecc) + + /* disable it */ + mtk_ecc_wait_idle(ecc, op); ++ if (op == ECC_DECODE) ++ /* ++ * Clear decode IRQ status in case there is a timeout to wait ++ * decode IRQ. ++ */ ++ readw(ecc->regs + ECC_DECIRQ_STA); + writew(0, ecc->regs + ECC_IRQ_REG(op)); + writew(ECC_OP_DISABLE, ecc->regs + ECC_CTL_REG(op)); + +diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c +index 12edaae17d81..3f1d806e590a 100644 +--- a/drivers/mtd/nand/nand_base.c ++++ b/drivers/mtd/nand/nand_base.c +@@ -1246,6 +1246,7 @@ int nand_reset(struct nand_chip *chip, int chipnr) + + return 0; + } ++EXPORT_SYMBOL_GPL(nand_reset); + + /** + * nand_check_erased_buf - check if a buffer contains (almost) only 0xff data +@@ -2799,15 +2800,18 @@ static int panic_nand_write(struct mtd_info *mtd, loff_t to, size_t len, + size_t *retlen, const uint8_t *buf) + { + struct nand_chip *chip = mtd_to_nand(mtd); ++ int chipnr = (int)(to >> chip->chip_shift); + struct mtd_oob_ops ops; + int ret; + +- /* Wait for the device to get ready */ +- panic_nand_wait(mtd, chip, 400); +- + /* Grab the device */ + panic_nand_get_device(chip, mtd, FL_WRITING); + ++ chip->select_chip(mtd, chipnr); ++ ++ /* Wait for the device to get ready */ ++ panic_nand_wait(mtd, chip, 400); ++ + memset(&ops, 0, sizeof(ops)); + ops.len = len; + ops.datbuf = (uint8_t *)buf; +diff --git a/drivers/mtd/nand/nandsim.c b/drivers/mtd/nand/nandsim.c +index 246b4393118e..44322a363ba5 100644 +--- a/drivers/mtd/nand/nandsim.c ++++ b/drivers/mtd/nand/nandsim.c +@@ -520,11 +520,16 @@ static int nandsim_debugfs_create(struct nandsim *dev) + struct dentry *root = nsmtd->dbg.dfs_dir; + struct dentry *dent; + +- if (!IS_ENABLED(CONFIG_DEBUG_FS)) ++ /* ++ * Just skip debugfs initialization when the debugfs directory is ++ * missing. ++ */ ++ if (IS_ERR_OR_NULL(root)) { ++ if (IS_ENABLED(CONFIG_DEBUG_FS) && ++ !IS_ENABLED(CONFIG_MTD_PARTITIONED_MASTER)) ++ NS_WARN("CONFIG_MTD_PARTITIONED_MASTER must be enabled to expose debugfs stuff\n"); + return 0; +- +- if (IS_ERR_OR_NULL(root)) +- return -1; ++ } + + dent = debugfs_create_file("nandsim_wear_report", S_IRUSR, + root, dev, &dfs_fops); +diff --git a/drivers/mtd/nand/omap2.c b/drivers/mtd/nand/omap2.c +index 54540c8fa1a2..9f98f74ff221 100644 +--- a/drivers/mtd/nand/omap2.c ++++ b/drivers/mtd/nand/omap2.c +@@ -1133,129 +1133,172 @@ static u8 bch8_polynomial[] = {0xef, 0x51, 0x2e, 0x09, 0xed, 0x93, 0x9a, 0xc2, + 0x97, 0x79, 0xe5, 0x24, 0xb5}; + + /** +- * omap_calculate_ecc_bch - Generate bytes of ECC bytes ++ * _omap_calculate_ecc_bch - Generate ECC bytes for one sector + * @mtd: MTD device structure + * @dat: The pointer to data on which ecc is computed + * @ecc_code: The ecc_code buffer ++ * @i: The sector number (for a multi sector page) + * +- * Support calculating of BCH4/8 ecc vectors for the page ++ * Support calculating of BCH4/8/16 ECC vectors for one sector ++ * within a page. Sector number is in @i. + */ +-static int __maybe_unused omap_calculate_ecc_bch(struct mtd_info *mtd, +- const u_char *dat, u_char *ecc_calc) ++static int _omap_calculate_ecc_bch(struct mtd_info *mtd, ++ const u_char *dat, u_char *ecc_calc, int i) + { + struct omap_nand_info *info = mtd_to_omap(mtd); + int eccbytes = info->nand.ecc.bytes; + struct gpmc_nand_regs *gpmc_regs = &info->reg; + u8 *ecc_code; +- unsigned long nsectors, bch_val1, bch_val2, bch_val3, bch_val4; ++ unsigned long bch_val1, bch_val2, bch_val3, bch_val4; + u32 val; +- int i, j; ++ int j; ++ ++ ecc_code = ecc_calc; ++ switch (info->ecc_opt) { ++ case OMAP_ECC_BCH8_CODE_HW_DETECTION_SW: ++ case OMAP_ECC_BCH8_CODE_HW: ++ bch_val1 = readl(gpmc_regs->gpmc_bch_result0[i]); ++ bch_val2 = readl(gpmc_regs->gpmc_bch_result1[i]); ++ bch_val3 = readl(gpmc_regs->gpmc_bch_result2[i]); ++ bch_val4 = readl(gpmc_regs->gpmc_bch_result3[i]); ++ *ecc_code++ = (bch_val4 & 0xFF); ++ *ecc_code++ = ((bch_val3 >> 24) & 0xFF); ++ *ecc_code++ = ((bch_val3 >> 16) & 0xFF); ++ *ecc_code++ = ((bch_val3 >> 8) & 0xFF); ++ *ecc_code++ = (bch_val3 & 0xFF); ++ *ecc_code++ = ((bch_val2 >> 24) & 0xFF); ++ *ecc_code++ = ((bch_val2 >> 16) & 0xFF); ++ *ecc_code++ = ((bch_val2 >> 8) & 0xFF); ++ *ecc_code++ = (bch_val2 & 0xFF); ++ *ecc_code++ = ((bch_val1 >> 24) & 0xFF); ++ *ecc_code++ = ((bch_val1 >> 16) & 0xFF); ++ *ecc_code++ = ((bch_val1 >> 8) & 0xFF); ++ *ecc_code++ = (bch_val1 & 0xFF); ++ break; ++ case OMAP_ECC_BCH4_CODE_HW_DETECTION_SW: ++ case OMAP_ECC_BCH4_CODE_HW: ++ bch_val1 = readl(gpmc_regs->gpmc_bch_result0[i]); ++ bch_val2 = readl(gpmc_regs->gpmc_bch_result1[i]); ++ *ecc_code++ = ((bch_val2 >> 12) & 0xFF); ++ *ecc_code++ = ((bch_val2 >> 4) & 0xFF); ++ *ecc_code++ = ((bch_val2 & 0xF) << 4) | ++ ((bch_val1 >> 28) & 0xF); ++ *ecc_code++ = ((bch_val1 >> 20) & 0xFF); ++ *ecc_code++ = ((bch_val1 >> 12) & 0xFF); ++ *ecc_code++ = ((bch_val1 >> 4) & 0xFF); ++ *ecc_code++ = ((bch_val1 & 0xF) << 4); ++ break; ++ case OMAP_ECC_BCH16_CODE_HW: ++ val = readl(gpmc_regs->gpmc_bch_result6[i]); ++ ecc_code[0] = ((val >> 8) & 0xFF); ++ ecc_code[1] = ((val >> 0) & 0xFF); ++ val = readl(gpmc_regs->gpmc_bch_result5[i]); ++ ecc_code[2] = ((val >> 24) & 0xFF); ++ ecc_code[3] = ((val >> 16) & 0xFF); ++ ecc_code[4] = ((val >> 8) & 0xFF); ++ ecc_code[5] = ((val >> 0) & 0xFF); ++ val = readl(gpmc_regs->gpmc_bch_result4[i]); ++ ecc_code[6] = ((val >> 24) & 0xFF); ++ ecc_code[7] = ((val >> 16) & 0xFF); ++ ecc_code[8] = ((val >> 8) & 0xFF); ++ ecc_code[9] = ((val >> 0) & 0xFF); ++ val = readl(gpmc_regs->gpmc_bch_result3[i]); ++ ecc_code[10] = ((val >> 24) & 0xFF); ++ ecc_code[11] = ((val >> 16) & 0xFF); ++ ecc_code[12] = ((val >> 8) & 0xFF); ++ ecc_code[13] = ((val >> 0) & 0xFF); ++ val = readl(gpmc_regs->gpmc_bch_result2[i]); ++ ecc_code[14] = ((val >> 24) & 0xFF); ++ ecc_code[15] = ((val >> 16) & 0xFF); ++ ecc_code[16] = ((val >> 8) & 0xFF); ++ ecc_code[17] = ((val >> 0) & 0xFF); ++ val = readl(gpmc_regs->gpmc_bch_result1[i]); ++ ecc_code[18] = ((val >> 24) & 0xFF); ++ ecc_code[19] = ((val >> 16) & 0xFF); ++ ecc_code[20] = ((val >> 8) & 0xFF); ++ ecc_code[21] = ((val >> 0) & 0xFF); ++ val = readl(gpmc_regs->gpmc_bch_result0[i]); ++ ecc_code[22] = ((val >> 24) & 0xFF); ++ ecc_code[23] = ((val >> 16) & 0xFF); ++ ecc_code[24] = ((val >> 8) & 0xFF); ++ ecc_code[25] = ((val >> 0) & 0xFF); ++ break; ++ default: ++ return -EINVAL; ++ } ++ ++ /* ECC scheme specific syndrome customizations */ ++ switch (info->ecc_opt) { ++ case OMAP_ECC_BCH4_CODE_HW_DETECTION_SW: ++ /* Add constant polynomial to remainder, so that ++ * ECC of blank pages results in 0x0 on reading back ++ */ ++ for (j = 0; j < eccbytes; j++) ++ ecc_calc[j] ^= bch4_polynomial[j]; ++ break; ++ case OMAP_ECC_BCH4_CODE_HW: ++ /* Set 8th ECC byte as 0x0 for ROM compatibility */ ++ ecc_calc[eccbytes - 1] = 0x0; ++ break; ++ case OMAP_ECC_BCH8_CODE_HW_DETECTION_SW: ++ /* Add constant polynomial to remainder, so that ++ * ECC of blank pages results in 0x0 on reading back ++ */ ++ for (j = 0; j < eccbytes; j++) ++ ecc_calc[j] ^= bch8_polynomial[j]; ++ break; ++ case OMAP_ECC_BCH8_CODE_HW: ++ /* Set 14th ECC byte as 0x0 for ROM compatibility */ ++ ecc_calc[eccbytes - 1] = 0x0; ++ break; ++ case OMAP_ECC_BCH16_CODE_HW: ++ break; ++ default: ++ return -EINVAL; ++ } ++ ++ return 0; ++} ++ ++/** ++ * omap_calculate_ecc_bch_sw - ECC generator for sector for SW based correction ++ * @mtd: MTD device structure ++ * @dat: The pointer to data on which ecc is computed ++ * @ecc_code: The ecc_code buffer ++ * ++ * Support calculating of BCH4/8/16 ECC vectors for one sector. This is used ++ * when SW based correction is required as ECC is required for one sector ++ * at a time. ++ */ ++static int omap_calculate_ecc_bch_sw(struct mtd_info *mtd, ++ const u_char *dat, u_char *ecc_calc) ++{ ++ return _omap_calculate_ecc_bch(mtd, dat, ecc_calc, 0); ++} ++ ++/** ++ * omap_calculate_ecc_bch_multi - Generate ECC for multiple sectors ++ * @mtd: MTD device structure ++ * @dat: The pointer to data on which ecc is computed ++ * @ecc_code: The ecc_code buffer ++ * ++ * Support calculating of BCH4/8/16 ecc vectors for the entire page in one go. ++ */ ++static int omap_calculate_ecc_bch_multi(struct mtd_info *mtd, ++ const u_char *dat, u_char *ecc_calc) ++{ ++ struct omap_nand_info *info = mtd_to_omap(mtd); ++ int eccbytes = info->nand.ecc.bytes; ++ unsigned long nsectors; ++ int i, ret; + + nsectors = ((readl(info->reg.gpmc_ecc_config) >> 4) & 0x7) + 1; + for (i = 0; i < nsectors; i++) { +- ecc_code = ecc_calc; +- switch (info->ecc_opt) { +- case OMAP_ECC_BCH8_CODE_HW_DETECTION_SW: +- case OMAP_ECC_BCH8_CODE_HW: +- bch_val1 = readl(gpmc_regs->gpmc_bch_result0[i]); +- bch_val2 = readl(gpmc_regs->gpmc_bch_result1[i]); +- bch_val3 = readl(gpmc_regs->gpmc_bch_result2[i]); +- bch_val4 = readl(gpmc_regs->gpmc_bch_result3[i]); +- *ecc_code++ = (bch_val4 & 0xFF); +- *ecc_code++ = ((bch_val3 >> 24) & 0xFF); +- *ecc_code++ = ((bch_val3 >> 16) & 0xFF); +- *ecc_code++ = ((bch_val3 >> 8) & 0xFF); +- *ecc_code++ = (bch_val3 & 0xFF); +- *ecc_code++ = ((bch_val2 >> 24) & 0xFF); +- *ecc_code++ = ((bch_val2 >> 16) & 0xFF); +- *ecc_code++ = ((bch_val2 >> 8) & 0xFF); +- *ecc_code++ = (bch_val2 & 0xFF); +- *ecc_code++ = ((bch_val1 >> 24) & 0xFF); +- *ecc_code++ = ((bch_val1 >> 16) & 0xFF); +- *ecc_code++ = ((bch_val1 >> 8) & 0xFF); +- *ecc_code++ = (bch_val1 & 0xFF); +- break; +- case OMAP_ECC_BCH4_CODE_HW_DETECTION_SW: +- case OMAP_ECC_BCH4_CODE_HW: +- bch_val1 = readl(gpmc_regs->gpmc_bch_result0[i]); +- bch_val2 = readl(gpmc_regs->gpmc_bch_result1[i]); +- *ecc_code++ = ((bch_val2 >> 12) & 0xFF); +- *ecc_code++ = ((bch_val2 >> 4) & 0xFF); +- *ecc_code++ = ((bch_val2 & 0xF) << 4) | +- ((bch_val1 >> 28) & 0xF); +- *ecc_code++ = ((bch_val1 >> 20) & 0xFF); +- *ecc_code++ = ((bch_val1 >> 12) & 0xFF); +- *ecc_code++ = ((bch_val1 >> 4) & 0xFF); +- *ecc_code++ = ((bch_val1 & 0xF) << 4); +- break; +- case OMAP_ECC_BCH16_CODE_HW: +- val = readl(gpmc_regs->gpmc_bch_result6[i]); +- ecc_code[0] = ((val >> 8) & 0xFF); +- ecc_code[1] = ((val >> 0) & 0xFF); +- val = readl(gpmc_regs->gpmc_bch_result5[i]); +- ecc_code[2] = ((val >> 24) & 0xFF); +- ecc_code[3] = ((val >> 16) & 0xFF); +- ecc_code[4] = ((val >> 8) & 0xFF); +- ecc_code[5] = ((val >> 0) & 0xFF); +- val = readl(gpmc_regs->gpmc_bch_result4[i]); +- ecc_code[6] = ((val >> 24) & 0xFF); +- ecc_code[7] = ((val >> 16) & 0xFF); +- ecc_code[8] = ((val >> 8) & 0xFF); +- ecc_code[9] = ((val >> 0) & 0xFF); +- val = readl(gpmc_regs->gpmc_bch_result3[i]); +- ecc_code[10] = ((val >> 24) & 0xFF); +- ecc_code[11] = ((val >> 16) & 0xFF); +- ecc_code[12] = ((val >> 8) & 0xFF); +- ecc_code[13] = ((val >> 0) & 0xFF); +- val = readl(gpmc_regs->gpmc_bch_result2[i]); +- ecc_code[14] = ((val >> 24) & 0xFF); +- ecc_code[15] = ((val >> 16) & 0xFF); +- ecc_code[16] = ((val >> 8) & 0xFF); +- ecc_code[17] = ((val >> 0) & 0xFF); +- val = readl(gpmc_regs->gpmc_bch_result1[i]); +- ecc_code[18] = ((val >> 24) & 0xFF); +- ecc_code[19] = ((val >> 16) & 0xFF); +- ecc_code[20] = ((val >> 8) & 0xFF); +- ecc_code[21] = ((val >> 0) & 0xFF); +- val = readl(gpmc_regs->gpmc_bch_result0[i]); +- ecc_code[22] = ((val >> 24) & 0xFF); +- ecc_code[23] = ((val >> 16) & 0xFF); +- ecc_code[24] = ((val >> 8) & 0xFF); +- ecc_code[25] = ((val >> 0) & 0xFF); +- break; +- default: +- return -EINVAL; +- } +- +- /* ECC scheme specific syndrome customizations */ +- switch (info->ecc_opt) { +- case OMAP_ECC_BCH4_CODE_HW_DETECTION_SW: +- /* Add constant polynomial to remainder, so that +- * ECC of blank pages results in 0x0 on reading back */ +- for (j = 0; j < eccbytes; j++) +- ecc_calc[j] ^= bch4_polynomial[j]; +- break; +- case OMAP_ECC_BCH4_CODE_HW: +- /* Set 8th ECC byte as 0x0 for ROM compatibility */ +- ecc_calc[eccbytes - 1] = 0x0; +- break; +- case OMAP_ECC_BCH8_CODE_HW_DETECTION_SW: +- /* Add constant polynomial to remainder, so that +- * ECC of blank pages results in 0x0 on reading back */ +- for (j = 0; j < eccbytes; j++) +- ecc_calc[j] ^= bch8_polynomial[j]; +- break; +- case OMAP_ECC_BCH8_CODE_HW: +- /* Set 14th ECC byte as 0x0 for ROM compatibility */ +- ecc_calc[eccbytes - 1] = 0x0; +- break; +- case OMAP_ECC_BCH16_CODE_HW: +- break; +- default: +- return -EINVAL; +- } ++ ret = _omap_calculate_ecc_bch(mtd, dat, ecc_calc, i); ++ if (ret) ++ return ret; + +- ecc_calc += eccbytes; ++ ecc_calc += eccbytes; + } + + return 0; +@@ -1496,7 +1539,7 @@ static int omap_write_page_bch(struct mtd_info *mtd, struct nand_chip *chip, + chip->write_buf(mtd, buf, mtd->writesize); + + /* Update ecc vector from GPMC result registers */ +- chip->ecc.calculate(mtd, buf, &ecc_calc[0]); ++ omap_calculate_ecc_bch_multi(mtd, buf, &ecc_calc[0]); + + ret = mtd_ooblayout_set_eccbytes(mtd, ecc_calc, chip->oob_poi, 0, + chip->ecc.total); +@@ -1508,6 +1551,72 @@ static int omap_write_page_bch(struct mtd_info *mtd, struct nand_chip *chip, + return 0; + } + ++/** ++ * omap_write_subpage_bch - BCH hardware ECC based subpage write ++ * @mtd: mtd info structure ++ * @chip: nand chip info structure ++ * @offset: column address of subpage within the page ++ * @data_len: data length ++ * @buf: data buffer ++ * @oob_required: must write chip->oob_poi to OOB ++ * @page: page number to write ++ * ++ * OMAP optimized subpage write method. ++ */ ++static int omap_write_subpage_bch(struct mtd_info *mtd, ++ struct nand_chip *chip, u32 offset, ++ u32 data_len, const u8 *buf, ++ int oob_required, int page) ++{ ++ u8 *ecc_calc = chip->buffers->ecccalc; ++ int ecc_size = chip->ecc.size; ++ int ecc_bytes = chip->ecc.bytes; ++ int ecc_steps = chip->ecc.steps; ++ u32 start_step = offset / ecc_size; ++ u32 end_step = (offset + data_len - 1) / ecc_size; ++ int step, ret = 0; ++ ++ /* ++ * Write entire page at one go as it would be optimal ++ * as ECC is calculated by hardware. ++ * ECC is calculated for all subpages but we choose ++ * only what we want. ++ */ ++ ++ /* Enable GPMC ECC engine */ ++ chip->ecc.hwctl(mtd, NAND_ECC_WRITE); ++ ++ /* Write data */ ++ chip->write_buf(mtd, buf, mtd->writesize); ++ ++ for (step = 0; step < ecc_steps; step++) { ++ /* mask ECC of un-touched subpages by padding 0xFF */ ++ if (step < start_step || step > end_step) ++ memset(ecc_calc, 0xff, ecc_bytes); ++ else ++ ret = _omap_calculate_ecc_bch(mtd, buf, ecc_calc, step); ++ ++ if (ret) ++ return ret; ++ ++ buf += ecc_size; ++ ecc_calc += ecc_bytes; ++ } ++ ++ /* copy calculated ECC for whole page to chip->buffer->oob */ ++ /* this include masked-value(0xFF) for unwritten subpages */ ++ ecc_calc = chip->buffers->ecccalc; ++ ret = mtd_ooblayout_set_eccbytes(mtd, ecc_calc, chip->oob_poi, 0, ++ chip->ecc.total); ++ if (ret) ++ return ret; ++ ++ /* write OOB buffer to NAND device */ ++ chip->write_buf(mtd, chip->oob_poi, mtd->oobsize); ++ ++ return 0; ++} ++ + /** + * omap_read_page_bch - BCH ecc based page read function for entire page + * @mtd: mtd info structure +@@ -1544,7 +1653,7 @@ static int omap_read_page_bch(struct mtd_info *mtd, struct nand_chip *chip, + chip->ecc.total); + + /* Calculate ecc bytes */ +- chip->ecc.calculate(mtd, buf, ecc_calc); ++ omap_calculate_ecc_bch_multi(mtd, buf, ecc_calc); + + ret = mtd_ooblayout_get_eccbytes(mtd, ecc_code, chip->oob_poi, 0, + chip->ecc.total); +@@ -2044,7 +2153,7 @@ static int omap_nand_probe(struct platform_device *pdev) + nand_chip->ecc.strength = 4; + nand_chip->ecc.hwctl = omap_enable_hwecc_bch; + nand_chip->ecc.correct = nand_bch_correct_data; +- nand_chip->ecc.calculate = omap_calculate_ecc_bch; ++ nand_chip->ecc.calculate = omap_calculate_ecc_bch_sw; + mtd_set_ooblayout(mtd, &omap_sw_ooblayout_ops); + /* Reserve one byte for the OMAP marker */ + oobbytes_per_step = nand_chip->ecc.bytes + 1; +@@ -2066,9 +2175,9 @@ static int omap_nand_probe(struct platform_device *pdev) + nand_chip->ecc.strength = 4; + nand_chip->ecc.hwctl = omap_enable_hwecc_bch; + nand_chip->ecc.correct = omap_elm_correct_data; +- nand_chip->ecc.calculate = omap_calculate_ecc_bch; + nand_chip->ecc.read_page = omap_read_page_bch; + nand_chip->ecc.write_page = omap_write_page_bch; ++ nand_chip->ecc.write_subpage = omap_write_subpage_bch; + mtd_set_ooblayout(mtd, &omap_ooblayout_ops); + oobbytes_per_step = nand_chip->ecc.bytes; + +@@ -2087,7 +2196,7 @@ static int omap_nand_probe(struct platform_device *pdev) + nand_chip->ecc.strength = 8; + nand_chip->ecc.hwctl = omap_enable_hwecc_bch; + nand_chip->ecc.correct = nand_bch_correct_data; +- nand_chip->ecc.calculate = omap_calculate_ecc_bch; ++ nand_chip->ecc.calculate = omap_calculate_ecc_bch_sw; + mtd_set_ooblayout(mtd, &omap_sw_ooblayout_ops); + /* Reserve one byte for the OMAP marker */ + oobbytes_per_step = nand_chip->ecc.bytes + 1; +@@ -2109,9 +2218,9 @@ static int omap_nand_probe(struct platform_device *pdev) + nand_chip->ecc.strength = 8; + nand_chip->ecc.hwctl = omap_enable_hwecc_bch; + nand_chip->ecc.correct = omap_elm_correct_data; +- nand_chip->ecc.calculate = omap_calculate_ecc_bch; + nand_chip->ecc.read_page = omap_read_page_bch; + nand_chip->ecc.write_page = omap_write_page_bch; ++ nand_chip->ecc.write_subpage = omap_write_subpage_bch; + mtd_set_ooblayout(mtd, &omap_ooblayout_ops); + oobbytes_per_step = nand_chip->ecc.bytes; + +@@ -2131,9 +2240,9 @@ static int omap_nand_probe(struct platform_device *pdev) + nand_chip->ecc.strength = 16; + nand_chip->ecc.hwctl = omap_enable_hwecc_bch; + nand_chip->ecc.correct = omap_elm_correct_data; +- nand_chip->ecc.calculate = omap_calculate_ecc_bch; + nand_chip->ecc.read_page = omap_read_page_bch; + nand_chip->ecc.write_page = omap_write_page_bch; ++ nand_chip->ecc.write_subpage = omap_write_subpage_bch; + mtd_set_ooblayout(mtd, &omap_ooblayout_ops); + oobbytes_per_step = nand_chip->ecc.bytes; + +diff --git a/drivers/mtd/spi-nor/intel-spi.c b/drivers/mtd/spi-nor/intel-spi.c +index 8a596bfeddff..7802ac3ba934 100644 +--- a/drivers/mtd/spi-nor/intel-spi.c ++++ b/drivers/mtd/spi-nor/intel-spi.c +@@ -422,7 +422,7 @@ static int intel_spi_sw_cycle(struct intel_spi *ispi, u8 opcode, u8 *buf, + if (ret < 0) + return ret; + +- val = (len << SSFSTS_CTL_DBC_SHIFT) | SSFSTS_CTL_DS; ++ val = ((len - 1) << SSFSTS_CTL_DBC_SHIFT) | SSFSTS_CTL_DS; + val |= ret << SSFSTS_CTL_COP_SHIFT; + val |= SSFSTS_CTL_FCERR | SSFSTS_CTL_FDONE; + val |= SSFSTS_CTL_SCGO; +@@ -432,7 +432,7 @@ static int intel_spi_sw_cycle(struct intel_spi *ispi, u8 opcode, u8 *buf, + if (ret) + return ret; + +- status = readl(ispi->base + SSFSTS_CTL); ++ status = readl(ispi->sregs + SSFSTS_CTL); + if (status & SSFSTS_CTL_FCERR) + return -EIO; + else if (status & SSFSTS_CTL_AEL) +diff --git a/drivers/net/ethernet/intel/e1000e/defines.h b/drivers/net/ethernet/intel/e1000e/defines.h +index 0641c0098738..afb7ebe20b24 100644 +--- a/drivers/net/ethernet/intel/e1000e/defines.h ++++ b/drivers/net/ethernet/intel/e1000e/defines.h +@@ -398,6 +398,7 @@ + #define E1000_ICR_LSC 0x00000004 /* Link Status Change */ + #define E1000_ICR_RXSEQ 0x00000008 /* Rx sequence error */ + #define E1000_ICR_RXDMT0 0x00000010 /* Rx desc min. threshold (0) */ ++#define E1000_ICR_RXO 0x00000040 /* Receiver Overrun */ + #define E1000_ICR_RXT0 0x00000080 /* Rx timer intr (ring 0) */ + #define E1000_ICR_ECCER 0x00400000 /* Uncorrectable ECC Error */ + /* If this bit asserted, the driver should claim the interrupt */ +diff --git a/drivers/net/ethernet/intel/e1000e/mac.c b/drivers/net/ethernet/intel/e1000e/mac.c +index b322011ec282..f457c5703d0c 100644 +--- a/drivers/net/ethernet/intel/e1000e/mac.c ++++ b/drivers/net/ethernet/intel/e1000e/mac.c +@@ -410,6 +410,9 @@ void e1000e_clear_hw_cntrs_base(struct e1000_hw *hw) + * Checks to see of the link status of the hardware has changed. If a + * change in link status has been detected, then we read the PHY registers + * to get the current speed/duplex if link exists. ++ * ++ * Returns a negative error code (-E1000_ERR_*) or 0 (link down) or 1 (link ++ * up). + **/ + s32 e1000e_check_for_copper_link(struct e1000_hw *hw) + { +@@ -423,7 +426,7 @@ s32 e1000e_check_for_copper_link(struct e1000_hw *hw) + * Change or Rx Sequence Error interrupt. + */ + if (!mac->get_link_status) +- return 0; ++ return 1; + + /* First we want to see if the MII Status Register reports + * link. If so, then we want to get the current speed/duplex +@@ -461,10 +464,12 @@ s32 e1000e_check_for_copper_link(struct e1000_hw *hw) + * different link partner. + */ + ret_val = e1000e_config_fc_after_link_up(hw); +- if (ret_val) ++ if (ret_val) { + e_dbg("Error configuring flow control\n"); ++ return ret_val; ++ } + +- return ret_val; ++ return 1; + } + + /** +diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c +index 327dfe5bedc0..c38b00c90f48 100644 +--- a/drivers/net/ethernet/intel/e1000e/netdev.c ++++ b/drivers/net/ethernet/intel/e1000e/netdev.c +@@ -1910,14 +1910,30 @@ static irqreturn_t e1000_msix_other(int __always_unused irq, void *data) + struct net_device *netdev = data; + struct e1000_adapter *adapter = netdev_priv(netdev); + struct e1000_hw *hw = &adapter->hw; ++ u32 icr; ++ bool enable = true; ++ ++ icr = er32(ICR); ++ if (icr & E1000_ICR_RXO) { ++ ew32(ICR, E1000_ICR_RXO); ++ enable = false; ++ /* napi poll will re-enable Other, make sure it runs */ ++ if (napi_schedule_prep(&adapter->napi)) { ++ adapter->total_rx_bytes = 0; ++ adapter->total_rx_packets = 0; ++ __napi_schedule(&adapter->napi); ++ } ++ } ++ if (icr & E1000_ICR_LSC) { ++ ew32(ICR, E1000_ICR_LSC); ++ hw->mac.get_link_status = true; ++ /* guard against interrupt when we're going down */ ++ if (!test_bit(__E1000_DOWN, &adapter->state)) ++ mod_timer(&adapter->watchdog_timer, jiffies + 1); ++ } + +- hw->mac.get_link_status = true; +- +- /* guard against interrupt when we're going down */ +- if (!test_bit(__E1000_DOWN, &adapter->state)) { +- mod_timer(&adapter->watchdog_timer, jiffies + 1); ++ if (enable && !test_bit(__E1000_DOWN, &adapter->state)) + ew32(IMS, E1000_IMS_OTHER); +- } + + return IRQ_HANDLED; + } +@@ -2687,7 +2703,8 @@ static int e1000e_poll(struct napi_struct *napi, int weight) + napi_complete_done(napi, work_done); + if (!test_bit(__E1000_DOWN, &adapter->state)) { + if (adapter->msix_entries) +- ew32(IMS, adapter->rx_ring->ims_val); ++ ew32(IMS, adapter->rx_ring->ims_val | ++ E1000_IMS_OTHER); + else + e1000_irq_enable(adapter); + } +@@ -3004,8 +3021,8 @@ static void e1000_configure_tx(struct e1000_adapter *adapter) + + hw->mac.ops.config_collision_dist(hw); + +- /* SPT and CNP Si errata workaround to avoid data corruption */ +- if (hw->mac.type >= e1000_pch_spt) { ++ /* SPT and KBL Si errata workaround to avoid data corruption */ ++ if (hw->mac.type == e1000_pch_spt) { + u32 reg_val; + + reg_val = er32(IOSFPC); +@@ -3013,7 +3030,9 @@ static void e1000_configure_tx(struct e1000_adapter *adapter) + ew32(IOSFPC, reg_val); + + reg_val = er32(TARC(0)); +- reg_val |= E1000_TARC0_CB_MULTIQ_3_REQ; ++ /* SPT and KBL Si errata workaround to avoid Tx hang */ ++ reg_val &= ~BIT(28); ++ reg_val |= BIT(29); + ew32(TARC(0), reg_val); + } + } +@@ -4204,7 +4223,7 @@ static void e1000e_trigger_lsc(struct e1000_adapter *adapter) + struct e1000_hw *hw = &adapter->hw; + + if (adapter->msix_entries) +- ew32(ICS, E1000_ICS_OTHER); ++ ew32(ICS, E1000_ICS_LSC | E1000_ICS_OTHER); + else + ew32(ICS, E1000_ICS_LSC); + } +@@ -5081,7 +5100,7 @@ static bool e1000e_has_link(struct e1000_adapter *adapter) + case e1000_media_type_copper: + if (hw->mac.get_link_status) { + ret_val = hw->mac.ops.check_for_link(hw); +- link_active = !hw->mac.get_link_status; ++ link_active = ret_val > 0; + } else { + link_active = true; + } +@@ -5099,7 +5118,7 @@ static bool e1000e_has_link(struct e1000_adapter *adapter) + break; + } + +- if ((ret_val == E1000_ERR_PHY) && (hw->phy.type == e1000_phy_igp_3) && ++ if ((ret_val == -E1000_ERR_PHY) && (hw->phy.type == e1000_phy_igp_3) && + (er32(CTRL) & E1000_PHY_CTRL_GBE_DISABLE)) { + /* See e1000_kmrn_lock_loss_workaround_ich8lan() */ + e_info("Gigabit has been disabled, downgrading speed\n"); +diff --git a/drivers/net/ethernet/intel/e1000e/phy.c b/drivers/net/ethernet/intel/e1000e/phy.c +index d78d47b41a71..86ff0969efb6 100644 +--- a/drivers/net/ethernet/intel/e1000e/phy.c ++++ b/drivers/net/ethernet/intel/e1000e/phy.c +@@ -1744,6 +1744,7 @@ s32 e1000e_phy_has_link_generic(struct e1000_hw *hw, u32 iterations, + s32 ret_val = 0; + u16 i, phy_status; + ++ *success = false; + for (i = 0; i < iterations; i++) { + /* Some PHYs require the MII_BMSR register to be read + * twice due to the link bit being sticky. No harm doing +@@ -1763,16 +1764,16 @@ s32 e1000e_phy_has_link_generic(struct e1000_hw *hw, u32 iterations, + ret_val = e1e_rphy(hw, MII_BMSR, &phy_status); + if (ret_val) + break; +- if (phy_status & BMSR_LSTATUS) ++ if (phy_status & BMSR_LSTATUS) { ++ *success = true; + break; ++ } + if (usec_interval >= 1000) + msleep(usec_interval / 1000); + else + udelay(usec_interval); + } + +- *success = (i < iterations); +- + return ret_val; + } + +diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_main.c b/drivers/net/ethernet/intel/fm10k/fm10k_main.c +index 9dffaba85ae6..103c0a742d03 100644 +--- a/drivers/net/ethernet/intel/fm10k/fm10k_main.c ++++ b/drivers/net/ethernet/intel/fm10k/fm10k_main.c +@@ -1229,7 +1229,7 @@ static bool fm10k_clean_tx_irq(struct fm10k_q_vector *q_vector, + break; + + /* prevent any other reads prior to eop_desc */ +- read_barrier_depends(); ++ smp_rmb(); + + /* if DD is not set pending work has not been completed */ + if (!(eop_desc->flags & FM10K_TXD_FLAG_DONE)) +diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c +index 6498da8806cb..ea20aacd5e1d 100644 +--- a/drivers/net/ethernet/intel/i40e/i40e_main.c ++++ b/drivers/net/ethernet/intel/i40e/i40e_main.c +@@ -3760,7 +3760,7 @@ static bool i40e_clean_fdir_tx_irq(struct i40e_ring *tx_ring, int budget) + break; + + /* prevent any other reads prior to eop_desc */ +- read_barrier_depends(); ++ smp_rmb(); + + /* if the descriptor isn't done, no work yet to do */ + if (!(eop_desc->cmd_type_offset_bsz & +diff --git a/drivers/net/ethernet/intel/i40e/i40e_txrx.c b/drivers/net/ethernet/intel/i40e/i40e_txrx.c +index 120c68f78951..3c07ff171ddc 100644 +--- a/drivers/net/ethernet/intel/i40e/i40e_txrx.c ++++ b/drivers/net/ethernet/intel/i40e/i40e_txrx.c +@@ -759,7 +759,7 @@ static bool i40e_clean_tx_irq(struct i40e_vsi *vsi, + break; + + /* prevent any other reads prior to eop_desc */ +- read_barrier_depends(); ++ smp_rmb(); + + i40e_trace(clean_tx_irq, tx_ring, tx_desc, tx_buf); + /* we have caught up to head, no work left to do */ +diff --git a/drivers/net/ethernet/intel/i40evf/i40e_txrx.c b/drivers/net/ethernet/intel/i40evf/i40e_txrx.c +index c32c62462c84..07a4e6e13925 100644 +--- a/drivers/net/ethernet/intel/i40evf/i40e_txrx.c ++++ b/drivers/net/ethernet/intel/i40evf/i40e_txrx.c +@@ -179,7 +179,7 @@ static bool i40e_clean_tx_irq(struct i40e_vsi *vsi, + break; + + /* prevent any other reads prior to eop_desc */ +- read_barrier_depends(); ++ smp_rmb(); + + i40e_trace(clean_tx_irq, tx_ring, tx_desc, tx_buf); + /* if the descriptor isn't done, no work yet to do */ +diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c +index ea69af267d63..b0031c5ff767 100644 +--- a/drivers/net/ethernet/intel/igb/igb_main.c ++++ b/drivers/net/ethernet/intel/igb/igb_main.c +@@ -6970,7 +6970,7 @@ static bool igb_clean_tx_irq(struct igb_q_vector *q_vector, int napi_budget) + break; + + /* prevent any other reads prior to eop_desc */ +- read_barrier_depends(); ++ smp_rmb(); + + /* if DD is not set pending work has not been completed */ + if (!(eop_desc->wb.status & cpu_to_le32(E1000_TXD_STAT_DD))) +diff --git a/drivers/net/ethernet/intel/igbvf/netdev.c b/drivers/net/ethernet/intel/igbvf/netdev.c +index 1ed556911b14..6f5888bd9194 100644 +--- a/drivers/net/ethernet/intel/igbvf/netdev.c ++++ b/drivers/net/ethernet/intel/igbvf/netdev.c +@@ -810,7 +810,7 @@ static bool igbvf_clean_tx_irq(struct igbvf_ring *tx_ring) + break; + + /* prevent any other reads prior to eop_desc */ +- read_barrier_depends(); ++ smp_rmb(); + + /* if DD is not set pending work has not been completed */ + if (!(eop_desc->wb.status & cpu_to_le32(E1000_TXD_STAT_DD))) +diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c +index 6d5f31e94358..879a9c4cef59 100644 +--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c ++++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c +@@ -1192,7 +1192,7 @@ static bool ixgbe_clean_tx_irq(struct ixgbe_q_vector *q_vector, + break; + + /* prevent any other reads prior to eop_desc */ +- read_barrier_depends(); ++ smp_rmb(); + + /* if DD is not set pending work has not been completed */ + if (!(eop_desc->wb.status & cpu_to_le32(IXGBE_TXD_STAT_DD))) +diff --git a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c +index 032f8ac06357..90ecc4b06462 100644 +--- a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c ++++ b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c +@@ -326,7 +326,7 @@ static bool ixgbevf_clean_tx_irq(struct ixgbevf_q_vector *q_vector, + break; + + /* prevent any other reads prior to eop_desc */ +- read_barrier_depends(); ++ smp_rmb(); + + /* if DD is not set pending work has not been completed */ + if (!(eop_desc->wb.status & cpu_to_le32(IXGBE_TXD_STAT_DD))) +diff --git a/drivers/net/ethernet/marvell/mvneta.c b/drivers/net/ethernet/marvell/mvneta.c +index 64a04975bcf8..bc93b69cfd1e 100644 +--- a/drivers/net/ethernet/marvell/mvneta.c ++++ b/drivers/net/ethernet/marvell/mvneta.c +@@ -816,11 +816,14 @@ static void mvneta_txq_pend_desc_add(struct mvneta_port *pp, + { + u32 val; + +- /* Only 255 descriptors can be added at once ; Assume caller +- * process TX desriptors in quanta less than 256 +- */ +- val = pend_desc + txq->pending; +- mvreg_write(pp, MVNETA_TXQ_UPDATE_REG(txq->id), val); ++ pend_desc += txq->pending; ++ ++ /* Only 255 Tx descriptors can be added at once */ ++ do { ++ val = min(pend_desc, 255); ++ mvreg_write(pp, MVNETA_TXQ_UPDATE_REG(txq->id), val); ++ pend_desc -= val; ++ } while (pend_desc > 0); + txq->pending = 0; + } + +diff --git a/drivers/net/wireless/intel/iwlwifi/cfg/9000.c b/drivers/net/wireless/intel/iwlwifi/cfg/9000.c +index e8b5ff42f5a8..c8e7b54a538a 100644 +--- a/drivers/net/wireless/intel/iwlwifi/cfg/9000.c ++++ b/drivers/net/wireless/intel/iwlwifi/cfg/9000.c +@@ -72,18 +72,21 @@ + #define IWL9000_SMEM_OFFSET 0x400000 + #define IWL9000_SMEM_LEN 0x68000 + +-#define IWL9000_FW_PRE "iwlwifi-9000-pu-a0-jf-a0-" ++#define IWL9000A_FW_PRE "iwlwifi-9000-pu-a0-jf-a0-" ++#define IWL9000B_FW_PRE "iwlwifi-9000-pu-b0-jf-b0-" + #define IWL9000RFB_FW_PRE "iwlwifi-9000-pu-a0-jf-b0-" + #define IWL9260A_FW_PRE "iwlwifi-9260-th-a0-jf-a0-" + #define IWL9260B_FW_PRE "iwlwifi-9260-th-b0-jf-b0-" +-#define IWL9000_MODULE_FIRMWARE(api) \ +- IWL9000_FW_PRE "-" __stringify(api) ".ucode" ++#define IWL9000A_MODULE_FIRMWARE(api) \ ++ IWL9000A_FW_PRE __stringify(api) ".ucode" ++#define IWL9000B_MODULE_FIRMWARE(api) \ ++ IWL9000B_FW_PRE __stringify(api) ".ucode" + #define IWL9000RFB_MODULE_FIRMWARE(api) \ +- IWL9000RFB_FW_PRE "-" __stringify(api) ".ucode" ++ IWL9000RFB_FW_PRE __stringify(api) ".ucode" + #define IWL9260A_MODULE_FIRMWARE(api) \ +- IWL9260A_FW_PRE "-" __stringify(api) ".ucode" ++ IWL9260A_FW_PRE __stringify(api) ".ucode" + #define IWL9260B_MODULE_FIRMWARE(api) \ +- IWL9260B_FW_PRE "-" __stringify(api) ".ucode" ++ IWL9260B_FW_PRE __stringify(api) ".ucode" + + #define NVM_HW_SECTION_NUM_FAMILY_9000 10 + +@@ -193,7 +196,48 @@ const struct iwl_cfg iwl9460_2ac_cfg = { + .nvm_ver = IWL9000_NVM_VERSION, + .nvm_calib_ver = IWL9000_TX_POWER_VERSION, + .max_ht_ampdu_exponent = IEEE80211_HT_MAX_AMPDU_64K, ++}; ++ ++const struct iwl_cfg iwl9460_2ac_cfg_soc = { ++ .name = "Intel(R) Dual Band Wireless AC 9460", ++ .fw_name_pre = IWL9000A_FW_PRE, ++ .fw_name_pre_b_or_c_step = IWL9000B_FW_PRE, ++ .fw_name_pre_rf_next_step = IWL9000RFB_FW_PRE, ++ IWL_DEVICE_9000, ++ .ht_params = &iwl9000_ht_params, ++ .nvm_ver = IWL9000_NVM_VERSION, ++ .nvm_calib_ver = IWL9000_TX_POWER_VERSION, ++ .max_ht_ampdu_exponent = IEEE80211_HT_MAX_AMPDU_64K, + .integrated = true, ++ .soc_latency = 5000, ++}; ++ ++const struct iwl_cfg iwl9461_2ac_cfg_soc = { ++ .name = "Intel(R) Dual Band Wireless AC 9461", ++ .fw_name_pre = IWL9000A_FW_PRE, ++ .fw_name_pre_b_or_c_step = IWL9000B_FW_PRE, ++ .fw_name_pre_rf_next_step = IWL9000RFB_FW_PRE, ++ IWL_DEVICE_9000, ++ .ht_params = &iwl9000_ht_params, ++ .nvm_ver = IWL9000_NVM_VERSION, ++ .nvm_calib_ver = IWL9000_TX_POWER_VERSION, ++ .max_ht_ampdu_exponent = IEEE80211_HT_MAX_AMPDU_64K, ++ .integrated = true, ++ .soc_latency = 5000, ++}; ++ ++const struct iwl_cfg iwl9462_2ac_cfg_soc = { ++ .name = "Intel(R) Dual Band Wireless AC 9462", ++ .fw_name_pre = IWL9000A_FW_PRE, ++ .fw_name_pre_b_or_c_step = IWL9000B_FW_PRE, ++ .fw_name_pre_rf_next_step = IWL9000RFB_FW_PRE, ++ IWL_DEVICE_9000, ++ .ht_params = &iwl9000_ht_params, ++ .nvm_ver = IWL9000_NVM_VERSION, ++ .nvm_calib_ver = IWL9000_TX_POWER_VERSION, ++ .max_ht_ampdu_exponent = IEEE80211_HT_MAX_AMPDU_64K, ++ .integrated = true, ++ .soc_latency = 5000, + }; + + const struct iwl_cfg iwl9560_2ac_cfg = { +@@ -205,10 +249,23 @@ const struct iwl_cfg iwl9560_2ac_cfg = { + .nvm_ver = IWL9000_NVM_VERSION, + .nvm_calib_ver = IWL9000_TX_POWER_VERSION, + .max_ht_ampdu_exponent = IEEE80211_HT_MAX_AMPDU_64K, +- .integrated = true, + }; + +-MODULE_FIRMWARE(IWL9000_MODULE_FIRMWARE(IWL9000_UCODE_API_MAX)); ++const struct iwl_cfg iwl9560_2ac_cfg_soc = { ++ .name = "Intel(R) Dual Band Wireless AC 9560", ++ .fw_name_pre = IWL9000A_FW_PRE, ++ .fw_name_pre_b_or_c_step = IWL9000B_FW_PRE, ++ .fw_name_pre_rf_next_step = IWL9000RFB_FW_PRE, ++ IWL_DEVICE_9000, ++ .ht_params = &iwl9000_ht_params, ++ .nvm_ver = IWL9000_NVM_VERSION, ++ .nvm_calib_ver = IWL9000_TX_POWER_VERSION, ++ .max_ht_ampdu_exponent = IEEE80211_HT_MAX_AMPDU_64K, ++ .integrated = true, ++ .soc_latency = 5000, ++}; ++MODULE_FIRMWARE(IWL9000A_MODULE_FIRMWARE(IWL9000_UCODE_API_MAX)); ++MODULE_FIRMWARE(IWL9000B_MODULE_FIRMWARE(IWL9000_UCODE_API_MAX)); + MODULE_FIRMWARE(IWL9000RFB_MODULE_FIRMWARE(IWL9000_UCODE_API_MAX)); + MODULE_FIRMWARE(IWL9260A_MODULE_FIRMWARE(IWL9000_UCODE_API_MAX)); + MODULE_FIRMWARE(IWL9260B_MODULE_FIRMWARE(IWL9000_UCODE_API_MAX)); +diff --git a/drivers/net/wireless/intel/iwlwifi/cfg/a000.c b/drivers/net/wireless/intel/iwlwifi/cfg/a000.c +index a440140ed8dd..7eade165b747 100644 +--- a/drivers/net/wireless/intel/iwlwifi/cfg/a000.c ++++ b/drivers/net/wireless/intel/iwlwifi/cfg/a000.c +@@ -80,15 +80,15 @@ + #define IWL_A000_HR_A0_FW_PRE "iwlwifi-QuQnj-a0-hr-a0-" + + #define IWL_A000_HR_MODULE_FIRMWARE(api) \ +- IWL_A000_HR_FW_PRE "-" __stringify(api) ".ucode" ++ IWL_A000_HR_FW_PRE __stringify(api) ".ucode" + #define IWL_A000_JF_MODULE_FIRMWARE(api) \ +- IWL_A000_JF_FW_PRE "-" __stringify(api) ".ucode" ++ IWL_A000_JF_FW_PRE __stringify(api) ".ucode" + #define IWL_A000_HR_F0_QNJ_MODULE_FIRMWARE(api) \ +- IWL_A000_HR_F0_FW_PRE "-" __stringify(api) ".ucode" ++ IWL_A000_HR_F0_FW_PRE __stringify(api) ".ucode" + #define IWL_A000_JF_B0_QNJ_MODULE_FIRMWARE(api) \ +- IWL_A000_JF_B0_FW_PRE "-" __stringify(api) ".ucode" ++ IWL_A000_JF_B0_FW_PRE __stringify(api) ".ucode" + #define IWL_A000_HR_A0_QNJ_MODULE_FIRMWARE(api) \ +- IWL_A000_HR_A0_FW_PRE "-" __stringify(api) ".ucode" ++ IWL_A000_HR_A0_FW_PRE __stringify(api) ".ucode" + + #define NVM_HW_SECTION_NUM_FAMILY_A000 10 + +diff --git a/drivers/net/wireless/intel/iwlwifi/fw/api/scan.h b/drivers/net/wireless/intel/iwlwifi/fw/api/scan.h +index 5a40092febfb..3bfc657f6b42 100644 +--- a/drivers/net/wireless/intel/iwlwifi/fw/api/scan.h ++++ b/drivers/net/wireless/intel/iwlwifi/fw/api/scan.h +@@ -531,6 +531,8 @@ struct iwl_scan_config_v1 { + } __packed; /* SCAN_CONFIG_DB_CMD_API_S */ + + #define SCAN_TWO_LMACS 2 ++#define SCAN_LB_LMAC_IDX 0 ++#define SCAN_HB_LMAC_IDX 1 + + struct iwl_scan_config { + __le32 flags; +@@ -578,6 +580,7 @@ enum iwl_umac_scan_general_flags { + IWL_UMAC_SCAN_GEN_FLAGS_MATCH = BIT(9), + IWL_UMAC_SCAN_GEN_FLAGS_EXTENDED_DWELL = BIT(10), + IWL_UMAC_SCAN_GEN_FLAGS_LMAC2_FRAGMENTED = BIT(11), ++ IWL_UMAC_SCAN_GEN_FLAGS_ADAPTIVE_DWELL = BIT(13), + }; + + /** +@@ -631,12 +634,17 @@ struct iwl_scan_req_umac_tail { + * @uid: scan id, &enum iwl_umac_scan_uid_offsets + * @ooc_priority: out of channel priority - &enum iwl_scan_priority + * @general_flags: &enum iwl_umac_scan_general_flags +- * @reserved2: for future use and alignment + * @scan_start_mac_id: report the scan start TSF time according to this mac TSF + * @extended_dwell: dwell time for channels 1, 6 and 11 + * @active_dwell: dwell time for active scan + * @passive_dwell: dwell time for passive scan + * @fragmented_dwell: dwell time for fragmented passive scan ++ * @adwell_default_n_aps: for adaptive dwell the default number of APs ++ * per channel ++ * @adwell_default_n_aps_social: for adaptive dwell the default ++ * number of APs per social (1,6,11) channel ++ * @adwell_max_budget: for adaptive dwell the maximal budget of TU to be added ++ * to total scan time + * @max_out_time: max out of serving channel time, per LMAC - for CDB there + * are 2 LMACs + * @suspend_time: max suspend time, per LMAC - for CDB there are 2 LMACs +@@ -644,6 +652,8 @@ struct iwl_scan_req_umac_tail { + * @channel_flags: &enum iwl_scan_channel_flags + * @n_channels: num of channels in scan request + * @reserved: for future use and alignment ++ * @reserved2: for future use and alignment ++ * @reserved3: for future use and alignment + * @data: &struct iwl_scan_channel_cfg_umac and + * &struct iwl_scan_req_umac_tail + */ +@@ -651,41 +661,64 @@ struct iwl_scan_req_umac { + __le32 flags; + __le32 uid; + __le32 ooc_priority; +- /* SCAN_GENERAL_PARAMS_API_S_VER_4 */ + __le16 general_flags; +- u8 reserved2; ++ u8 reserved; + u8 scan_start_mac_id; +- u8 extended_dwell; +- u8 active_dwell; +- u8 passive_dwell; +- u8 fragmented_dwell; + union { + struct { ++ u8 extended_dwell; ++ u8 active_dwell; ++ u8 passive_dwell; ++ u8 fragmented_dwell; + __le32 max_out_time; + __le32 suspend_time; + __le32 scan_priority; +- /* SCAN_CHANNEL_PARAMS_API_S_VER_4 */ ++ /* SCAN_CHANNEL_PARAMS_API_S_VER_1 */ + u8 channel_flags; + u8 n_channels; +- __le16 reserved; ++ __le16 reserved2; + u8 data[]; + } v1; /* SCAN_REQUEST_CMD_UMAC_API_S_VER_1 */ + struct { ++ u8 extended_dwell; ++ u8 active_dwell; ++ u8 passive_dwell; ++ u8 fragmented_dwell; + __le32 max_out_time[SCAN_TWO_LMACS]; + __le32 suspend_time[SCAN_TWO_LMACS]; + __le32 scan_priority; +- /* SCAN_CHANNEL_PARAMS_API_S_VER_4 */ ++ /* SCAN_CHANNEL_PARAMS_API_S_VER_1 */ + u8 channel_flags; + u8 n_channels; +- __le16 reserved; ++ __le16 reserved2; + u8 data[]; + } v6; /* SCAN_REQUEST_CMD_UMAC_API_S_VER_6 */ ++ struct { ++ u8 active_dwell; ++ u8 passive_dwell; ++ u8 fragmented_dwell; ++ u8 adwell_default_n_aps; ++ u8 adwell_default_n_aps_social; ++ u8 reserved3; ++ __le16 adwell_max_budget; ++ __le32 max_out_time[SCAN_TWO_LMACS]; ++ __le32 suspend_time[SCAN_TWO_LMACS]; ++ __le32 scan_priority; ++ /* SCAN_CHANNEL_PARAMS_API_S_VER_1 */ ++ u8 channel_flags; ++ u8 n_channels; ++ __le16 reserved2; ++ u8 data[]; ++ } v7; /* SCAN_REQUEST_CMD_UMAC_API_S_VER_7 */ + }; + } __packed; + +-#define IWL_SCAN_REQ_UMAC_SIZE sizeof(struct iwl_scan_req_umac) ++#define IWL_SCAN_REQ_UMAC_SIZE_V7 sizeof(struct iwl_scan_req_umac) ++#define IWL_SCAN_REQ_UMAC_SIZE_V6 (sizeof(struct iwl_scan_req_umac) - \ ++ 2 * sizeof(u8) - sizeof(__le16)) + #define IWL_SCAN_REQ_UMAC_SIZE_V1 (sizeof(struct iwl_scan_req_umac) - \ +- 2 * sizeof(__le32)) ++ 2 * sizeof(__le32) - 2 * sizeof(u8) - \ ++ sizeof(__le16)) + + /** + * struct iwl_umac_scan_abort +diff --git a/drivers/net/wireless/intel/iwlwifi/fw/file.h b/drivers/net/wireless/intel/iwlwifi/fw/file.h +index 279248cd9cfb..e988e4c371c4 100644 +--- a/drivers/net/wireless/intel/iwlwifi/fw/file.h ++++ b/drivers/net/wireless/intel/iwlwifi/fw/file.h +@@ -262,6 +262,7 @@ enum iwl_ucode_tlv_api { + IWL_UCODE_TLV_API_STA_TYPE = (__force iwl_ucode_tlv_api_t)30, + IWL_UCODE_TLV_API_NAN2_VER2 = (__force iwl_ucode_tlv_api_t)31, + /* API Set 1 */ ++ IWL_UCODE_TLV_API_ADAPTIVE_DWELL = (__force iwl_ucode_tlv_api_t)32, + IWL_UCODE_TLV_API_NEW_BEACON_TEMPLATE = (__force iwl_ucode_tlv_api_t)34, + IWL_UCODE_TLV_API_NEW_RX_STATS = (__force iwl_ucode_tlv_api_t)35, + IWL_UCODE_TLV_API_COEX_ATS_EXTERNAL = (__force iwl_ucode_tlv_api_t)37, +diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-config.h b/drivers/net/wireless/intel/iwlwifi/iwl-config.h +index 71cb1ecde0f7..e226179c32fa 100644 +--- a/drivers/net/wireless/intel/iwlwifi/iwl-config.h ++++ b/drivers/net/wireless/intel/iwlwifi/iwl-config.h +@@ -364,6 +364,7 @@ struct iwl_cfg { + u32 dccm2_len; + u32 smem_offset; + u32 smem_len; ++ u32 soc_latency; + u16 nvm_ver; + u16 nvm_calib_ver; + u16 rx_with_siso_diversity:1, +@@ -471,6 +472,10 @@ extern const struct iwl_cfg iwl9260_2ac_cfg; + extern const struct iwl_cfg iwl9270_2ac_cfg; + extern const struct iwl_cfg iwl9460_2ac_cfg; + extern const struct iwl_cfg iwl9560_2ac_cfg; ++extern const struct iwl_cfg iwl9460_2ac_cfg_soc; ++extern const struct iwl_cfg iwl9461_2ac_cfg_soc; ++extern const struct iwl_cfg iwl9462_2ac_cfg_soc; ++extern const struct iwl_cfg iwl9560_2ac_cfg_soc; + extern const struct iwl_cfg iwla000_2ac_cfg_hr; + extern const struct iwl_cfg iwla000_2ac_cfg_hr_cdb; + extern const struct iwl_cfg iwla000_2ac_cfg_jf; +diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h b/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h +index 949e63418299..8dcdb522b846 100644 +--- a/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h ++++ b/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h +@@ -1124,6 +1124,12 @@ static inline bool iwl_mvm_is_d0i3_supported(struct iwl_mvm *mvm) + IWL_UCODE_TLV_CAPA_D0I3_SUPPORT); + } + ++static inline bool iwl_mvm_is_adaptive_dwell_supported(struct iwl_mvm *mvm) ++{ ++ return fw_has_api(&mvm->fw->ucode_capa, ++ IWL_UCODE_TLV_API_ADAPTIVE_DWELL); ++} ++ + static inline bool iwl_mvm_enter_d0i3_on_suspend(struct iwl_mvm *mvm) + { + /* For now we only use this mode to differentiate between +diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/scan.c b/drivers/net/wireless/intel/iwlwifi/mvm/scan.c +index 774122fed454..e4fd476e9ccb 100644 +--- a/drivers/net/wireless/intel/iwlwifi/mvm/scan.c ++++ b/drivers/net/wireless/intel/iwlwifi/mvm/scan.c +@@ -130,6 +130,19 @@ struct iwl_mvm_scan_params { + u32 measurement_dwell; + }; + ++static inline void *iwl_mvm_get_scan_req_umac_data(struct iwl_mvm *mvm) ++{ ++ struct iwl_scan_req_umac *cmd = mvm->scan_cmd; ++ ++ if (iwl_mvm_is_adaptive_dwell_supported(mvm)) ++ return (void *)&cmd->v7.data; ++ ++ if (iwl_mvm_has_new_tx_api(mvm)) ++ return (void *)&cmd->v6.data; ++ ++ return (void *)&cmd->v1.data; ++} ++ + static u8 iwl_mvm_scan_rx_ant(struct iwl_mvm *mvm) + { + if (mvm->scan_rx_ant != ANT_NONE) +@@ -1075,25 +1088,57 @@ static void iwl_mvm_scan_umac_dwell(struct iwl_mvm *mvm, + { + struct iwl_mvm_scan_timing_params *timing = &scan_timing[params->type]; + ++ if (iwl_mvm_is_regular_scan(params)) ++ cmd->ooc_priority = cpu_to_le32(IWL_SCAN_PRIORITY_EXT_6); ++ else ++ cmd->ooc_priority = cpu_to_le32(IWL_SCAN_PRIORITY_EXT_2); ++ ++ if (iwl_mvm_is_adaptive_dwell_supported(mvm)) { ++ if (params->measurement_dwell) { ++ cmd->v7.active_dwell = params->measurement_dwell; ++ cmd->v7.passive_dwell = params->measurement_dwell; ++ } else { ++ cmd->v7.active_dwell = IWL_SCAN_DWELL_ACTIVE; ++ cmd->v7.passive_dwell = IWL_SCAN_DWELL_PASSIVE; ++ } ++ cmd->v7.fragmented_dwell = IWL_SCAN_DWELL_FRAGMENTED; ++ ++ cmd->v7.scan_priority = cpu_to_le32(IWL_SCAN_PRIORITY_EXT_6); ++ cmd->v7.max_out_time[SCAN_LB_LMAC_IDX] = ++ cpu_to_le32(timing->max_out_time); ++ cmd->v7.suspend_time[SCAN_LB_LMAC_IDX] = ++ cpu_to_le32(timing->suspend_time); ++ if (iwl_mvm_is_cdb_supported(mvm)) { ++ cmd->v7.max_out_time[SCAN_HB_LMAC_IDX] = ++ cpu_to_le32(timing->max_out_time); ++ cmd->v7.suspend_time[SCAN_HB_LMAC_IDX] = ++ cpu_to_le32(timing->suspend_time); ++ } ++ ++ return; ++ } ++ + if (params->measurement_dwell) { +- cmd->active_dwell = params->measurement_dwell; +- cmd->passive_dwell = params->measurement_dwell; +- cmd->extended_dwell = params->measurement_dwell; ++ cmd->v1.active_dwell = params->measurement_dwell; ++ cmd->v1.passive_dwell = params->measurement_dwell; ++ cmd->v1.extended_dwell = params->measurement_dwell; + } else { +- cmd->active_dwell = IWL_SCAN_DWELL_ACTIVE; +- cmd->passive_dwell = IWL_SCAN_DWELL_PASSIVE; +- cmd->extended_dwell = IWL_SCAN_DWELL_EXTENDED; ++ cmd->v1.active_dwell = IWL_SCAN_DWELL_ACTIVE; ++ cmd->v1.passive_dwell = IWL_SCAN_DWELL_PASSIVE; ++ cmd->v1.extended_dwell = IWL_SCAN_DWELL_EXTENDED; + } +- cmd->fragmented_dwell = IWL_SCAN_DWELL_FRAGMENTED; ++ cmd->v1.fragmented_dwell = IWL_SCAN_DWELL_FRAGMENTED; + + if (iwl_mvm_has_new_tx_api(mvm)) { + cmd->v6.scan_priority = cpu_to_le32(IWL_SCAN_PRIORITY_EXT_6); +- cmd->v6.max_out_time[0] = cpu_to_le32(timing->max_out_time); +- cmd->v6.suspend_time[0] = cpu_to_le32(timing->suspend_time); ++ cmd->v6.max_out_time[SCAN_LB_LMAC_IDX] = ++ cpu_to_le32(timing->max_out_time); ++ cmd->v6.suspend_time[SCAN_LB_LMAC_IDX] = ++ cpu_to_le32(timing->suspend_time); + if (iwl_mvm_is_cdb_supported(mvm)) { +- cmd->v6.max_out_time[1] = ++ cmd->v6.max_out_time[SCAN_HB_LMAC_IDX] = + cpu_to_le32(timing->max_out_time); +- cmd->v6.suspend_time[1] = ++ cmd->v6.suspend_time[SCAN_HB_LMAC_IDX] = + cpu_to_le32(timing->suspend_time); + } + } else { +@@ -1102,11 +1147,6 @@ static void iwl_mvm_scan_umac_dwell(struct iwl_mvm *mvm, + cmd->v1.scan_priority = + cpu_to_le32(IWL_SCAN_PRIORITY_EXT_6); + } +- +- if (iwl_mvm_is_regular_scan(params)) +- cmd->ooc_priority = cpu_to_le32(IWL_SCAN_PRIORITY_EXT_6); +- else +- cmd->ooc_priority = cpu_to_le32(IWL_SCAN_PRIORITY_EXT_2); + } + + static void +@@ -1178,8 +1218,7 @@ static int iwl_mvm_scan_umac(struct iwl_mvm *mvm, struct ieee80211_vif *vif, + int type) + { + struct iwl_scan_req_umac *cmd = mvm->scan_cmd; +- void *cmd_data = iwl_mvm_has_new_tx_api(mvm) ? +- (void *)&cmd->v6.data : (void *)&cmd->v1.data; ++ void *cmd_data = iwl_mvm_get_scan_req_umac_data(mvm); + struct iwl_scan_req_umac_tail *sec_part = cmd_data + + sizeof(struct iwl_scan_channel_cfg_umac) * + mvm->fw->ucode_capa.n_scan_channels; +@@ -1216,7 +1255,10 @@ static int iwl_mvm_scan_umac(struct iwl_mvm *mvm, struct ieee80211_vif *vif, + IWL_SCAN_CHANNEL_FLAG_EBS_ACCURATE | + IWL_SCAN_CHANNEL_FLAG_CACHE_ADD; + +- if (iwl_mvm_has_new_tx_api(mvm)) { ++ if (iwl_mvm_is_adaptive_dwell_supported(mvm)) { ++ cmd->v7.channel_flags = channel_flags; ++ cmd->v7.n_channels = params->n_channels; ++ } else if (iwl_mvm_has_new_tx_api(mvm)) { + cmd->v6.channel_flags = channel_flags; + cmd->v6.n_channels = params->n_channels; + } else { +@@ -1661,8 +1703,10 @@ int iwl_mvm_scan_size(struct iwl_mvm *mvm) + { + int base_size = IWL_SCAN_REQ_UMAC_SIZE_V1; + +- if (iwl_mvm_has_new_tx_api(mvm)) +- base_size = IWL_SCAN_REQ_UMAC_SIZE; ++ if (iwl_mvm_is_adaptive_dwell_supported(mvm)) ++ base_size = IWL_SCAN_REQ_UMAC_SIZE_V7; ++ else if (iwl_mvm_has_new_tx_api(mvm)) ++ base_size = IWL_SCAN_REQ_UMAC_SIZE_V6; + + if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) + return base_size + +diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/drv.c b/drivers/net/wireless/intel/iwlwifi/pcie/drv.c +index 858765fed8f8..548e1928430d 100644 +--- a/drivers/net/wireless/intel/iwlwifi/pcie/drv.c ++++ b/drivers/net/wireless/intel/iwlwifi/pcie/drv.c +@@ -465,6 +465,8 @@ static const struct pci_device_id iwl_hw_card_ids[] = { + {IWL_PCI_DEVICE(0x24F3, 0x9110, iwl8260_2ac_cfg)}, + {IWL_PCI_DEVICE(0x24F4, 0x8030, iwl8260_2ac_cfg)}, + {IWL_PCI_DEVICE(0x24F4, 0x9030, iwl8260_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x24F4, 0xC030, iwl8260_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x24F4, 0xD030, iwl8260_2ac_cfg)}, + {IWL_PCI_DEVICE(0x24F3, 0x8130, iwl8260_2ac_cfg)}, + {IWL_PCI_DEVICE(0x24F3, 0x9130, iwl8260_2ac_cfg)}, + {IWL_PCI_DEVICE(0x24F3, 0x8132, iwl8260_2ac_cfg)}, +@@ -483,6 +485,7 @@ static const struct pci_device_id iwl_hw_card_ids[] = { + {IWL_PCI_DEVICE(0x24F3, 0x0950, iwl8260_2ac_cfg)}, + {IWL_PCI_DEVICE(0x24F3, 0x0930, iwl8260_2ac_cfg)}, + {IWL_PCI_DEVICE(0x24F3, 0x0000, iwl8265_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x24F3, 0x4010, iwl8260_2ac_cfg)}, + {IWL_PCI_DEVICE(0x24FD, 0x0010, iwl8265_2ac_cfg)}, + {IWL_PCI_DEVICE(0x24FD, 0x0110, iwl8265_2ac_cfg)}, + {IWL_PCI_DEVICE(0x24FD, 0x1110, iwl8265_2ac_cfg)}, +@@ -508,67 +511,143 @@ static const struct pci_device_id iwl_hw_card_ids[] = { + {IWL_PCI_DEVICE(0x24FD, 0x3E01, iwl8275_2ac_cfg)}, + {IWL_PCI_DEVICE(0x24FD, 0x1012, iwl8275_2ac_cfg)}, + {IWL_PCI_DEVICE(0x24FD, 0x0012, iwl8275_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x24FD, 0x0014, iwl8265_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x24FD, 0x9074, iwl8265_2ac_cfg)}, + + /* 9000 Series */ +- {IWL_PCI_DEVICE(0x271B, 0x0010, iwl9160_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x271B, 0x0014, iwl9160_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x271B, 0x0210, iwl9160_2ac_cfg)}, + {IWL_PCI_DEVICE(0x2526, 0x0000, iwl9260_2ac_cfg)}, + {IWL_PCI_DEVICE(0x2526, 0x0010, iwl9260_2ac_cfg)}, + {IWL_PCI_DEVICE(0x2526, 0x0014, iwl9260_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x2526, 0xA014, iwl9260_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x2526, 0x4010, iwl9260_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x2526, 0x0210, iwl9260_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x2526, 0x0214, iwl9260_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x2526, 0x1410, iwl9270_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x2526, 0x1610, iwl9270_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x9DF0, 0x0A10, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x9DF0, 0x0010, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x9DF0, 0x0210, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x9DF0, 0x0410, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x9DF0, 0x0610, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x9DF0, 0x0310, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x9DF0, 0x0000, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x9DF0, 0x0510, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x9DF0, 0x2010, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x2526, 0x1420, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x9DF0, 0x0710, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x9DF0, 0x2A10, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x30DC, 0x0060, iwl9460_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0x0030, iwl9560_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0x0034, iwl9560_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0x0038, iwl9560_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0x003C, iwl9560_2ac_cfg)}, + {IWL_PCI_DEVICE(0x2526, 0x0060, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x2526, 0x0260, iwl9460_2ac_cfg)}, + {IWL_PCI_DEVICE(0x2526, 0x0064, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x2526, 0x00A4, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x2526, 0x40A4, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x2526, 0x02A4, iwl9460_2ac_cfg)}, + {IWL_PCI_DEVICE(0x2526, 0x00A0, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x2526, 0x02A0, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x9DF0, 0x0060, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0xA370, 0x0060, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x31DC, 0x0060, iwl9460_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x2526, 0x0030, iwl9560_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x2526, 0x4030, iwl9560_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0x00A4, iwl9460_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0x0210, iwl9260_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0x0214, iwl9260_2ac_cfg)}, + {IWL_PCI_DEVICE(0x2526, 0x0230, iwl9560_2ac_cfg)}, + {IWL_PCI_DEVICE(0x2526, 0x0234, iwl9560_2ac_cfg)}, + {IWL_PCI_DEVICE(0x2526, 0x0238, iwl9560_2ac_cfg)}, + {IWL_PCI_DEVICE(0x2526, 0x023C, iwl9560_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x9DF0, 0x0030, iwl9560_2ac_cfg)}, +- {IWL_PCI_DEVICE(0xA370, 0x0030, iwl9560_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x31DC, 0x0030, iwl9560_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0x0260, iwl9460_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0x0264, iwl9461_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x2526, 0x02A0, iwl9460_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0x02A4, iwl9460_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0x1010, iwl9260_2ac_cfg)}, + {IWL_PCI_DEVICE(0x2526, 0x1030, iwl9560_2ac_cfg)}, +- {IWL_PCI_DEVICE(0xA370, 0x1030, iwl9560_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x9DF0, 0x0034, iwl9560_2ac_cfg)}, +- {IWL_PCI_DEVICE(0xA370, 0x0034, iwl9560_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x31DC, 0x0034, iwl9560_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x2526, 0x0038, iwl9560_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x2526, 0x003C, iwl9560_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x9DF0, 0x0038, iwl9560_2ac_cfg)}, +- {IWL_PCI_DEVICE(0xA370, 0x0038, iwl9560_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x31DC, 0x0038, iwl9560_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x9DF0, 0x003C, iwl9560_2ac_cfg)}, +- {IWL_PCI_DEVICE(0xA370, 0x003C, iwl9560_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x31DC, 0x003C, iwl9560_2ac_cfg)}, +- {IWL_PCI_DEVICE(0x2526, 0x0034, iwl9560_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0x1210, iwl9260_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0x1410, iwl9270_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0x1420, iwl9460_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x2526, 0x1610, iwl9270_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0x4010, iwl9260_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0x4030, iwl9560_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0x40A4, iwl9460_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0xA014, iwl9260_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2526, 0x42A4, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x271B, 0x0010, iwl9160_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x271B, 0x0014, iwl9160_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x271B, 0x0210, iwl9160_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x271B, 0x0214, iwl9260_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2720, 0x0034, iwl9560_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2720, 0x0038, iwl9560_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2720, 0x003C, iwl9560_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2720, 0x0060, iwl9461_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x2720, 0x0064, iwl9461_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x2720, 0x00A0, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x2720, 0x00A4, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x2720, 0x0230, iwl9560_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2720, 0x0234, iwl9560_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2720, 0x0238, iwl9560_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2720, 0x023C, iwl9560_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2720, 0x0260, iwl9461_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x2720, 0x0264, iwl9461_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x2720, 0x02A0, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x2720, 0x02A4, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x2720, 0x4030, iwl9560_2ac_cfg)}, ++ {IWL_PCI_DEVICE(0x2720, 0x40A4, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x30DC, 0x0060, iwl9460_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x30DC, 0x0064, iwl9461_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x30DC, 0x00A0, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x30DC, 0x00A4, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x30DC, 0x0260, iwl9461_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x30DC, 0x0264, iwl9461_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x30DC, 0x02A0, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x30DC, 0x02A4, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x0030, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x0034, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x0038, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x003C, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x0060, iwl9460_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x0064, iwl9461_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x00A0, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x00A4, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x0230, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x0234, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x0238, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x023C, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x0260, iwl9461_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x0264, iwl9461_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x02A0, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x02A4, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x4030, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x4034, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x31DC, 0x40A4, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x34F0, 0x0030, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x34F0, 0x0034, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x34F0, 0x02A4, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0000, iwl9460_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0010, iwl9460_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0030, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0034, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0038, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x003C, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0060, iwl9460_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0064, iwl9461_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x00A0, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x00A4, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0210, iwl9460_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0230, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0234, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0238, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x023C, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0260, iwl9461_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0264, iwl9461_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x02A0, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x02A4, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0310, iwl9460_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0410, iwl9460_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0510, iwl9460_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0610, iwl9460_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0710, iwl9460_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x0A10, iwl9460_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x2010, iwl9460_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x2A10, iwl9460_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x4030, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x4034, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0x9DF0, 0x40A4, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x0030, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x0034, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x0038, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x003C, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x0060, iwl9460_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x0064, iwl9461_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x00A0, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x00A4, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x0230, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x0234, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x0238, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x023C, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x0260, iwl9461_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x0264, iwl9461_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x02A0, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x02A4, iwl9462_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x1030, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x4030, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x4034, iwl9560_2ac_cfg_soc)}, ++ {IWL_PCI_DEVICE(0xA370, 0x40A4, iwl9462_2ac_cfg_soc)}, + + /* a000 Series */ + {IWL_PCI_DEVICE(0x2720, 0x0A10, iwla000_2ac_cfg_hr_cdb)}, +@@ -576,8 +655,14 @@ static const struct pci_device_id iwl_hw_card_ids[] = { + {IWL_PCI_DEVICE(0x2720, 0x0000, iwla000_2ax_cfg_hr)}, + {IWL_PCI_DEVICE(0x34F0, 0x0070, iwla000_2ax_cfg_hr)}, + {IWL_PCI_DEVICE(0x2720, 0x0078, iwla000_2ax_cfg_hr)}, +- {IWL_PCI_DEVICE(0x2720, 0x0070, iwla000_2ax_cfg_hr)}, ++ {IWL_PCI_DEVICE(0x2720, 0x0070, iwla000_2ac_cfg_hr_cdb)}, ++ {IWL_PCI_DEVICE(0x2720, 0x0030, iwla000_2ac_cfg_hr_cdb)}, + {IWL_PCI_DEVICE(0x2720, 0x1080, iwla000_2ax_cfg_hr)}, ++ {IWL_PCI_DEVICE(0x2720, 0x0090, iwla000_2ac_cfg_hr_cdb)}, ++ {IWL_PCI_DEVICE(0x2720, 0x0310, iwla000_2ac_cfg_hr_cdb)}, ++ {IWL_PCI_DEVICE(0x40C0, 0x0000, iwla000_2ax_cfg_hr)}, ++ {IWL_PCI_DEVICE(0x40C0, 0x0A10, iwla000_2ax_cfg_hr)}, ++ + #endif /* CONFIG_IWLMVM */ + + {0} +diff --git a/drivers/net/wireless/intersil/p54/main.c b/drivers/net/wireless/intersil/p54/main.c +index d5a3bf91a03e..ab6d39e12069 100644 +--- a/drivers/net/wireless/intersil/p54/main.c ++++ b/drivers/net/wireless/intersil/p54/main.c +@@ -852,12 +852,11 @@ void p54_unregister_common(struct ieee80211_hw *dev) + { + struct p54_common *priv = dev->priv; + +-#ifdef CONFIG_P54_LEDS +- p54_unregister_leds(priv); +-#endif /* CONFIG_P54_LEDS */ +- + if (priv->registered) { + priv->registered = false; ++#ifdef CONFIG_P54_LEDS ++ p54_unregister_leds(priv); ++#endif /* CONFIG_P54_LEDS */ + ieee80211_unregister_hw(dev); + } + +diff --git a/drivers/net/wireless/ralink/rt2x00/rt2x00usb.c b/drivers/net/wireless/ralink/rt2x00/rt2x00usb.c +index e2f4f5778267..086aad22743d 100644 +--- a/drivers/net/wireless/ralink/rt2x00/rt2x00usb.c ++++ b/drivers/net/wireless/ralink/rt2x00/rt2x00usb.c +@@ -57,7 +57,7 @@ int rt2x00usb_vendor_request(struct rt2x00_dev *rt2x00dev, + if (status >= 0) + return 0; + +- if (status == -ENODEV) { ++ if (status == -ENODEV || status == -ENOENT) { + /* Device has disappeared. */ + clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags); + break; +@@ -321,7 +321,7 @@ static bool rt2x00usb_kick_tx_entry(struct queue_entry *entry, void *data) + + status = usb_submit_urb(entry_priv->urb, GFP_ATOMIC); + if (status) { +- if (status == -ENODEV) ++ if (status == -ENODEV || status == -ENOENT) + clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags); + set_bit(ENTRY_DATA_IO_FAILED, &entry->flags); + rt2x00lib_dmadone(entry); +@@ -410,7 +410,7 @@ static bool rt2x00usb_kick_rx_entry(struct queue_entry *entry, void *data) + + status = usb_submit_urb(entry_priv->urb, GFP_ATOMIC); + if (status) { +- if (status == -ENODEV) ++ if (status == -ENODEV || status == -ENOENT) + clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags); + set_bit(ENTRY_DATA_IO_FAILED, &entry->flags); + rt2x00lib_dmadone(entry); +diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8192ee/fw.c b/drivers/net/wireless/realtek/rtlwifi/rtl8192ee/fw.c +index 7eae27f8e173..f9563ae301ad 100644 +--- a/drivers/net/wireless/realtek/rtlwifi/rtl8192ee/fw.c ++++ b/drivers/net/wireless/realtek/rtlwifi/rtl8192ee/fw.c +@@ -682,7 +682,7 @@ void rtl92ee_set_fw_rsvdpagepkt(struct ieee80211_hw *hw, bool b_dl_finished) + struct rtl_priv *rtlpriv = rtl_priv(hw); + struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); + struct sk_buff *skb = NULL; +- ++ bool rtstatus; + u32 totalpacketlen; + u8 u1rsvdpageloc[5] = { 0 }; + bool b_dlok = false; +@@ -768,7 +768,9 @@ void rtl92ee_set_fw_rsvdpagepkt(struct ieee80211_hw *hw, bool b_dl_finished) + skb = dev_alloc_skb(totalpacketlen); + skb_put_data(skb, &reserved_page_packet, totalpacketlen); + +- b_dlok = true; ++ rtstatus = rtl_cmd_send_packet(hw, skb); ++ if (rtstatus) ++ b_dlok = true; + + if (b_dlok) { + RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD , +diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/hw.c b/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/hw.c +index 1d431d4bf6d2..9ac1511de7ba 100644 +--- a/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/hw.c ++++ b/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/hw.c +@@ -1372,6 +1372,7 @@ static void _rtl8821ae_get_wakeup_reason(struct ieee80211_hw *hw) + + ppsc->wakeup_reason = 0; + ++ do_gettimeofday(&ts); + rtlhal->last_suspend_sec = ts.tv_sec; + + switch (fw_reason) { +diff --git a/drivers/nvdimm/dimm.c b/drivers/nvdimm/dimm.c +index e0f0e3ce1a32..98466d762c8f 100644 +--- a/drivers/nvdimm/dimm.c ++++ b/drivers/nvdimm/dimm.c +@@ -68,6 +68,7 @@ static int nvdimm_probe(struct device *dev) + rc = nd_label_reserve_dpa(ndd); + if (ndd->ns_current >= 0) + nvdimm_set_aliasing(dev); ++ nvdimm_clear_locked(dev); + nvdimm_bus_unlock(dev); + + if (rc) +diff --git a/drivers/nvdimm/dimm_devs.c b/drivers/nvdimm/dimm_devs.c +index f0d1b7e5de01..5f1385b96b13 100644 +--- a/drivers/nvdimm/dimm_devs.c ++++ b/drivers/nvdimm/dimm_devs.c +@@ -200,6 +200,13 @@ void nvdimm_set_locked(struct device *dev) + set_bit(NDD_LOCKED, &nvdimm->flags); + } + ++void nvdimm_clear_locked(struct device *dev) ++{ ++ struct nvdimm *nvdimm = to_nvdimm(dev); ++ ++ clear_bit(NDD_LOCKED, &nvdimm->flags); ++} ++ + static void nvdimm_release(struct device *dev) + { + struct nvdimm *nvdimm = to_nvdimm(dev); +diff --git a/drivers/nvdimm/label.c b/drivers/nvdimm/label.c +index 9c5f108910e3..de66c02f6140 100644 +--- a/drivers/nvdimm/label.c ++++ b/drivers/nvdimm/label.c +@@ -1050,7 +1050,7 @@ static int init_labels(struct nd_mapping *nd_mapping, int num_labels) + nsindex = to_namespace_index(ndd, 0); + memset(nsindex, 0, ndd->nsarea.config_size); + for (i = 0; i < 2; i++) { +- int rc = nd_label_write_index(ndd, i, i*2, ND_NSINDEX_INIT); ++ int rc = nd_label_write_index(ndd, i, 3 - i, ND_NSINDEX_INIT); + + if (rc) + return rc; +diff --git a/drivers/nvdimm/namespace_devs.c b/drivers/nvdimm/namespace_devs.c +index 3e4d1e7998da..0af988739a06 100644 +--- a/drivers/nvdimm/namespace_devs.c ++++ b/drivers/nvdimm/namespace_devs.c +@@ -1620,7 +1620,7 @@ static umode_t namespace_visible(struct kobject *kobj, + if (a == &dev_attr_resource.attr) { + if (is_namespace_blk(dev)) + return 0; +- return a->mode; ++ return 0400; + } + + if (is_namespace_pmem(dev) || is_namespace_blk(dev)) { +diff --git a/drivers/nvdimm/nd.h b/drivers/nvdimm/nd.h +index 9c758a91372b..156be00e1f76 100644 +--- a/drivers/nvdimm/nd.h ++++ b/drivers/nvdimm/nd.h +@@ -254,6 +254,7 @@ long nvdimm_clear_poison(struct device *dev, phys_addr_t phys, + unsigned int len); + void nvdimm_set_aliasing(struct device *dev); + void nvdimm_set_locked(struct device *dev); ++void nvdimm_clear_locked(struct device *dev); + struct nd_btt *to_nd_btt(struct device *dev); + + struct nd_gen_sb { +diff --git a/drivers/nvdimm/pfn_devs.c b/drivers/nvdimm/pfn_devs.c +index 9576c444f0ab..65cc171c721d 100644 +--- a/drivers/nvdimm/pfn_devs.c ++++ b/drivers/nvdimm/pfn_devs.c +@@ -282,8 +282,16 @@ static struct attribute *nd_pfn_attributes[] = { + NULL, + }; + ++static umode_t pfn_visible(struct kobject *kobj, struct attribute *a, int n) ++{ ++ if (a == &dev_attr_resource.attr) ++ return 0400; ++ return a->mode; ++} ++ + struct attribute_group nd_pfn_attribute_group = { + .attrs = nd_pfn_attributes, ++ .is_visible = pfn_visible, + }; + + static const struct attribute_group *nd_pfn_attribute_groups[] = { +diff --git a/drivers/nvdimm/region_devs.c b/drivers/nvdimm/region_devs.c +index 829d760f651c..abaf38c61220 100644 +--- a/drivers/nvdimm/region_devs.c ++++ b/drivers/nvdimm/region_devs.c +@@ -562,8 +562,12 @@ static umode_t region_visible(struct kobject *kobj, struct attribute *a, int n) + if (!is_nd_pmem(dev) && a == &dev_attr_badblocks.attr) + return 0; + +- if (!is_nd_pmem(dev) && a == &dev_attr_resource.attr) +- return 0; ++ if (a == &dev_attr_resource.attr) { ++ if (is_nd_pmem(dev)) ++ return 0400; ++ else ++ return 0; ++ } + + if (a == &dev_attr_deep_flush.attr) { + int has_flush = nvdimm_has_flush(nd_region); +diff --git a/drivers/pci/host/pci-hyperv.c b/drivers/pci/host/pci-hyperv.c +index 0fe3ea164ee5..04dac6a42c9f 100644 +--- a/drivers/pci/host/pci-hyperv.c ++++ b/drivers/pci/host/pci-hyperv.c +@@ -879,7 +879,7 @@ static void hv_irq_unmask(struct irq_data *data) + int cpu; + u64 res; + +- dest = irq_data_get_affinity_mask(data); ++ dest = irq_data_get_effective_affinity_mask(data); + pdev = msi_desc_to_pci_dev(msi_desc); + pbus = pdev->bus; + hbus = container_of(pbus->sysdata, struct hv_pcibus_device, sysdata); +@@ -1042,6 +1042,7 @@ static void hv_compose_msi_msg(struct irq_data *data, struct msi_msg *msg) + struct hv_pci_dev *hpdev; + struct pci_bus *pbus; + struct pci_dev *pdev; ++ struct cpumask *dest; + struct compose_comp_ctxt comp; + struct tran_int_desc *int_desc; + struct { +@@ -1056,6 +1057,7 @@ static void hv_compose_msi_msg(struct irq_data *data, struct msi_msg *msg) + int ret; + + pdev = msi_desc_to_pci_dev(irq_data_get_msi_desc(data)); ++ dest = irq_data_get_effective_affinity_mask(data); + pbus = pdev->bus; + hbus = container_of(pbus->sysdata, struct hv_pcibus_device, sysdata); + hpdev = get_pcichild_wslot(hbus, devfn_to_wslot(pdev->devfn)); +@@ -1081,14 +1083,14 @@ static void hv_compose_msi_msg(struct irq_data *data, struct msi_msg *msg) + switch (pci_protocol_version) { + case PCI_PROTOCOL_VERSION_1_1: + size = hv_compose_msi_req_v1(&ctxt.int_pkts.v1, +- irq_data_get_affinity_mask(data), ++ dest, + hpdev->desc.win_slot.slot, + cfg->vector); + break; + + case PCI_PROTOCOL_VERSION_1_2: + size = hv_compose_msi_req_v2(&ctxt.int_pkts.v2, +- irq_data_get_affinity_mask(data), ++ dest, + hpdev->desc.win_slot.slot, + cfg->vector); + break; +diff --git a/drivers/pci/pcie/aspm.c b/drivers/pci/pcie/aspm.c +index 83e4a892b14b..cae54f8320be 100644 +--- a/drivers/pci/pcie/aspm.c ++++ b/drivers/pci/pcie/aspm.c +@@ -453,7 +453,7 @@ static void aspm_calc_l1ss_info(struct pcie_link_state *link, + + /* Choose the greater of the two T_cmn_mode_rstr_time */ + val1 = (upreg->l1ss_cap >> 8) & 0xFF; +- val2 = (upreg->l1ss_cap >> 8) & 0xFF; ++ val2 = (dwreg->l1ss_cap >> 8) & 0xFF; + if (val1 > val2) + link->l1ss.ctl1 |= val1 << 8; + else +@@ -658,7 +658,7 @@ static void pcie_config_aspm_l1ss(struct pcie_link_state *link, u32 state) + 0xFF00, link->l1ss.ctl1); + + /* Program LTR L1.2 threshold in both ports */ +- pci_clear_and_set_dword(parent, dw_cap_ptr + PCI_L1SS_CTL1, ++ pci_clear_and_set_dword(parent, up_cap_ptr + PCI_L1SS_CTL1, + 0xE3FF0000, link->l1ss.ctl1); + pci_clear_and_set_dword(child, dw_cap_ptr + PCI_L1SS_CTL1, + 0xE3FF0000, link->l1ss.ctl1); +diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c +index 911b3b65c8b2..f66f9375177c 100644 +--- a/drivers/pci/quirks.c ++++ b/drivers/pci/quirks.c +@@ -4212,17 +4212,32 @@ static int pci_quirk_amd_sb_acs(struct pci_dev *dev, u16 acs_flags) + #endif + } + ++static bool pci_quirk_cavium_acs_match(struct pci_dev *dev) ++{ ++ /* ++ * Effectively selects all downstream ports for whole ThunderX 1 ++ * family by 0xf800 mask (which represents 8 SoCs), while the lower ++ * bits of device ID are used to indicate which subdevice is used ++ * within the SoC. ++ */ ++ return (pci_is_pcie(dev) && ++ (pci_pcie_type(dev) == PCI_EXP_TYPE_ROOT_PORT) && ++ ((dev->device & 0xf800) == 0xa000)); ++} ++ + static int pci_quirk_cavium_acs(struct pci_dev *dev, u16 acs_flags) + { + /* +- * Cavium devices matching this quirk do not perform peer-to-peer +- * with other functions, allowing masking out these bits as if they +- * were unimplemented in the ACS capability. ++ * Cavium root ports don't advertise an ACS capability. However, ++ * the RTL internally implements similar protection as if ACS had ++ * Request Redirection, Completion Redirection, Source Validation, ++ * and Upstream Forwarding features enabled. Assert that the ++ * hardware implements and enables equivalent ACS functionality for ++ * these flags. + */ +- acs_flags &= ~(PCI_ACS_SV | PCI_ACS_TB | PCI_ACS_RR | +- PCI_ACS_CR | PCI_ACS_UF | PCI_ACS_DT); ++ acs_flags &= ~(PCI_ACS_RR | PCI_ACS_CR | PCI_ACS_SV | PCI_ACS_UF); + +- if (!((dev->device >= 0xa000) && (dev->device <= 0xa0ff))) ++ if (!pci_quirk_cavium_acs_match(dev)) + return -ENOTTY; + + return acs_flags ? 0 : 1; +diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c +index c17677f494af..dc6519b2c53a 100644 +--- a/drivers/scsi/lpfc/lpfc_attr.c ++++ b/drivers/scsi/lpfc/lpfc_attr.c +@@ -3134,7 +3134,8 @@ lpfc_txq_hw_show(struct device *dev, struct device_attribute *attr, char *buf) + struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba; + struct lpfc_sli_ring *pring = lpfc_phba_elsring(phba); + +- return snprintf(buf, PAGE_SIZE, "%d\n", pring->txq_max); ++ return snprintf(buf, PAGE_SIZE, "%d\n", ++ pring ? pring->txq_max : 0); + } + + static DEVICE_ATTR(txq_hw, S_IRUGO, +@@ -3147,7 +3148,8 @@ lpfc_txcmplq_hw_show(struct device *dev, struct device_attribute *attr, + struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba; + struct lpfc_sli_ring *pring = lpfc_phba_elsring(phba); + +- return snprintf(buf, PAGE_SIZE, "%d\n", pring->txcmplq_max); ++ return snprintf(buf, PAGE_SIZE, "%d\n", ++ pring ? pring->txcmplq_max : 0); + } + + static DEVICE_ATTR(txcmplq_hw, S_IRUGO, +diff --git a/drivers/scsi/lpfc/lpfc_bsg.c b/drivers/scsi/lpfc/lpfc_bsg.c +index fe9e1c079c20..d89816222b23 100644 +--- a/drivers/scsi/lpfc/lpfc_bsg.c ++++ b/drivers/scsi/lpfc/lpfc_bsg.c +@@ -2911,7 +2911,7 @@ static int lpfcdiag_loop_post_rxbufs(struct lpfc_hba *phba, uint16_t rxxri, + } + } + +- if (!cmdiocbq || !rxbmp || !rxbpl || !rxbuffer) { ++ if (!cmdiocbq || !rxbmp || !rxbpl || !rxbuffer || !pring) { + ret_val = -ENOMEM; + goto err_post_rxbufs_exit; + } +@@ -5421,6 +5421,8 @@ lpfc_bsg_timeout(struct bsg_job *job) + struct lpfc_iocbq *check_iocb, *next_iocb; + + pring = lpfc_phba_elsring(phba); ++ if (unlikely(!pring)) ++ return -EIO; + + /* if job's driver data is NULL, the command completed or is in the + * the process of completing. In this case, return status to request +diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c +index 468a66371de9..3ebf6ccba6e6 100644 +--- a/drivers/scsi/lpfc/lpfc_els.c ++++ b/drivers/scsi/lpfc/lpfc_els.c +@@ -7430,6 +7430,8 @@ lpfc_els_timeout_handler(struct lpfc_vport *vport) + timeout = (uint32_t)(phba->fc_ratov << 1); + + pring = lpfc_phba_elsring(phba); ++ if (unlikely(!pring)) ++ return; + + if ((phba->pport->load_flag & FC_UNLOADING)) + return; +@@ -9310,6 +9312,9 @@ void lpfc_fabric_abort_nport(struct lpfc_nodelist *ndlp) + + pring = lpfc_phba_elsring(phba); + ++ if (unlikely(!pring)) ++ return; ++ + spin_lock_irq(&phba->hbalock); + list_for_each_entry_safe(piocb, tmp_iocb, &phba->fabric_iocb_list, + list) { +@@ -9416,7 +9421,7 @@ lpfc_sli4_els_xri_aborted(struct lpfc_hba *phba, + rxid, 1); + + /* Check if TXQ queue needs to be serviced */ +- if (!(list_empty(&pring->txq))) ++ if (pring && !list_empty(&pring->txq)) + lpfc_worker_wake_up(phba); + return; + } +diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c +index 20808349a80e..499df9d17339 100644 +--- a/drivers/scsi/lpfc/lpfc_hbadisc.c ++++ b/drivers/scsi/lpfc/lpfc_hbadisc.c +@@ -3324,7 +3324,8 @@ lpfc_mbx_cmpl_read_topology(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb) + + /* Unblock ELS traffic */ + pring = lpfc_phba_elsring(phba); +- pring->flag &= ~LPFC_STOP_IOCB_EVENT; ++ if (pring) ++ pring->flag &= ~LPFC_STOP_IOCB_EVENT; + + /* Check for error */ + if (mb->mbxStatus) { +@@ -5430,6 +5431,8 @@ lpfc_free_tx(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp) + + psli = &phba->sli; + pring = lpfc_phba_elsring(phba); ++ if (unlikely(!pring)) ++ return; + + /* Error matching iocb on txq or txcmplq + * First check the txq. +diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c +index 100bc4c8798d..6acf1bb1d320 100644 +--- a/drivers/scsi/lpfc/lpfc_init.c ++++ b/drivers/scsi/lpfc/lpfc_init.c +@@ -11404,6 +11404,13 @@ lpfc_pci_remove_one_s4(struct pci_dev *pdev) + /* Remove FC host and then SCSI host with the physical port */ + fc_remove_host(shost); + scsi_remove_host(shost); ++ /* ++ * Bring down the SLI Layer. This step disables all interrupts, ++ * clears the rings, discards all mailbox commands, and resets ++ * the HBA FCoE function. ++ */ ++ lpfc_debugfs_terminate(vport); ++ lpfc_sli4_hba_unset(phba); + + /* Perform ndlp cleanup on the physical port. The nvme and nvmet + * localports are destroyed after to cleanup all transport memory. +@@ -11412,14 +11419,8 @@ lpfc_pci_remove_one_s4(struct pci_dev *pdev) + lpfc_nvmet_destroy_targetport(phba); + lpfc_nvme_destroy_localport(vport); + +- /* +- * Bring down the SLI Layer. This step disables all interrupts, +- * clears the rings, discards all mailbox commands, and resets +- * the HBA FCoE function. +- */ +- lpfc_debugfs_terminate(vport); +- lpfc_sli4_hba_unset(phba); + ++ lpfc_stop_hba_timers(phba); + spin_lock_irq(&phba->hbalock); + list_del_init(&vport->listentry); + spin_unlock_irq(&phba->hbalock); +diff --git a/drivers/scsi/lpfc/lpfc_nportdisc.c b/drivers/scsi/lpfc/lpfc_nportdisc.c +index f3ad7cac355d..b6957d944b9a 100644 +--- a/drivers/scsi/lpfc/lpfc_nportdisc.c ++++ b/drivers/scsi/lpfc/lpfc_nportdisc.c +@@ -216,7 +216,7 @@ lpfc_els_abort(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp) + pring = lpfc_phba_elsring(phba); + + /* In case of error recovery path, we might have a NULL pring here */ +- if (!pring) ++ if (unlikely(!pring)) + return; + + /* Abort outstanding I/O on NPort <nlp_DID> */ +diff --git a/drivers/scsi/lpfc/lpfc_nvmet.c b/drivers/scsi/lpfc/lpfc_nvmet.c +index 0b7c1a49e203..3c5b054a56ac 100644 +--- a/drivers/scsi/lpfc/lpfc_nvmet.c ++++ b/drivers/scsi/lpfc/lpfc_nvmet.c +@@ -1138,9 +1138,14 @@ lpfc_nvmet_create_targetport(struct lpfc_hba *phba) + #endif + if (error) { + lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC, +- "6025 Cannot register NVME targetport " +- "x%x\n", error); ++ "6025 Cannot register NVME targetport x%x: " ++ "portnm %llx nodenm %llx segs %d qs %d\n", ++ error, ++ pinfo.port_name, pinfo.node_name, ++ lpfc_tgttemplate.max_sgl_segments, ++ lpfc_tgttemplate.max_hw_queues); + phba->targetport = NULL; ++ phba->nvmet_support = 0; + + lpfc_nvmet_cleanup_io_context(phba); + +@@ -1152,9 +1157,11 @@ lpfc_nvmet_create_targetport(struct lpfc_hba *phba) + lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC, + "6026 Registered NVME " + "targetport: %p, private %p " +- "portnm %llx nodenm %llx\n", ++ "portnm %llx nodenm %llx segs %d qs %d\n", + phba->targetport, tgtp, +- pinfo.port_name, pinfo.node_name); ++ pinfo.port_name, pinfo.node_name, ++ lpfc_tgttemplate.max_sgl_segments, ++ lpfc_tgttemplate.max_hw_queues); + + atomic_set(&tgtp->rcv_ls_req_in, 0); + atomic_set(&tgtp->rcv_ls_req_out, 0); +diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c +index 8b119f87b51d..455f3ce9fda9 100644 +--- a/drivers/scsi/lpfc/lpfc_sli.c ++++ b/drivers/scsi/lpfc/lpfc_sli.c +@@ -9396,10 +9396,13 @@ lpfc_sli4_calc_ring(struct lpfc_hba *phba, struct lpfc_iocbq *piocb) + * for abort iocb hba_wqidx should already + * be setup based on what work queue we used. + */ +- if (!(piocb->iocb_flag & LPFC_USE_FCPWQIDX)) ++ if (!(piocb->iocb_flag & LPFC_USE_FCPWQIDX)) { + piocb->hba_wqidx = + lpfc_sli4_scmd_to_wqidx_distr(phba, + piocb->context1); ++ piocb->hba_wqidx = piocb->hba_wqidx % ++ phba->cfg_fcp_io_channel; ++ } + return phba->sli4_hba.fcp_wq[piocb->hba_wqidx]->pring; + } else { + if (unlikely(!phba->sli4_hba.oas_wq)) +@@ -10632,6 +10635,14 @@ lpfc_sli_issue_abort_iotag(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, + (cmdiocb->iocb_flag & LPFC_DRIVER_ABORTED) != 0) + return 0; + ++ if (!pring) { ++ if (cmdiocb->iocb_flag & LPFC_IO_FABRIC) ++ cmdiocb->fabric_iocb_cmpl = lpfc_ignore_els_cmpl; ++ else ++ cmdiocb->iocb_cmpl = lpfc_ignore_els_cmpl; ++ goto abort_iotag_exit; ++ } ++ + /* + * If we're unloading, don't abort iocb on the ELS ring, but change + * the callback so that nothing happens when it finishes. +@@ -12500,6 +12511,8 @@ lpfc_sli4_els_wcqe_to_rspiocbq(struct lpfc_hba *phba, + unsigned long iflags; + + pring = lpfc_phba_elsring(phba); ++ if (unlikely(!pring)) ++ return NULL; + + wcqe = &irspiocbq->cq_event.cqe.wcqe_cmpl; + spin_lock_irqsave(&pring->ring_lock, iflags); +@@ -12507,19 +12520,21 @@ lpfc_sli4_els_wcqe_to_rspiocbq(struct lpfc_hba *phba, + /* Look up the ELS command IOCB and create pseudo response IOCB */ + cmdiocbq = lpfc_sli_iocbq_lookup_by_tag(phba, pring, + bf_get(lpfc_wcqe_c_request_tag, wcqe)); +- /* Put the iocb back on the txcmplq */ +- lpfc_sli_ringtxcmpl_put(phba, pring, cmdiocbq); +- spin_unlock_irqrestore(&pring->ring_lock, iflags); +- + if (unlikely(!cmdiocbq)) { ++ spin_unlock_irqrestore(&pring->ring_lock, iflags); + lpfc_printf_log(phba, KERN_WARNING, LOG_SLI, + "0386 ELS complete with no corresponding " +- "cmdiocb: iotag (%d)\n", +- bf_get(lpfc_wcqe_c_request_tag, wcqe)); ++ "cmdiocb: 0x%x 0x%x 0x%x 0x%x\n", ++ wcqe->word0, wcqe->total_data_placed, ++ wcqe->parameter, wcqe->word3); + lpfc_sli_release_iocbq(phba, irspiocbq); + return NULL; + } + ++ /* Put the iocb back on the txcmplq */ ++ lpfc_sli_ringtxcmpl_put(phba, pring, cmdiocbq); ++ spin_unlock_irqrestore(&pring->ring_lock, iflags); ++ + /* Fake the irspiocbq and copy necessary response information */ + lpfc_sli4_iocb_param_transfer(phba, irspiocbq, cmdiocbq, wcqe); + +@@ -17137,7 +17152,8 @@ lpfc_sli4_handle_mds_loopback(struct lpfc_vport *vport, + if (pcmd && pcmd->virt) + dma_pool_free(phba->lpfc_drb_pool, pcmd->virt, pcmd->phys); + kfree(pcmd); +- lpfc_sli_release_iocbq(phba, iocbq); ++ if (iocbq) ++ lpfc_sli_release_iocbq(phba, iocbq); + lpfc_in_buf_free(phba, &dmabuf->dbuf); + } + +@@ -18691,6 +18707,8 @@ lpfc_drain_txq(struct lpfc_hba *phba) + uint32_t txq_cnt = 0; + + pring = lpfc_phba_elsring(phba); ++ if (unlikely(!pring)) ++ return 0; + + spin_lock_irqsave(&pring->ring_lock, iflags); + list_for_each_entry(piocbq, &pring->txq, list) { +diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c +index dce42a416876..6eaaa326e508 100644 +--- a/drivers/scsi/qla2xxx/qla_os.c ++++ b/drivers/scsi/qla2xxx/qla_os.c +@@ -388,7 +388,7 @@ static void qla_init_base_qpair(struct scsi_qla_host *vha, struct req_que *req, + INIT_LIST_HEAD(&ha->base_qpair->nvme_done_list); + ha->base_qpair->enable_class_2 = ql2xenableclass2; + /* init qpair to this cpu. Will adjust at run time. */ +- qla_cpu_update(rsp->qpair, smp_processor_id()); ++ qla_cpu_update(rsp->qpair, raw_smp_processor_id()); + ha->base_qpair->pdev = ha->pdev; + + if (IS_QLA27XX(ha) || IS_QLA83XX(ha)) +diff --git a/drivers/scsi/sd_zbc.c b/drivers/scsi/sd_zbc.c +index 8aa54779aac1..2eb61d54bbb4 100644 +--- a/drivers/scsi/sd_zbc.c ++++ b/drivers/scsi/sd_zbc.c +@@ -375,15 +375,15 @@ static int sd_zbc_read_zoned_characteristics(struct scsi_disk *sdkp, + if (sdkp->device->type != TYPE_ZBC) { + /* Host-aware */ + sdkp->urswrz = 1; +- sdkp->zones_optimal_open = get_unaligned_be64(&buf[8]); +- sdkp->zones_optimal_nonseq = get_unaligned_be64(&buf[12]); ++ sdkp->zones_optimal_open = get_unaligned_be32(&buf[8]); ++ sdkp->zones_optimal_nonseq = get_unaligned_be32(&buf[12]); + sdkp->zones_max_open = 0; + } else { + /* Host-managed */ + sdkp->urswrz = buf[4] & 1; + sdkp->zones_optimal_open = 0; + sdkp->zones_optimal_nonseq = 0; +- sdkp->zones_max_open = get_unaligned_be64(&buf[16]); ++ sdkp->zones_max_open = get_unaligned_be32(&buf[16]); + } + + return 0; +diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c +index 5001261f5d69..d9ba4ee2c62b 100644 +--- a/drivers/target/iscsi/iscsi_target.c ++++ b/drivers/target/iscsi/iscsi_target.c +@@ -1960,7 +1960,6 @@ iscsit_handle_task_mgt_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd, + struct iscsi_tmr_req *tmr_req; + struct iscsi_tm *hdr; + int out_of_order_cmdsn = 0, ret; +- bool sess_ref = false; + u8 function, tcm_function = TMR_UNKNOWN; + + hdr = (struct iscsi_tm *) buf; +@@ -1993,22 +1992,23 @@ iscsit_handle_task_mgt_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd, + + cmd->data_direction = DMA_NONE; + cmd->tmr_req = kzalloc(sizeof(*cmd->tmr_req), GFP_KERNEL); +- if (!cmd->tmr_req) ++ if (!cmd->tmr_req) { + return iscsit_add_reject_cmd(cmd, + ISCSI_REASON_BOOKMARK_NO_RESOURCES, + buf); ++ } ++ ++ transport_init_se_cmd(&cmd->se_cmd, &iscsi_ops, ++ conn->sess->se_sess, 0, DMA_NONE, ++ TCM_SIMPLE_TAG, cmd->sense_buffer + 2); ++ ++ target_get_sess_cmd(&cmd->se_cmd, true); + + /* + * TASK_REASSIGN for ERL=2 / connection stays inside of + * LIO-Target $FABRIC_MOD + */ + if (function != ISCSI_TM_FUNC_TASK_REASSIGN) { +- transport_init_se_cmd(&cmd->se_cmd, &iscsi_ops, +- conn->sess->se_sess, 0, DMA_NONE, +- TCM_SIMPLE_TAG, cmd->sense_buffer + 2); +- +- target_get_sess_cmd(&cmd->se_cmd, true); +- sess_ref = true; + tcm_function = iscsit_convert_tmf(function); + if (tcm_function == TMR_UNKNOWN) { + pr_err("Unknown iSCSI TMR Function:" +@@ -2099,12 +2099,14 @@ iscsit_handle_task_mgt_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd, + + if (!(hdr->opcode & ISCSI_OP_IMMEDIATE)) { + int cmdsn_ret = iscsit_sequence_cmd(conn, cmd, buf, hdr->cmdsn); +- if (cmdsn_ret == CMDSN_HIGHER_THAN_EXP) ++ if (cmdsn_ret == CMDSN_HIGHER_THAN_EXP) { + out_of_order_cmdsn = 1; +- else if (cmdsn_ret == CMDSN_LOWER_THAN_EXP) ++ } else if (cmdsn_ret == CMDSN_LOWER_THAN_EXP) { ++ target_put_sess_cmd(&cmd->se_cmd); + return 0; +- else if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER) ++ } else if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER) { + return -1; ++ } + } + iscsit_ack_from_expstatsn(conn, be32_to_cpu(hdr->exp_statsn)); + +@@ -2124,12 +2126,8 @@ iscsit_handle_task_mgt_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd, + * For connection recovery, this is also the default action for + * TMR TASK_REASSIGN. + */ +- if (sess_ref) { +- pr_debug("Handle TMR, using sess_ref=true check\n"); +- target_put_sess_cmd(&cmd->se_cmd); +- } +- + iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state); ++ target_put_sess_cmd(&cmd->se_cmd); + return 0; + } + EXPORT_SYMBOL(iscsit_handle_task_mgt_cmd); +diff --git a/drivers/target/target_core_pr.c b/drivers/target/target_core_pr.c +index dd2cd8048582..9f25c9c6f67d 100644 +--- a/drivers/target/target_core_pr.c ++++ b/drivers/target/target_core_pr.c +@@ -4011,6 +4011,7 @@ core_scsi3_pri_read_full_status(struct se_cmd *cmd) + * Set the ADDITIONAL DESCRIPTOR LENGTH + */ + put_unaligned_be32(desc_len, &buf[off]); ++ off += 4; + /* + * Size of full desctipor header minus TransportID + * containing $FABRIC_MOD specific) initiator device/port +diff --git a/drivers/target/target_core_tmr.c b/drivers/target/target_core_tmr.c +index e22847bd79b9..9c7bc1ca341a 100644 +--- a/drivers/target/target_core_tmr.c ++++ b/drivers/target/target_core_tmr.c +@@ -133,6 +133,15 @@ static bool __target_check_io_state(struct se_cmd *se_cmd, + spin_unlock(&se_cmd->t_state_lock); + return false; + } ++ if (se_cmd->transport_state & CMD_T_PRE_EXECUTE) { ++ if (se_cmd->scsi_status) { ++ pr_debug("Attempted to abort io tag: %llu early failure" ++ " status: 0x%02x\n", se_cmd->tag, ++ se_cmd->scsi_status); ++ spin_unlock(&se_cmd->t_state_lock); ++ return false; ++ } ++ } + if (sess->sess_tearing_down || se_cmd->cmd_wait_set) { + pr_debug("Attempted to abort io tag: %llu already shutdown," + " skipping\n", se_cmd->tag); +@@ -217,7 +226,8 @@ static void core_tmr_drain_tmr_list( + * LUN_RESET tmr.. + */ + spin_lock_irqsave(&dev->se_tmr_lock, flags); +- list_del_init(&tmr->tmr_list); ++ if (tmr) ++ list_del_init(&tmr->tmr_list); + list_for_each_entry_safe(tmr_p, tmr_pp, &dev->dev_tmr_list, tmr_list) { + cmd = tmr_p->task_cmd; + if (!cmd) { +diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c +index 836d552b0385..e6d51135d105 100644 +--- a/drivers/target/target_core_transport.c ++++ b/drivers/target/target_core_transport.c +@@ -1730,9 +1730,6 @@ void transport_generic_request_failure(struct se_cmd *cmd, + { + int ret = 0, post_ret = 0; + +- if (transport_check_aborted_status(cmd, 1)) +- return; +- + pr_debug("-----[ Storage Engine Exception; sense_reason %d\n", + sense_reason); + target_show_cmd("-----[ ", cmd); +@@ -1741,6 +1738,7 @@ void transport_generic_request_failure(struct se_cmd *cmd, + * For SAM Task Attribute emulation for failed struct se_cmd + */ + transport_complete_task_attr(cmd); ++ + /* + * Handle special case for COMPARE_AND_WRITE failure, where the + * callback is expected to drop the per device ->caw_sem. +@@ -1749,6 +1747,9 @@ void transport_generic_request_failure(struct se_cmd *cmd, + cmd->transport_complete_callback) + cmd->transport_complete_callback(cmd, false, &post_ret); + ++ if (transport_check_aborted_status(cmd, 1)) ++ return; ++ + switch (sense_reason) { + case TCM_NON_EXISTENT_LUN: + case TCM_UNSUPPORTED_SCSI_OPCODE: +@@ -1973,6 +1974,7 @@ void target_execute_cmd(struct se_cmd *cmd) + } + + cmd->t_state = TRANSPORT_PROCESSING; ++ cmd->transport_state &= ~CMD_T_PRE_EXECUTE; + cmd->transport_state |= CMD_T_ACTIVE | CMD_T_SENT; + spin_unlock_irq(&cmd->t_state_lock); + +@@ -2010,6 +2012,8 @@ static void target_restart_delayed_cmds(struct se_device *dev) + list_del(&cmd->se_delayed_node); + spin_unlock(&dev->delayed_cmd_lock); + ++ cmd->transport_state |= CMD_T_SENT; ++ + __target_execute_cmd(cmd, true); + + if (cmd->sam_task_attr == TCM_ORDERED_TAG) +@@ -2045,6 +2049,8 @@ static void transport_complete_task_attr(struct se_cmd *cmd) + pr_debug("Incremented dev_cur_ordered_id: %u for ORDERED\n", + dev->dev_cur_ordered_id); + } ++ cmd->se_cmd_flags &= ~SCF_TASK_ATTR_SET; ++ + restart: + target_restart_delayed_cmds(dev); + } +@@ -2570,7 +2576,20 @@ EXPORT_SYMBOL(transport_generic_new_cmd); + + static void transport_write_pending_qf(struct se_cmd *cmd) + { ++ unsigned long flags; + int ret; ++ bool stop; ++ ++ spin_lock_irqsave(&cmd->t_state_lock, flags); ++ stop = (cmd->transport_state & (CMD_T_STOP | CMD_T_ABORTED)); ++ spin_unlock_irqrestore(&cmd->t_state_lock, flags); ++ ++ if (stop) { ++ pr_debug("%s:%d CMD_T_STOP|CMD_T_ABORTED for ITT: 0x%08llx\n", ++ __func__, __LINE__, cmd->tag); ++ complete_all(&cmd->t_transport_stop_comp); ++ return; ++ } + + ret = cmd->se_tfo->write_pending(cmd); + if (ret) { +@@ -2664,6 +2683,7 @@ int target_get_sess_cmd(struct se_cmd *se_cmd, bool ack_kref) + ret = -ESHUTDOWN; + goto out; + } ++ se_cmd->transport_state |= CMD_T_PRE_EXECUTE; + list_add_tail(&se_cmd->se_cmd_list, &se_sess->sess_cmd_list); + out: + spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags); +diff --git a/drivers/tty/serdev/core.c b/drivers/tty/serdev/core.c +index c68fb3a8ea1c..97db76afced2 100644 +--- a/drivers/tty/serdev/core.c ++++ b/drivers/tty/serdev/core.c +@@ -65,21 +65,32 @@ static int serdev_uevent(struct device *dev, struct kobj_uevent_env *env) + */ + int serdev_device_add(struct serdev_device *serdev) + { ++ struct serdev_controller *ctrl = serdev->ctrl; + struct device *parent = serdev->dev.parent; + int err; + + dev_set_name(&serdev->dev, "%s-%d", dev_name(parent), serdev->nr); + ++ /* Only a single slave device is currently supported. */ ++ if (ctrl->serdev) { ++ dev_err(&serdev->dev, "controller busy\n"); ++ return -EBUSY; ++ } ++ ctrl->serdev = serdev; ++ + err = device_add(&serdev->dev); + if (err < 0) { + dev_err(&serdev->dev, "Can't add %s, status %d\n", + dev_name(&serdev->dev), err); +- goto err_device_add; ++ goto err_clear_serdev; + } + + dev_dbg(&serdev->dev, "device %s registered\n", dev_name(&serdev->dev)); + +-err_device_add: ++ return 0; ++ ++err_clear_serdev: ++ ctrl->serdev = NULL; + return err; + } + EXPORT_SYMBOL_GPL(serdev_device_add); +@@ -90,7 +101,10 @@ EXPORT_SYMBOL_GPL(serdev_device_add); + */ + void serdev_device_remove(struct serdev_device *serdev) + { ++ struct serdev_controller *ctrl = serdev->ctrl; ++ + device_unregister(&serdev->dev); ++ ctrl->serdev = NULL; + } + EXPORT_SYMBOL_GPL(serdev_device_remove); + +@@ -295,7 +309,6 @@ struct serdev_device *serdev_device_alloc(struct serdev_controller *ctrl) + return NULL; + + serdev->ctrl = ctrl; +- ctrl->serdev = serdev; + device_initialize(&serdev->dev); + serdev->dev.parent = &ctrl->dev; + serdev->dev.bus = &serdev_bus_type; +diff --git a/drivers/vhost/scsi.c b/drivers/vhost/scsi.c +index 046f6d280af5..e47c5bc3ddca 100644 +--- a/drivers/vhost/scsi.c ++++ b/drivers/vhost/scsi.c +@@ -688,6 +688,7 @@ vhost_scsi_iov_to_sgl(struct vhost_scsi_cmd *cmd, bool write, + struct scatterlist *sg, int sg_count) + { + size_t off = iter->iov_offset; ++ struct scatterlist *p = sg; + int i, ret; + + for (i = 0; i < iter->nr_segs; i++) { +@@ -696,8 +697,8 @@ vhost_scsi_iov_to_sgl(struct vhost_scsi_cmd *cmd, bool write, + + ret = vhost_scsi_map_to_sgl(cmd, base, len, sg, write); + if (ret < 0) { +- for (i = 0; i < sg_count; i++) { +- struct page *page = sg_page(&sg[i]); ++ while (p < sg) { ++ struct page *page = sg_page(p++); + if (page) + put_page(page); + } +diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c +index 2a5de610dd8f..bdabb2765d1b 100644 +--- a/fs/9p/vfs_inode.c ++++ b/fs/9p/vfs_inode.c +@@ -483,6 +483,9 @@ static int v9fs_test_inode(struct inode *inode, void *data) + + if (v9inode->qid.type != st->qid.type) + return 0; ++ ++ if (v9inode->qid.path != st->qid.path) ++ return 0; + return 1; + } + +diff --git a/fs/9p/vfs_inode_dotl.c b/fs/9p/vfs_inode_dotl.c +index 70f9887c59a9..7f6ae21a27b3 100644 +--- a/fs/9p/vfs_inode_dotl.c ++++ b/fs/9p/vfs_inode_dotl.c +@@ -87,6 +87,9 @@ static int v9fs_test_inode_dotl(struct inode *inode, void *data) + + if (v9inode->qid.type != st->qid.type) + return 0; ++ ++ if (v9inode->qid.path != st->qid.path) ++ return 0; + return 1; + } + +diff --git a/fs/autofs4/waitq.c b/fs/autofs4/waitq.c +index 4ac49d038bf3..8fc41705c7cd 100644 +--- a/fs/autofs4/waitq.c ++++ b/fs/autofs4/waitq.c +@@ -81,7 +81,8 @@ static int autofs4_write(struct autofs_sb_info *sbi, + spin_unlock_irqrestore(¤t->sighand->siglock, flags); + } + +- return (bytes > 0); ++ /* if 'wr' returned 0 (impossible) we assume -EIO (safe) */ ++ return bytes == 0 ? 0 : wr < 0 ? wr : -EIO; + } + + static void autofs4_notify_daemon(struct autofs_sb_info *sbi, +@@ -95,6 +96,7 @@ static void autofs4_notify_daemon(struct autofs_sb_info *sbi, + } pkt; + struct file *pipe = NULL; + size_t pktsz; ++ int ret; + + pr_debug("wait id = 0x%08lx, name = %.*s, type=%d\n", + (unsigned long) wq->wait_queue_token, +@@ -169,7 +171,18 @@ static void autofs4_notify_daemon(struct autofs_sb_info *sbi, + mutex_unlock(&sbi->wq_mutex); + + if (autofs4_write(sbi, pipe, &pkt, pktsz)) ++ switch (ret = autofs4_write(sbi, pipe, &pkt, pktsz)) { ++ case 0: ++ break; ++ case -ENOMEM: ++ case -ERESTARTSYS: ++ /* Just fail this one */ ++ autofs4_wait_release(sbi, wq->wait_queue_token, ret); ++ break; ++ default: + autofs4_catatonic_mode(sbi); ++ break; ++ } + fput(pipe); + } + +diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c +index e2d7e86b51d1..08698105fa4a 100644 +--- a/fs/btrfs/extent-tree.c ++++ b/fs/btrfs/extent-tree.c +@@ -4919,6 +4919,13 @@ static void shrink_delalloc(struct btrfs_fs_info *fs_info, u64 to_reclaim, + } + } + ++struct reserve_ticket { ++ u64 bytes; ++ int error; ++ struct list_head list; ++ wait_queue_head_t wait; ++}; ++ + /** + * maybe_commit_transaction - possibly commit the transaction if its ok to + * @root - the root we're allocating for +@@ -4930,18 +4937,29 @@ static void shrink_delalloc(struct btrfs_fs_info *fs_info, u64 to_reclaim, + * will return -ENOSPC. + */ + static int may_commit_transaction(struct btrfs_fs_info *fs_info, +- struct btrfs_space_info *space_info, +- u64 bytes, int force) ++ struct btrfs_space_info *space_info) + { ++ struct reserve_ticket *ticket = NULL; + struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_block_rsv; + struct btrfs_trans_handle *trans; ++ u64 bytes; + + trans = (struct btrfs_trans_handle *)current->journal_info; + if (trans) + return -EAGAIN; + +- if (force) +- goto commit; ++ spin_lock(&space_info->lock); ++ if (!list_empty(&space_info->priority_tickets)) ++ ticket = list_first_entry(&space_info->priority_tickets, ++ struct reserve_ticket, list); ++ else if (!list_empty(&space_info->tickets)) ++ ticket = list_first_entry(&space_info->tickets, ++ struct reserve_ticket, list); ++ bytes = (ticket) ? ticket->bytes : 0; ++ spin_unlock(&space_info->lock); ++ ++ if (!bytes) ++ return 0; + + /* See if there is enough pinned space to make this reservation */ + if (percpu_counter_compare(&space_info->total_bytes_pinned, +@@ -4956,8 +4974,12 @@ static int may_commit_transaction(struct btrfs_fs_info *fs_info, + return -ENOSPC; + + spin_lock(&delayed_rsv->lock); ++ if (delayed_rsv->size > bytes) ++ bytes = 0; ++ else ++ bytes -= delayed_rsv->size; + if (percpu_counter_compare(&space_info->total_bytes_pinned, +- bytes - delayed_rsv->size) < 0) { ++ bytes) < 0) { + spin_unlock(&delayed_rsv->lock); + return -ENOSPC; + } +@@ -4971,13 +4993,6 @@ static int may_commit_transaction(struct btrfs_fs_info *fs_info, + return btrfs_commit_transaction(trans); + } + +-struct reserve_ticket { +- u64 bytes; +- int error; +- struct list_head list; +- wait_queue_head_t wait; +-}; +- + /* + * Try to flush some data based on policy set by @state. This is only advisory + * and may fail for various reasons. The caller is supposed to examine the +@@ -5027,8 +5042,7 @@ static void flush_space(struct btrfs_fs_info *fs_info, + ret = 0; + break; + case COMMIT_TRANS: +- ret = may_commit_transaction(fs_info, space_info, +- num_bytes, 0); ++ ret = may_commit_transaction(fs_info, space_info); + break; + default: + ret = -ENOSPC; +diff --git a/fs/buffer.c b/fs/buffer.c +index 170df856bdb9..b96f3b98a6ef 100644 +--- a/fs/buffer.c ++++ b/fs/buffer.c +@@ -3055,8 +3055,16 @@ void guard_bio_eod(int op, struct bio *bio) + sector_t maxsector; + struct bio_vec *bvec = &bio->bi_io_vec[bio->bi_vcnt - 1]; + unsigned truncated_bytes; ++ struct hd_struct *part; ++ ++ rcu_read_lock(); ++ part = __disk_get_part(bio->bi_disk, bio->bi_partno); ++ if (part) ++ maxsector = part_nr_sects_read(part); ++ else ++ maxsector = get_capacity(bio->bi_disk); ++ rcu_read_unlock(); + +- maxsector = get_capacity(bio->bi_disk); + if (!maxsector) + return; + +diff --git a/fs/crypto/crypto.c b/fs/crypto/crypto.c +index c7835df7e7b8..d262a93d9b31 100644 +--- a/fs/crypto/crypto.c ++++ b/fs/crypto/crypto.c +@@ -410,11 +410,8 @@ int fscrypt_initialize(unsigned int cop_flags) + { + int i, res = -ENOMEM; + +- /* +- * No need to allocate a bounce page pool if there already is one or +- * this FS won't use it. +- */ +- if (cop_flags & FS_CFLG_OWN_PAGES || fscrypt_bounce_page_pool) ++ /* No need to allocate a bounce page pool if this FS won't use it. */ ++ if (cop_flags & FS_CFLG_OWN_PAGES) + return 0; + + mutex_lock(&fscrypt_init_mutex); +diff --git a/fs/dax.c b/fs/dax.c +index f001d8c72a06..191306cd8b6b 100644 +--- a/fs/dax.c ++++ b/fs/dax.c +@@ -1327,7 +1327,7 @@ static int dax_iomap_pmd_fault(struct vm_fault *vmf, + * this is a reliable test. + */ + pgoff = linear_page_index(vma, pmd_addr); +- max_pgoff = (i_size_read(inode) - 1) >> PAGE_SHIFT; ++ max_pgoff = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE); + + trace_dax_pmd_fault(inode, vmf, max_pgoff, 0); + +@@ -1351,13 +1351,13 @@ static int dax_iomap_pmd_fault(struct vm_fault *vmf, + if ((pmd_addr + PMD_SIZE) > vma->vm_end) + goto fallback; + +- if (pgoff > max_pgoff) { ++ if (pgoff >= max_pgoff) { + result = VM_FAULT_SIGBUS; + goto out; + } + + /* If the PMD would extend beyond the file size */ +- if ((pgoff | PG_PMD_COLOUR) > max_pgoff) ++ if ((pgoff | PG_PMD_COLOUR) >= max_pgoff) + goto fallback; + + /* +diff --git a/fs/ecryptfs/messaging.c b/fs/ecryptfs/messaging.c +index 286f10b0363b..4f457d5c4933 100644 +--- a/fs/ecryptfs/messaging.c ++++ b/fs/ecryptfs/messaging.c +@@ -442,15 +442,16 @@ void ecryptfs_release_messaging(void) + } + if (ecryptfs_daemon_hash) { + struct ecryptfs_daemon *daemon; ++ struct hlist_node *n; + int i; + + mutex_lock(&ecryptfs_daemon_hash_mux); + for (i = 0; i < (1 << ecryptfs_hash_bits); i++) { + int rc; + +- hlist_for_each_entry(daemon, +- &ecryptfs_daemon_hash[i], +- euid_chain) { ++ hlist_for_each_entry_safe(daemon, n, ++ &ecryptfs_daemon_hash[i], ++ euid_chain) { + rc = ecryptfs_exorcise_daemon(daemon); + if (rc) + printk(KERN_ERR "%s: Error whilst " +diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c +index 97f0fd06728d..07bca11749d4 100644 +--- a/fs/ext4/extents.c ++++ b/fs/ext4/extents.c +@@ -4794,7 +4794,8 @@ static long ext4_zero_range(struct file *file, loff_t offset, + } + + if (!(mode & FALLOC_FL_KEEP_SIZE) && +- offset + len > i_size_read(inode)) { ++ (offset + len > i_size_read(inode) || ++ offset + len > EXT4_I(inode)->i_disksize)) { + new_size = offset + len; + ret = inode_newsize_ok(inode, new_size); + if (ret) +@@ -4965,7 +4966,8 @@ long ext4_fallocate(struct file *file, int mode, loff_t offset, loff_t len) + } + + if (!(mode & FALLOC_FL_KEEP_SIZE) && +- offset + len > i_size_read(inode)) { ++ (offset + len > i_size_read(inode) || ++ offset + len > EXT4_I(inode)->i_disksize)) { + new_size = offset + len; + ret = inode_newsize_ok(inode, new_size); + if (ret) +diff --git a/fs/ext4/inline.c b/fs/ext4/inline.c +index 28c5c3abddb3..fd9501977f1c 100644 +--- a/fs/ext4/inline.c ++++ b/fs/ext4/inline.c +@@ -302,11 +302,6 @@ static int ext4_create_inline_data(handle_t *handle, + EXT4_I(inode)->i_inline_size = len + EXT4_MIN_INLINE_DATA_SIZE; + ext4_clear_inode_flag(inode, EXT4_INODE_EXTENTS); + ext4_set_inode_flag(inode, EXT4_INODE_INLINE_DATA); +- /* +- * Propagate changes to inode->i_flags as well - e.g. S_DAX may +- * get cleared +- */ +- ext4_set_inode_flags(inode); + get_bh(is.iloc.bh); + error = ext4_mark_iloc_dirty(handle, inode, &is.iloc); + +@@ -451,11 +446,6 @@ static int ext4_destroy_inline_data_nolock(handle_t *handle, + } + } + ext4_clear_inode_flag(inode, EXT4_INODE_INLINE_DATA); +- /* +- * Propagate changes to inode->i_flags as well - e.g. S_DAX may +- * get set. +- */ +- ext4_set_inode_flags(inode); + + get_bh(is.iloc.bh); + error = ext4_mark_iloc_dirty(handle, inode, &is.iloc); +diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c +index 90afeb7293a6..38eb621edd80 100644 +--- a/fs/ext4/inode.c ++++ b/fs/ext4/inode.c +@@ -5967,11 +5967,6 @@ int ext4_change_inode_journal_flag(struct inode *inode, int val) + ext4_clear_inode_flag(inode, EXT4_INODE_JOURNAL_DATA); + } + ext4_set_aops(inode); +- /* +- * Update inode->i_flags after EXT4_INODE_JOURNAL_DATA was updated. +- * E.g. S_DAX may get cleared / set. +- */ +- ext4_set_inode_flags(inode); + + jbd2_journal_unlock_updates(journal); + percpu_up_write(&sbi->s_journal_flag_rwsem); +diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c +index 75d83471f65c..d97f40396765 100644 +--- a/fs/ext4/ioctl.c ++++ b/fs/ext4/ioctl.c +@@ -291,10 +291,20 @@ static int ext4_ioctl_setflags(struct inode *inode, + if (err) + goto flags_out; + +- if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) ++ if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) { ++ /* ++ * Changes to the journaling mode can cause unsafe changes to ++ * S_DAX if we are using the DAX mount option. ++ */ ++ if (test_opt(inode->i_sb, DAX)) { ++ err = -EBUSY; ++ goto flags_out; ++ } ++ + err = ext4_change_inode_journal_flag(inode, jflag); +- if (err) +- goto flags_out; ++ if (err) ++ goto flags_out; ++ } + if (migrate) { + if (flags & EXT4_EXTENTS_FL) + err = ext4_ext_migrate(inode); +diff --git a/fs/ext4/super.c b/fs/ext4/super.c +index b0915b734a38..f29351c66610 100644 +--- a/fs/ext4/super.c ++++ b/fs/ext4/super.c +@@ -3708,6 +3708,11 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) + } + + if (sbi->s_mount_opt & EXT4_MOUNT_DAX) { ++ if (ext4_has_feature_inline_data(sb)) { ++ ext4_msg(sb, KERN_ERR, "Cannot use DAX on a filesystem" ++ " that may contain inline data"); ++ goto failed_mount; ++ } + err = bdev_dax_supported(sb, blocksize); + if (err) + goto failed_mount; +diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c +index 517e112c8a9a..6ce467872376 100644 +--- a/fs/f2fs/file.c ++++ b/fs/f2fs/file.c +@@ -683,6 +683,12 @@ int f2fs_getattr(const struct path *path, struct kstat *stat, + STATX_ATTR_NODUMP); + + generic_fillattr(inode, stat); ++ ++ /* we need to show initial sectors used for inline_data/dentries */ ++ if ((S_ISREG(inode->i_mode) && f2fs_has_inline_data(inode)) || ++ f2fs_has_inline_dentry(inode)) ++ stat->blocks += (stat->size + 511) >> 9; ++ + return 0; + } + +diff --git a/fs/isofs/isofs.h b/fs/isofs/isofs.h +index 57d4c3e2e94a..8e42b4fbefdc 100644 +--- a/fs/isofs/isofs.h ++++ b/fs/isofs/isofs.h +@@ -107,7 +107,7 @@ static inline unsigned int isonum_733(char *p) + /* Ignore bigendian datum due to broken mastering programs */ + return get_unaligned_le32(p); + } +-extern int iso_date(char *, int); ++extern int iso_date(u8 *, int); + + struct inode; /* To make gcc happy */ + +diff --git a/fs/isofs/rock.h b/fs/isofs/rock.h +index ef03625431bb..ac5cc587d718 100644 +--- a/fs/isofs/rock.h ++++ b/fs/isofs/rock.h +@@ -66,7 +66,7 @@ struct RR_PL_s { + }; + + struct stamp { +- char time[7]; ++ __u8 time[7]; /* actually 6 unsigned, 1 signed */ + } __attribute__ ((packed)); + + struct RR_TF_s { +diff --git a/fs/isofs/util.c b/fs/isofs/util.c +index 42544bf0e222..e88dba721661 100644 +--- a/fs/isofs/util.c ++++ b/fs/isofs/util.c +@@ -16,7 +16,7 @@ + * to GMT. Thus we should always be correct. + */ + +-int iso_date(char * p, int flag) ++int iso_date(u8 *p, int flag) + { + int year, month, day, hour, minute, second, tz; + int crtime; +diff --git a/fs/lockd/svc.c b/fs/lockd/svc.c +index b995bdc13976..f04ecfc7ece0 100644 +--- a/fs/lockd/svc.c ++++ b/fs/lockd/svc.c +@@ -369,6 +369,7 @@ static int lockd_start_svc(struct svc_serv *serv) + printk(KERN_WARNING + "lockd_up: svc_rqst allocation failed, error=%d\n", + error); ++ lockd_unregister_notifiers(); + goto out_rqst; + } + +@@ -459,13 +460,16 @@ int lockd_up(struct net *net) + } + + error = lockd_up_net(serv, net); +- if (error < 0) +- goto err_net; ++ if (error < 0) { ++ lockd_unregister_notifiers(); ++ goto err_put; ++ } + + error = lockd_start_svc(serv); +- if (error < 0) +- goto err_start; +- ++ if (error < 0) { ++ lockd_down_net(serv, net); ++ goto err_put; ++ } + nlmsvc_users++; + /* + * Note: svc_serv structures have an initial use count of 1, +@@ -476,12 +480,6 @@ int lockd_up(struct net *net) + err_create: + mutex_unlock(&nlmsvc_mutex); + return error; +- +-err_start: +- lockd_down_net(serv, net); +-err_net: +- lockd_unregister_notifiers(); +- goto err_put; + } + EXPORT_SYMBOL_GPL(lockd_up); + +diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c +index 5ceaeb1f6fb6..b03b3bc05f96 100644 +--- a/fs/nfs/dir.c ++++ b/fs/nfs/dir.c +@@ -1241,8 +1241,7 @@ static int nfs_weak_revalidate(struct dentry *dentry, unsigned int flags) + return 0; + } + +- if (nfs_mapping_need_revalidate_inode(inode)) +- error = __nfs_revalidate_inode(NFS_SERVER(inode), inode); ++ error = nfs_lookup_verify_inode(inode, flags); + dfprintk(LOOKUPCACHE, "NFS: %s: inode %lu is %s\n", + __func__, inode->i_ino, error ? "invalid" : "valid"); + return !error; +@@ -1393,6 +1392,7 @@ static int nfs4_lookup_revalidate(struct dentry *, unsigned int); + + const struct dentry_operations nfs4_dentry_operations = { + .d_revalidate = nfs4_lookup_revalidate, ++ .d_weak_revalidate = nfs_weak_revalidate, + .d_delete = nfs_dentry_delete, + .d_iput = nfs_dentry_iput, + .d_automount = nfs_d_automount, +diff --git a/fs/nfs/file.c b/fs/nfs/file.c +index 0214dd1e1060..81cca49a8375 100644 +--- a/fs/nfs/file.c ++++ b/fs/nfs/file.c +@@ -829,23 +829,9 @@ int nfs_flock(struct file *filp, int cmd, struct file_lock *fl) + if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK) + is_local = 1; + +- /* +- * VFS doesn't require the open mode to match a flock() lock's type. +- * NFS, however, may simulate flock() locking with posix locking which +- * requires the open mode to match the lock type. +- */ +- switch (fl->fl_type) { +- case F_UNLCK: ++ /* We're simulating flock() locks using posix locks on the server */ ++ if (fl->fl_type == F_UNLCK) + return do_unlk(filp, cmd, fl, is_local); +- case F_RDLCK: +- if (!(filp->f_mode & FMODE_READ)) +- return -EBADF; +- break; +- case F_WRLCK: +- if (!(filp->f_mode & FMODE_WRITE)) +- return -EBADF; +- } +- + return do_setlk(filp, cmd, fl, is_local); + } + EXPORT_SYMBOL_GPL(nfs_flock); +diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c +index f90090e8c959..2241d52710f7 100644 +--- a/fs/nfs/nfs4proc.c ++++ b/fs/nfs/nfs4proc.c +@@ -254,15 +254,12 @@ const u32 nfs4_fsinfo_bitmap[3] = { FATTR4_WORD0_MAXFILESIZE + }; + + const u32 nfs4_fs_locations_bitmap[3] = { +- FATTR4_WORD0_TYPE +- | FATTR4_WORD0_CHANGE ++ FATTR4_WORD0_CHANGE + | FATTR4_WORD0_SIZE + | FATTR4_WORD0_FSID + | FATTR4_WORD0_FILEID + | FATTR4_WORD0_FS_LOCATIONS, +- FATTR4_WORD1_MODE +- | FATTR4_WORD1_NUMLINKS +- | FATTR4_WORD1_OWNER ++ FATTR4_WORD1_OWNER + | FATTR4_WORD1_OWNER_GROUP + | FATTR4_WORD1_RAWDEV + | FATTR4_WORD1_SPACE_USED +@@ -6568,6 +6565,20 @@ nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request) + !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags)) + return -ENOLCK; + ++ /* ++ * Don't rely on the VFS having checked the file open mode, ++ * since it won't do this for flock() locks. ++ */ ++ switch (request->fl_type) { ++ case F_RDLCK: ++ if (!(filp->f_mode & FMODE_READ)) ++ return -EBADF; ++ break; ++ case F_WRLCK: ++ if (!(filp->f_mode & FMODE_WRITE)) ++ return -EBADF; ++ } ++ + status = nfs4_set_lock_state(state, request); + if (status != 0) + return status; +@@ -6763,9 +6774,7 @@ static int _nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir, + struct page *page) + { + struct nfs_server *server = NFS_SERVER(dir); +- u32 bitmask[3] = { +- [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS, +- }; ++ u32 bitmask[3]; + struct nfs4_fs_locations_arg args = { + .dir_fh = NFS_FH(dir), + .name = name, +@@ -6784,12 +6793,15 @@ static int _nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir, + + dprintk("%s: start\n", __func__); + ++ bitmask[0] = nfs4_fattr_bitmap[0] | FATTR4_WORD0_FS_LOCATIONS; ++ bitmask[1] = nfs4_fattr_bitmap[1]; ++ + /* Ask for the fileid of the absent filesystem if mounted_on_fileid + * is not supported */ + if (NFS_SERVER(dir)->attr_bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID) +- bitmask[1] |= FATTR4_WORD1_MOUNTED_ON_FILEID; ++ bitmask[0] &= ~FATTR4_WORD0_FILEID; + else +- bitmask[0] |= FATTR4_WORD0_FILEID; ++ bitmask[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID; + + nfs_fattr_init(&fs_locations->fattr); + fs_locations->server = server; +diff --git a/fs/nfs/nfs4trace.h b/fs/nfs/nfs4trace.h +index e7c6275519b0..71d2ca04a9f8 100644 +--- a/fs/nfs/nfs4trace.h ++++ b/fs/nfs/nfs4trace.h +@@ -202,17 +202,13 @@ DECLARE_EVENT_CLASS(nfs4_clientid_event, + TP_ARGS(clp, error), + + TP_STRUCT__entry( +- __string(dstaddr, +- rpc_peeraddr2str(clp->cl_rpcclient, +- RPC_DISPLAY_ADDR)) ++ __string(dstaddr, clp->cl_hostname) + __field(int, error) + ), + + TP_fast_assign( + __entry->error = error; +- __assign_str(dstaddr, +- rpc_peeraddr2str(clp->cl_rpcclient, +- RPC_DISPLAY_ADDR)); ++ __assign_str(dstaddr, clp->cl_hostname); + ), + + TP_printk( +@@ -1133,9 +1129,7 @@ DECLARE_EVENT_CLASS(nfs4_inode_callback_event, + __field(dev_t, dev) + __field(u32, fhandle) + __field(u64, fileid) +- __string(dstaddr, clp ? +- rpc_peeraddr2str(clp->cl_rpcclient, +- RPC_DISPLAY_ADDR) : "unknown") ++ __string(dstaddr, clp ? clp->cl_hostname : "unknown") + ), + + TP_fast_assign( +@@ -1148,9 +1142,7 @@ DECLARE_EVENT_CLASS(nfs4_inode_callback_event, + __entry->fileid = 0; + __entry->dev = 0; + } +- __assign_str(dstaddr, clp ? +- rpc_peeraddr2str(clp->cl_rpcclient, +- RPC_DISPLAY_ADDR) : "unknown") ++ __assign_str(dstaddr, clp ? clp->cl_hostname : "unknown") + ), + + TP_printk( +@@ -1192,9 +1184,7 @@ DECLARE_EVENT_CLASS(nfs4_inode_stateid_callback_event, + __field(dev_t, dev) + __field(u32, fhandle) + __field(u64, fileid) +- __string(dstaddr, clp ? +- rpc_peeraddr2str(clp->cl_rpcclient, +- RPC_DISPLAY_ADDR) : "unknown") ++ __string(dstaddr, clp ? clp->cl_hostname : "unknown") + __field(int, stateid_seq) + __field(u32, stateid_hash) + ), +@@ -1209,9 +1199,7 @@ DECLARE_EVENT_CLASS(nfs4_inode_stateid_callback_event, + __entry->fileid = 0; + __entry->dev = 0; + } +- __assign_str(dstaddr, clp ? +- rpc_peeraddr2str(clp->cl_rpcclient, +- RPC_DISPLAY_ADDR) : "unknown") ++ __assign_str(dstaddr, clp ? clp->cl_hostname : "unknown") + __entry->stateid_seq = + be32_to_cpu(stateid->seqid); + __entry->stateid_hash = +diff --git a/fs/nfs/super.c b/fs/nfs/super.c +index c9d24bae3025..216f67d628b3 100644 +--- a/fs/nfs/super.c ++++ b/fs/nfs/super.c +@@ -1332,7 +1332,7 @@ static int nfs_parse_mount_options(char *raw, + mnt->options |= NFS_OPTION_MIGRATION; + break; + case Opt_nomigration: +- mnt->options &= NFS_OPTION_MIGRATION; ++ mnt->options &= ~NFS_OPTION_MIGRATION; + break; + + /* +diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c +index 0c04f81aa63b..d386d569edbc 100644 +--- a/fs/nfsd/nfs4state.c ++++ b/fs/nfsd/nfs4state.c +@@ -3966,7 +3966,8 @@ static struct nfs4_delegation *find_deleg_stateid(struct nfs4_client *cl, statei + { + struct nfs4_stid *ret; + +- ret = find_stateid_by_type(cl, s, NFS4_DELEG_STID); ++ ret = find_stateid_by_type(cl, s, ++ NFS4_DELEG_STID|NFS4_REVOKED_DELEG_STID); + if (!ret) + return NULL; + return delegstateid(ret); +@@ -3989,6 +3990,12 @@ nfs4_check_deleg(struct nfs4_client *cl, struct nfsd4_open *open, + deleg = find_deleg_stateid(cl, &open->op_delegate_stateid); + if (deleg == NULL) + goto out; ++ if (deleg->dl_stid.sc_type == NFS4_REVOKED_DELEG_STID) { ++ nfs4_put_stid(&deleg->dl_stid); ++ if (cl->cl_minorversion) ++ status = nfserr_deleg_revoked; ++ goto out; ++ } + flags = share_access_to_flags(open->op_share_access); + status = nfs4_check_delegmode(deleg, flags); + if (status) { +@@ -4858,6 +4865,16 @@ nfsd4_lookup_stateid(struct nfsd4_compound_state *cstate, + struct nfs4_stid **s, struct nfsd_net *nn) + { + __be32 status; ++ bool return_revoked = false; ++ ++ /* ++ * only return revoked delegations if explicitly asked. ++ * otherwise we report revoked or bad_stateid status. ++ */ ++ if (typemask & NFS4_REVOKED_DELEG_STID) ++ return_revoked = true; ++ else if (typemask & NFS4_DELEG_STID) ++ typemask |= NFS4_REVOKED_DELEG_STID; + + if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) + return nfserr_bad_stateid; +@@ -4872,6 +4889,12 @@ nfsd4_lookup_stateid(struct nfsd4_compound_state *cstate, + *s = find_stateid_by_type(cstate->clp, stateid, typemask); + if (!*s) + return nfserr_bad_stateid; ++ if (((*s)->sc_type == NFS4_REVOKED_DELEG_STID) && !return_revoked) { ++ nfs4_put_stid(*s); ++ if (cstate->minorversion) ++ return nfserr_deleg_revoked; ++ return nfserr_bad_stateid; ++ } + return nfs_ok; + } + +diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c +index 70ded52dc1dd..50e12956c737 100644 +--- a/fs/nilfs2/segment.c ++++ b/fs/nilfs2/segment.c +@@ -1958,8 +1958,6 @@ static int nilfs_segctor_collect_dirty_files(struct nilfs_sc_info *sci, + err, ii->vfs_inode.i_ino); + return err; + } +- mark_buffer_dirty(ibh); +- nilfs_mdt_mark_dirty(ifile); + spin_lock(&nilfs->ns_inode_lock); + if (likely(!ii->i_bh)) + ii->i_bh = ibh; +@@ -1968,6 +1966,10 @@ static int nilfs_segctor_collect_dirty_files(struct nilfs_sc_info *sci, + goto retry; + } + ++ // Always redirty the buffer to avoid race condition ++ mark_buffer_dirty(ii->i_bh); ++ nilfs_mdt_mark_dirty(ifile); ++ + clear_bit(NILFS_I_QUEUED, &ii->i_state); + set_bit(NILFS_I_BUSY, &ii->i_state); + list_move_tail(&ii->i_dirty, &sci->sc_dirty_files); +diff --git a/fs/notify/fanotify/fanotify.c b/fs/notify/fanotify/fanotify.c +index 09640b546363..3c7053207297 100644 +--- a/fs/notify/fanotify/fanotify.c ++++ b/fs/notify/fanotify/fanotify.c +@@ -65,19 +65,8 @@ static int fanotify_get_response(struct fsnotify_group *group, + + pr_debug("%s: group=%p event=%p\n", __func__, group, event); + +- /* +- * fsnotify_prepare_user_wait() fails if we race with mark deletion. +- * Just let the operation pass in that case. +- */ +- if (!fsnotify_prepare_user_wait(iter_info)) { +- event->response = FAN_ALLOW; +- goto out; +- } +- + wait_event(group->fanotify_data.access_waitq, event->response); + +- fsnotify_finish_user_wait(iter_info); +-out: + /* userspace responded, convert to something usable */ + switch (event->response) { + case FAN_ALLOW: +@@ -212,9 +201,21 @@ static int fanotify_handle_event(struct fsnotify_group *group, + pr_debug("%s: group=%p inode=%p mask=%x\n", __func__, group, inode, + mask); + ++#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS ++ if (mask & FAN_ALL_PERM_EVENTS) { ++ /* ++ * fsnotify_prepare_user_wait() fails if we race with mark ++ * deletion. Just let the operation pass in that case. ++ */ ++ if (!fsnotify_prepare_user_wait(iter_info)) ++ return 0; ++ } ++#endif ++ + event = fanotify_alloc_event(inode, mask, data); ++ ret = -ENOMEM; + if (unlikely(!event)) +- return -ENOMEM; ++ goto finish; + + fsn_event = &event->fse; + ret = fsnotify_add_event(group, fsn_event, fanotify_merge); +@@ -224,7 +225,8 @@ static int fanotify_handle_event(struct fsnotify_group *group, + /* Our event wasn't used in the end. Free it. */ + fsnotify_destroy_event(group, fsn_event); + +- return 0; ++ ret = 0; ++ goto finish; + } + + #ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS +@@ -233,6 +235,11 @@ static int fanotify_handle_event(struct fsnotify_group *group, + iter_info); + fsnotify_destroy_event(group, fsn_event); + } ++finish: ++ if (mask & FAN_ALL_PERM_EVENTS) ++ fsnotify_finish_user_wait(iter_info); ++#else ++finish: + #endif + return ret; + } +diff --git a/fs/notify/fsnotify.c b/fs/notify/fsnotify.c +index 0c4583b61717..074716293829 100644 +--- a/fs/notify/fsnotify.c ++++ b/fs/notify/fsnotify.c +@@ -335,6 +335,13 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is, + struct fsnotify_mark, obj_list); + vfsmount_group = vfsmount_mark->group; + } ++ /* ++ * Need to protect both marks against freeing so that we can ++ * continue iteration from this place, regardless of which mark ++ * we actually happen to send an event for. ++ */ ++ iter_info.inode_mark = inode_mark; ++ iter_info.vfsmount_mark = vfsmount_mark; + + if (inode_group && vfsmount_group) { + int cmp = fsnotify_compare_groups(inode_group, +@@ -348,9 +355,6 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is, + } + } + +- iter_info.inode_mark = inode_mark; +- iter_info.vfsmount_mark = vfsmount_mark; +- + ret = send_to_group(to_tell, inode_mark, vfsmount_mark, mask, + data, data_is, cookie, file_name, + &iter_info); +diff --git a/fs/notify/mark.c b/fs/notify/mark.c +index 9991f8826734..258d99087183 100644 +--- a/fs/notify/mark.c ++++ b/fs/notify/mark.c +@@ -109,16 +109,6 @@ void fsnotify_get_mark(struct fsnotify_mark *mark) + atomic_inc(&mark->refcnt); + } + +-/* +- * Get mark reference when we found the mark via lockless traversal of object +- * list. Mark can be already removed from the list by now and on its way to be +- * destroyed once SRCU period ends. +- */ +-static bool fsnotify_get_mark_safe(struct fsnotify_mark *mark) +-{ +- return atomic_inc_not_zero(&mark->refcnt); +-} +- + static void __fsnotify_recalc_mask(struct fsnotify_mark_connector *conn) + { + u32 new_mask = 0; +@@ -256,32 +246,60 @@ void fsnotify_put_mark(struct fsnotify_mark *mark) + FSNOTIFY_REAPER_DELAY); + } + +-bool fsnotify_prepare_user_wait(struct fsnotify_iter_info *iter_info) ++/* ++ * Get mark reference when we found the mark via lockless traversal of object ++ * list. Mark can be already removed from the list by now and on its way to be ++ * destroyed once SRCU period ends. ++ * ++ * Also pin the group so it doesn't disappear under us. ++ */ ++static bool fsnotify_get_mark_safe(struct fsnotify_mark *mark) + { +- struct fsnotify_group *group; +- +- if (WARN_ON_ONCE(!iter_info->inode_mark && !iter_info->vfsmount_mark)) +- return false; +- +- if (iter_info->inode_mark) +- group = iter_info->inode_mark->group; +- else +- group = iter_info->vfsmount_mark->group; ++ if (!mark) ++ return true; ++ ++ if (atomic_inc_not_zero(&mark->refcnt)) { ++ spin_lock(&mark->lock); ++ if (mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED) { ++ /* mark is attached, group is still alive then */ ++ atomic_inc(&mark->group->user_waits); ++ spin_unlock(&mark->lock); ++ return true; ++ } ++ spin_unlock(&mark->lock); ++ fsnotify_put_mark(mark); ++ } ++ return false; ++} + +- /* +- * Since acquisition of mark reference is an atomic op as well, we can +- * be sure this inc is seen before any effect of refcount increment. +- */ +- atomic_inc(&group->user_waits); ++/* ++ * Puts marks and wakes up group destruction if necessary. ++ * ++ * Pairs with fsnotify_get_mark_safe() ++ */ ++static void fsnotify_put_mark_wake(struct fsnotify_mark *mark) ++{ ++ if (mark) { ++ struct fsnotify_group *group = mark->group; + +- if (iter_info->inode_mark) { +- /* This can fail if mark is being removed */ +- if (!fsnotify_get_mark_safe(iter_info->inode_mark)) +- goto out_wait; ++ fsnotify_put_mark(mark); ++ /* ++ * We abuse notification_waitq on group shutdown for waiting for ++ * all marks pinned when waiting for userspace. ++ */ ++ if (atomic_dec_and_test(&group->user_waits) && group->shutdown) ++ wake_up(&group->notification_waitq); + } +- if (iter_info->vfsmount_mark) { +- if (!fsnotify_get_mark_safe(iter_info->vfsmount_mark)) +- goto out_inode; ++} ++ ++bool fsnotify_prepare_user_wait(struct fsnotify_iter_info *iter_info) ++{ ++ /* This can fail if mark is being removed */ ++ if (!fsnotify_get_mark_safe(iter_info->inode_mark)) ++ return false; ++ if (!fsnotify_get_mark_safe(iter_info->vfsmount_mark)) { ++ fsnotify_put_mark_wake(iter_info->inode_mark); ++ return false; + } + + /* +@@ -292,34 +310,13 @@ bool fsnotify_prepare_user_wait(struct fsnotify_iter_info *iter_info) + srcu_read_unlock(&fsnotify_mark_srcu, iter_info->srcu_idx); + + return true; +-out_inode: +- if (iter_info->inode_mark) +- fsnotify_put_mark(iter_info->inode_mark); +-out_wait: +- if (atomic_dec_and_test(&group->user_waits) && group->shutdown) +- wake_up(&group->notification_waitq); +- return false; + } + + void fsnotify_finish_user_wait(struct fsnotify_iter_info *iter_info) + { +- struct fsnotify_group *group = NULL; +- + iter_info->srcu_idx = srcu_read_lock(&fsnotify_mark_srcu); +- if (iter_info->inode_mark) { +- group = iter_info->inode_mark->group; +- fsnotify_put_mark(iter_info->inode_mark); +- } +- if (iter_info->vfsmount_mark) { +- group = iter_info->vfsmount_mark->group; +- fsnotify_put_mark(iter_info->vfsmount_mark); +- } +- /* +- * We abuse notification_waitq on group shutdown for waiting for all +- * marks pinned when waiting for userspace. +- */ +- if (atomic_dec_and_test(&group->user_waits) && group->shutdown) +- wake_up(&group->notification_waitq); ++ fsnotify_put_mark_wake(iter_info->inode_mark); ++ fsnotify_put_mark_wake(iter_info->vfsmount_mark); + } + + /* +diff --git a/fs/overlayfs/namei.c b/fs/overlayfs/namei.c +index a12dc10bf726..bc6d5c5a3443 100644 +--- a/fs/overlayfs/namei.c ++++ b/fs/overlayfs/namei.c +@@ -630,7 +630,7 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, + err = ovl_check_origin(upperdentry, roe->lowerstack, + roe->numlower, &stack, &ctr); + if (err) +- goto out; ++ goto out_put_upper; + } + + if (d.redirect) { +diff --git a/include/linux/genhd.h b/include/linux/genhd.h +index 44790523057f..5ade8f2a6987 100644 +--- a/include/linux/genhd.h ++++ b/include/linux/genhd.h +@@ -243,6 +243,7 @@ static inline dev_t part_devt(struct hd_struct *part) + return part_to_dev(part)->devt; + } + ++extern struct hd_struct *__disk_get_part(struct gendisk *disk, int partno); + extern struct hd_struct *disk_get_part(struct gendisk *disk, int partno); + + static inline void disk_put_part(struct hd_struct *part) +diff --git a/include/linux/irq.h b/include/linux/irq.h +index 4536286cc4d2..0d53626405bf 100644 +--- a/include/linux/irq.h ++++ b/include/linux/irq.h +@@ -211,6 +211,7 @@ struct irq_data { + * IRQD_MANAGED_SHUTDOWN - Interrupt was shutdown due to empty affinity + * mask. Applies only to affinity managed irqs. + * IRQD_SINGLE_TARGET - IRQ allows only a single affinity target ++ * IRQD_DEFAULT_TRIGGER_SET - Expected trigger already been set + */ + enum { + IRQD_TRIGGER_MASK = 0xf, +@@ -231,6 +232,7 @@ enum { + IRQD_IRQ_STARTED = (1 << 22), + IRQD_MANAGED_SHUTDOWN = (1 << 23), + IRQD_SINGLE_TARGET = (1 << 24), ++ IRQD_DEFAULT_TRIGGER_SET = (1 << 25), + }; + + #define __irqd_to_state(d) ACCESS_PRIVATE((d)->common, state_use_accessors) +@@ -260,18 +262,25 @@ static inline void irqd_mark_affinity_was_set(struct irq_data *d) + __irqd_to_state(d) |= IRQD_AFFINITY_SET; + } + ++static inline bool irqd_trigger_type_was_set(struct irq_data *d) ++{ ++ return __irqd_to_state(d) & IRQD_DEFAULT_TRIGGER_SET; ++} ++ + static inline u32 irqd_get_trigger_type(struct irq_data *d) + { + return __irqd_to_state(d) & IRQD_TRIGGER_MASK; + } + + /* +- * Must only be called inside irq_chip.irq_set_type() functions. ++ * Must only be called inside irq_chip.irq_set_type() functions or ++ * from the DT/ACPI setup code. + */ + static inline void irqd_set_trigger_type(struct irq_data *d, u32 type) + { + __irqd_to_state(d) &= ~IRQD_TRIGGER_MASK; + __irqd_to_state(d) |= type & IRQD_TRIGGER_MASK; ++ __irqd_to_state(d) |= IRQD_DEFAULT_TRIGGER_SET; + } + + static inline bool irqd_is_level_type(struct irq_data *d) +diff --git a/include/net/tls.h b/include/net/tls.h +index b89d397dd62f..c06db1eadac2 100644 +--- a/include/net/tls.h ++++ b/include/net/tls.h +@@ -35,6 +35,10 @@ + #define _TLS_OFFLOAD_H + + #include <linux/types.h> ++#include <asm/byteorder.h> ++#include <linux/socket.h> ++#include <linux/tcp.h> ++#include <net/tcp.h> + + #include <uapi/linux/tls.h> + +diff --git a/include/sound/control.h b/include/sound/control.h +index a1f1152bc687..ca13a44ae9d4 100644 +--- a/include/sound/control.h ++++ b/include/sound/control.h +@@ -249,7 +249,9 @@ int snd_ctl_add_vmaster_hook(struct snd_kcontrol *kctl, + void snd_ctl_sync_vmaster(struct snd_kcontrol *kctl, bool hook_only); + #define snd_ctl_sync_vmaster_hook(kctl) snd_ctl_sync_vmaster(kctl, true) + int snd_ctl_apply_vmaster_slaves(struct snd_kcontrol *kctl, +- int (*func)(struct snd_kcontrol *, void *), ++ int (*func)(struct snd_kcontrol *vslave, ++ struct snd_kcontrol *slave, ++ void *arg), + void *arg); + + /* +diff --git a/include/target/target_core_base.h b/include/target/target_core_base.h +index f5db145e68ec..0d924e968c94 100644 +--- a/include/target/target_core_base.h ++++ b/include/target/target_core_base.h +@@ -490,6 +490,7 @@ struct se_cmd { + #define CMD_T_STOP (1 << 5) + #define CMD_T_TAS (1 << 10) + #define CMD_T_FABRIC_STOP (1 << 11) ++#define CMD_T_PRE_EXECUTE (1 << 12) + spinlock_t t_state_lock; + struct kref cmd_kref; + struct completion t_transport_stop_comp; +diff --git a/include/trace/events/sunrpc.h b/include/trace/events/sunrpc.h +index 25a7739514cd..3868b4752324 100644 +--- a/include/trace/events/sunrpc.h ++++ b/include/trace/events/sunrpc.h +@@ -456,20 +456,22 @@ TRACE_EVENT(svc_recv, + TP_ARGS(rqst, status), + + TP_STRUCT__entry( +- __field(struct sockaddr *, addr) + __field(__be32, xid) + __field(int, status) + __field(unsigned long, flags) ++ __dynamic_array(unsigned char, addr, rqst->rq_addrlen) + ), + + TP_fast_assign( +- __entry->addr = (struct sockaddr *)&rqst->rq_addr; + __entry->xid = status > 0 ? rqst->rq_xid : 0; + __entry->status = status; + __entry->flags = rqst->rq_flags; ++ memcpy(__get_dynamic_array(addr), ++ &rqst->rq_addr, rqst->rq_addrlen); + ), + +- TP_printk("addr=%pIScp xid=0x%x status=%d flags=%s", __entry->addr, ++ TP_printk("addr=%pIScp xid=0x%x status=%d flags=%s", ++ (struct sockaddr *)__get_dynamic_array(addr), + be32_to_cpu(__entry->xid), __entry->status, + show_rqstp_flags(__entry->flags)) + ); +@@ -514,22 +516,23 @@ DECLARE_EVENT_CLASS(svc_rqst_status, + TP_ARGS(rqst, status), + + TP_STRUCT__entry( +- __field(struct sockaddr *, addr) + __field(__be32, xid) +- __field(int, dropme) + __field(int, status) + __field(unsigned long, flags) ++ __dynamic_array(unsigned char, addr, rqst->rq_addrlen) + ), + + TP_fast_assign( +- __entry->addr = (struct sockaddr *)&rqst->rq_addr; + __entry->xid = rqst->rq_xid; + __entry->status = status; + __entry->flags = rqst->rq_flags; ++ memcpy(__get_dynamic_array(addr), ++ &rqst->rq_addr, rqst->rq_addrlen); + ), + + TP_printk("addr=%pIScp rq_xid=0x%x status=%d flags=%s", +- __entry->addr, be32_to_cpu(__entry->xid), ++ (struct sockaddr *)__get_dynamic_array(addr), ++ be32_to_cpu(__entry->xid), + __entry->status, show_rqstp_flags(__entry->flags)) + ); + +diff --git a/include/uapi/linux/rxrpc.h b/include/uapi/linux/rxrpc.h +index 9656aad8f8f7..9d4afea308a4 100644 +--- a/include/uapi/linux/rxrpc.h ++++ b/include/uapi/linux/rxrpc.h +@@ -20,12 +20,12 @@ + * RxRPC socket address + */ + struct sockaddr_rxrpc { +- sa_family_t srx_family; /* address family */ +- u16 srx_service; /* service desired */ +- u16 transport_type; /* type of transport socket (SOCK_DGRAM) */ +- u16 transport_len; /* length of transport address */ ++ __kernel_sa_family_t srx_family; /* address family */ ++ __u16 srx_service; /* service desired */ ++ __u16 transport_type; /* type of transport socket (SOCK_DGRAM) */ ++ __u16 transport_len; /* length of transport address */ + union { +- sa_family_t family; /* transport address family */ ++ __kernel_sa_family_t family; /* transport address family */ + struct sockaddr_in sin; /* IPv4 transport address */ + struct sockaddr_in6 sin6; /* IPv6 transport address */ + } transport; +diff --git a/include/uapi/linux/tls.h b/include/uapi/linux/tls.h +index d5e0682ab837..293b2cdad88d 100644 +--- a/include/uapi/linux/tls.h ++++ b/include/uapi/linux/tls.h +@@ -35,10 +35,6 @@ + #define _UAPI_LINUX_TLS_H + + #include <linux/types.h> +-#include <asm/byteorder.h> +-#include <linux/socket.h> +-#include <linux/tcp.h> +-#include <net/tcp.h> + + /* TLS socket options */ + #define TLS_TX 1 /* Set transmit parameters */ +diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c +index 4bff6a10ae8e..b02caa442776 100644 +--- a/kernel/irq/manage.c ++++ b/kernel/irq/manage.c +@@ -1245,7 +1245,18 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new) + * set the trigger type must match. Also all must + * agree on ONESHOT. + */ +- unsigned int oldtype = irqd_get_trigger_type(&desc->irq_data); ++ unsigned int oldtype; ++ ++ /* ++ * If nobody did set the configuration before, inherit ++ * the one provided by the requester. ++ */ ++ if (irqd_trigger_type_was_set(&desc->irq_data)) { ++ oldtype = irqd_get_trigger_type(&desc->irq_data); ++ } else { ++ oldtype = new->flags & IRQF_TRIGGER_MASK; ++ irqd_set_trigger_type(&desc->irq_data, oldtype); ++ } + + if (!((old->flags & new->flags) & IRQF_SHARED) || + (oldtype != (new->flags & IRQF_TRIGGER_MASK)) || +diff --git a/kernel/sched/core.c b/kernel/sched/core.c +index d17c5da523a0..8fa7b6f9e19b 100644 +--- a/kernel/sched/core.c ++++ b/kernel/sched/core.c +@@ -505,8 +505,7 @@ void resched_cpu(int cpu) + struct rq *rq = cpu_rq(cpu); + unsigned long flags; + +- if (!raw_spin_trylock_irqsave(&rq->lock, flags)) +- return; ++ raw_spin_lock_irqsave(&rq->lock, flags); + resched_curr(rq); + raw_spin_unlock_irqrestore(&rq->lock, flags); + } +diff --git a/kernel/sched/cpufreq_schedutil.c b/kernel/sched/cpufreq_schedutil.c +index ba0da243fdd8..2f52ec0f1539 100644 +--- a/kernel/sched/cpufreq_schedutil.c ++++ b/kernel/sched/cpufreq_schedutil.c +@@ -282,8 +282,12 @@ static void sugov_update_single(struct update_util_data *hook, u64 time, + * Do not reduce the frequency if the CPU has not been idle + * recently, as the reduction is likely to be premature then. + */ +- if (busy && next_f < sg_policy->next_freq) ++ if (busy && next_f < sg_policy->next_freq) { + next_f = sg_policy->next_freq; ++ ++ /* Reset cached freq as next_freq has changed */ ++ sg_policy->cached_raw_freq = 0; ++ } + } + sugov_update_commit(sg_policy, time, next_f); + } +diff --git a/kernel/sched/rt.c b/kernel/sched/rt.c +index 3c96c80e0992..d8c43d73e078 100644 +--- a/kernel/sched/rt.c ++++ b/kernel/sched/rt.c +@@ -74,10 +74,6 @@ static void start_rt_bandwidth(struct rt_bandwidth *rt_b) + raw_spin_unlock(&rt_b->rt_runtime_lock); + } + +-#if defined(CONFIG_SMP) && defined(HAVE_RT_PUSH_IPI) +-static void push_irq_work_func(struct irq_work *work); +-#endif +- + void init_rt_rq(struct rt_rq *rt_rq) + { + struct rt_prio_array *array; +@@ -97,13 +93,6 @@ void init_rt_rq(struct rt_rq *rt_rq) + rt_rq->rt_nr_migratory = 0; + rt_rq->overloaded = 0; + plist_head_init(&rt_rq->pushable_tasks); +- +-#ifdef HAVE_RT_PUSH_IPI +- rt_rq->push_flags = 0; +- rt_rq->push_cpu = nr_cpu_ids; +- raw_spin_lock_init(&rt_rq->push_lock); +- init_irq_work(&rt_rq->push_work, push_irq_work_func); +-#endif + #endif /* CONFIG_SMP */ + /* We start is dequeued state, because no RT tasks are queued */ + rt_rq->rt_queued = 0; +@@ -1876,241 +1865,166 @@ static void push_rt_tasks(struct rq *rq) + } + + #ifdef HAVE_RT_PUSH_IPI ++ + /* +- * The search for the next cpu always starts at rq->cpu and ends +- * when we reach rq->cpu again. It will never return rq->cpu. +- * This returns the next cpu to check, or nr_cpu_ids if the loop +- * is complete. ++ * When a high priority task schedules out from a CPU and a lower priority ++ * task is scheduled in, a check is made to see if there's any RT tasks ++ * on other CPUs that are waiting to run because a higher priority RT task ++ * is currently running on its CPU. In this case, the CPU with multiple RT ++ * tasks queued on it (overloaded) needs to be notified that a CPU has opened ++ * up that may be able to run one of its non-running queued RT tasks. ++ * ++ * All CPUs with overloaded RT tasks need to be notified as there is currently ++ * no way to know which of these CPUs have the highest priority task waiting ++ * to run. Instead of trying to take a spinlock on each of these CPUs, ++ * which has shown to cause large latency when done on machines with many ++ * CPUs, sending an IPI to the CPUs to have them push off the overloaded ++ * RT tasks waiting to run. ++ * ++ * Just sending an IPI to each of the CPUs is also an issue, as on large ++ * count CPU machines, this can cause an IPI storm on a CPU, especially ++ * if its the only CPU with multiple RT tasks queued, and a large number ++ * of CPUs scheduling a lower priority task at the same time. ++ * ++ * Each root domain has its own irq work function that can iterate over ++ * all CPUs with RT overloaded tasks. Since all CPUs with overloaded RT ++ * tassk must be checked if there's one or many CPUs that are lowering ++ * their priority, there's a single irq work iterator that will try to ++ * push off RT tasks that are waiting to run. ++ * ++ * When a CPU schedules a lower priority task, it will kick off the ++ * irq work iterator that will jump to each CPU with overloaded RT tasks. ++ * As it only takes the first CPU that schedules a lower priority task ++ * to start the process, the rto_start variable is incremented and if ++ * the atomic result is one, then that CPU will try to take the rto_lock. ++ * This prevents high contention on the lock as the process handles all ++ * CPUs scheduling lower priority tasks. ++ * ++ * All CPUs that are scheduling a lower priority task will increment the ++ * rt_loop_next variable. This will make sure that the irq work iterator ++ * checks all RT overloaded CPUs whenever a CPU schedules a new lower ++ * priority task, even if the iterator is in the middle of a scan. Incrementing ++ * the rt_loop_next will cause the iterator to perform another scan. + * +- * rq->rt.push_cpu holds the last cpu returned by this function, +- * or if this is the first instance, it must hold rq->cpu. + */ + static int rto_next_cpu(struct rq *rq) + { +- int prev_cpu = rq->rt.push_cpu; ++ struct root_domain *rd = rq->rd; ++ int next; + int cpu; + +- cpu = cpumask_next(prev_cpu, rq->rd->rto_mask); +- + /* +- * If the previous cpu is less than the rq's CPU, then it already +- * passed the end of the mask, and has started from the beginning. +- * We end if the next CPU is greater or equal to rq's CPU. ++ * When starting the IPI RT pushing, the rto_cpu is set to -1, ++ * rt_next_cpu() will simply return the first CPU found in ++ * the rto_mask. ++ * ++ * If rto_next_cpu() is called with rto_cpu is a valid cpu, it ++ * will return the next CPU found in the rto_mask. ++ * ++ * If there are no more CPUs left in the rto_mask, then a check is made ++ * against rto_loop and rto_loop_next. rto_loop is only updated with ++ * the rto_lock held, but any CPU may increment the rto_loop_next ++ * without any locking. + */ +- if (prev_cpu < rq->cpu) { +- if (cpu >= rq->cpu) +- return nr_cpu_ids; ++ for (;;) { + +- } else if (cpu >= nr_cpu_ids) { +- /* +- * We passed the end of the mask, start at the beginning. +- * If the result is greater or equal to the rq's CPU, then +- * the loop is finished. +- */ +- cpu = cpumask_first(rq->rd->rto_mask); +- if (cpu >= rq->cpu) +- return nr_cpu_ids; +- } +- rq->rt.push_cpu = cpu; ++ /* When rto_cpu is -1 this acts like cpumask_first() */ ++ cpu = cpumask_next(rd->rto_cpu, rd->rto_mask); + +- /* Return cpu to let the caller know if the loop is finished or not */ +- return cpu; +-} ++ rd->rto_cpu = cpu; + +-static int find_next_push_cpu(struct rq *rq) +-{ +- struct rq *next_rq; +- int cpu; ++ if (cpu < nr_cpu_ids) ++ return cpu; + +- while (1) { +- cpu = rto_next_cpu(rq); +- if (cpu >= nr_cpu_ids) +- break; +- next_rq = cpu_rq(cpu); ++ rd->rto_cpu = -1; ++ ++ /* ++ * ACQUIRE ensures we see the @rto_mask changes ++ * made prior to the @next value observed. ++ * ++ * Matches WMB in rt_set_overload(). ++ */ ++ next = atomic_read_acquire(&rd->rto_loop_next); + +- /* Make sure the next rq can push to this rq */ +- if (next_rq->rt.highest_prio.next < rq->rt.highest_prio.curr) ++ if (rd->rto_loop == next) + break; ++ ++ rd->rto_loop = next; + } + +- return cpu; ++ return -1; + } + +-#define RT_PUSH_IPI_EXECUTING 1 +-#define RT_PUSH_IPI_RESTART 2 ++static inline bool rto_start_trylock(atomic_t *v) ++{ ++ return !atomic_cmpxchg_acquire(v, 0, 1); ++} + +-/* +- * When a high priority task schedules out from a CPU and a lower priority +- * task is scheduled in, a check is made to see if there's any RT tasks +- * on other CPUs that are waiting to run because a higher priority RT task +- * is currently running on its CPU. In this case, the CPU with multiple RT +- * tasks queued on it (overloaded) needs to be notified that a CPU has opened +- * up that may be able to run one of its non-running queued RT tasks. +- * +- * On large CPU boxes, there's the case that several CPUs could schedule +- * a lower priority task at the same time, in which case it will look for +- * any overloaded CPUs that it could pull a task from. To do this, the runqueue +- * lock must be taken from that overloaded CPU. Having 10s of CPUs all fighting +- * for a single overloaded CPU's runqueue lock can produce a large latency. +- * (This has actually been observed on large boxes running cyclictest). +- * Instead of taking the runqueue lock of the overloaded CPU, each of the +- * CPUs that scheduled a lower priority task simply sends an IPI to the +- * overloaded CPU. An IPI is much cheaper than taking an runqueue lock with +- * lots of contention. The overloaded CPU will look to push its non-running +- * RT task off, and if it does, it can then ignore the other IPIs coming +- * in, and just pass those IPIs off to any other overloaded CPU. +- * +- * When a CPU schedules a lower priority task, it only sends an IPI to +- * the "next" CPU that has overloaded RT tasks. This prevents IPI storms, +- * as having 10 CPUs scheduling lower priority tasks and 10 CPUs with +- * RT overloaded tasks, would cause 100 IPIs to go out at once. +- * +- * The overloaded RT CPU, when receiving an IPI, will try to push off its +- * overloaded RT tasks and then send an IPI to the next CPU that has +- * overloaded RT tasks. This stops when all CPUs with overloaded RT tasks +- * have completed. Just because a CPU may have pushed off its own overloaded +- * RT task does not mean it should stop sending the IPI around to other +- * overloaded CPUs. There may be another RT task waiting to run on one of +- * those CPUs that are of higher priority than the one that was just +- * pushed. +- * +- * An optimization that could possibly be made is to make a CPU array similar +- * to the cpupri array mask of all running RT tasks, but for the overloaded +- * case, then the IPI could be sent to only the CPU with the highest priority +- * RT task waiting, and that CPU could send off further IPIs to the CPU with +- * the next highest waiting task. Since the overloaded case is much less likely +- * to happen, the complexity of this implementation may not be worth it. +- * Instead, just send an IPI around to all overloaded CPUs. +- * +- * The rq->rt.push_flags holds the status of the IPI that is going around. +- * A run queue can only send out a single IPI at a time. The possible flags +- * for rq->rt.push_flags are: +- * +- * (None or zero): No IPI is going around for the current rq +- * RT_PUSH_IPI_EXECUTING: An IPI for the rq is being passed around +- * RT_PUSH_IPI_RESTART: The priority of the running task for the rq +- * has changed, and the IPI should restart +- * circulating the overloaded CPUs again. +- * +- * rq->rt.push_cpu contains the CPU that is being sent the IPI. It is updated +- * before sending to the next CPU. +- * +- * Instead of having all CPUs that schedule a lower priority task send +- * an IPI to the same "first" CPU in the RT overload mask, they send it +- * to the next overloaded CPU after their own CPU. This helps distribute +- * the work when there's more than one overloaded CPU and multiple CPUs +- * scheduling in lower priority tasks. +- * +- * When a rq schedules a lower priority task than what was currently +- * running, the next CPU with overloaded RT tasks is examined first. +- * That is, if CPU 1 and 5 are overloaded, and CPU 3 schedules a lower +- * priority task, it will send an IPI first to CPU 5, then CPU 5 will +- * send to CPU 1 if it is still overloaded. CPU 1 will clear the +- * rq->rt.push_flags if RT_PUSH_IPI_RESTART is not set. +- * +- * The first CPU to notice IPI_RESTART is set, will clear that flag and then +- * send an IPI to the next overloaded CPU after the rq->cpu and not the next +- * CPU after push_cpu. That is, if CPU 1, 4 and 5 are overloaded when CPU 3 +- * schedules a lower priority task, and the IPI_RESTART gets set while the +- * handling is being done on CPU 5, it will clear the flag and send it back to +- * CPU 4 instead of CPU 1. +- * +- * Note, the above logic can be disabled by turning off the sched_feature +- * RT_PUSH_IPI. Then the rq lock of the overloaded CPU will simply be +- * taken by the CPU requesting a pull and the waiting RT task will be pulled +- * by that CPU. This may be fine for machines with few CPUs. +- */ +-static void tell_cpu_to_push(struct rq *rq) ++static inline void rto_start_unlock(atomic_t *v) + { +- int cpu; ++ atomic_set_release(v, 0); ++} + +- if (rq->rt.push_flags & RT_PUSH_IPI_EXECUTING) { +- raw_spin_lock(&rq->rt.push_lock); +- /* Make sure it's still executing */ +- if (rq->rt.push_flags & RT_PUSH_IPI_EXECUTING) { +- /* +- * Tell the IPI to restart the loop as things have +- * changed since it started. +- */ +- rq->rt.push_flags |= RT_PUSH_IPI_RESTART; +- raw_spin_unlock(&rq->rt.push_lock); +- return; +- } +- raw_spin_unlock(&rq->rt.push_lock); +- } ++static void tell_cpu_to_push(struct rq *rq) ++{ ++ int cpu = -1; + +- /* When here, there's no IPI going around */ ++ /* Keep the loop going if the IPI is currently active */ ++ atomic_inc(&rq->rd->rto_loop_next); + +- rq->rt.push_cpu = rq->cpu; +- cpu = find_next_push_cpu(rq); +- if (cpu >= nr_cpu_ids) ++ /* Only one CPU can initiate a loop at a time */ ++ if (!rto_start_trylock(&rq->rd->rto_loop_start)) + return; + +- rq->rt.push_flags = RT_PUSH_IPI_EXECUTING; ++ raw_spin_lock(&rq->rd->rto_lock); ++ ++ /* ++ * The rto_cpu is updated under the lock, if it has a valid cpu ++ * then the IPI is still running and will continue due to the ++ * update to loop_next, and nothing needs to be done here. ++ * Otherwise it is finishing up and an ipi needs to be sent. ++ */ ++ if (rq->rd->rto_cpu < 0) ++ cpu = rto_next_cpu(rq); + +- irq_work_queue_on(&rq->rt.push_work, cpu); ++ raw_spin_unlock(&rq->rd->rto_lock); ++ ++ rto_start_unlock(&rq->rd->rto_loop_start); ++ ++ if (cpu >= 0) ++ irq_work_queue_on(&rq->rd->rto_push_work, cpu); + } + + /* Called from hardirq context */ +-static void try_to_push_tasks(void *arg) ++void rto_push_irq_work_func(struct irq_work *work) + { +- struct rt_rq *rt_rq = arg; +- struct rq *rq, *src_rq; +- int this_cpu; ++ struct rq *rq; + int cpu; + +- this_cpu = rt_rq->push_cpu; ++ rq = this_rq(); + +- /* Paranoid check */ +- BUG_ON(this_cpu != smp_processor_id()); +- +- rq = cpu_rq(this_cpu); +- src_rq = rq_of_rt_rq(rt_rq); +- +-again: ++ /* ++ * We do not need to grab the lock to check for has_pushable_tasks. ++ * When it gets updated, a check is made if a push is possible. ++ */ + if (has_pushable_tasks(rq)) { + raw_spin_lock(&rq->lock); +- push_rt_task(rq); ++ push_rt_tasks(rq); + raw_spin_unlock(&rq->lock); + } + +- /* Pass the IPI to the next rt overloaded queue */ +- raw_spin_lock(&rt_rq->push_lock); +- /* +- * If the source queue changed since the IPI went out, +- * we need to restart the search from that CPU again. +- */ +- if (rt_rq->push_flags & RT_PUSH_IPI_RESTART) { +- rt_rq->push_flags &= ~RT_PUSH_IPI_RESTART; +- rt_rq->push_cpu = src_rq->cpu; +- } ++ raw_spin_lock(&rq->rd->rto_lock); + +- cpu = find_next_push_cpu(src_rq); ++ /* Pass the IPI to the next rt overloaded queue */ ++ cpu = rto_next_cpu(rq); + +- if (cpu >= nr_cpu_ids) +- rt_rq->push_flags &= ~RT_PUSH_IPI_EXECUTING; +- raw_spin_unlock(&rt_rq->push_lock); ++ raw_spin_unlock(&rq->rd->rto_lock); + +- if (cpu >= nr_cpu_ids) ++ if (cpu < 0) + return; + +- /* +- * It is possible that a restart caused this CPU to be +- * chosen again. Don't bother with an IPI, just see if we +- * have more to push. +- */ +- if (unlikely(cpu == rq->cpu)) +- goto again; +- + /* Try the next RT overloaded CPU */ +- irq_work_queue_on(&rt_rq->push_work, cpu); +-} +- +-static void push_irq_work_func(struct irq_work *work) +-{ +- struct rt_rq *rt_rq = container_of(work, struct rt_rq, push_work); +- +- try_to_push_tasks(rt_rq); ++ irq_work_queue_on(&rq->rd->rto_push_work, cpu); + } + #endif /* HAVE_RT_PUSH_IPI */ + +diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h +index 3b448ba82225..b732e779fe7d 100644 +--- a/kernel/sched/sched.h ++++ b/kernel/sched/sched.h +@@ -502,7 +502,7 @@ static inline int rt_bandwidth_enabled(void) + } + + /* RT IPI pull logic requires IRQ_WORK */ +-#ifdef CONFIG_IRQ_WORK ++#if defined(CONFIG_IRQ_WORK) && defined(CONFIG_SMP) + # define HAVE_RT_PUSH_IPI + #endif + +@@ -524,12 +524,6 @@ struct rt_rq { + unsigned long rt_nr_total; + int overloaded; + struct plist_head pushable_tasks; +-#ifdef HAVE_RT_PUSH_IPI +- int push_flags; +- int push_cpu; +- struct irq_work push_work; +- raw_spinlock_t push_lock; +-#endif + #endif /* CONFIG_SMP */ + int rt_queued; + +@@ -638,6 +632,19 @@ struct root_domain { + struct dl_bw dl_bw; + struct cpudl cpudl; + ++#ifdef HAVE_RT_PUSH_IPI ++ /* ++ * For IPI pull requests, loop across the rto_mask. ++ */ ++ struct irq_work rto_push_work; ++ raw_spinlock_t rto_lock; ++ /* These are only updated and read within rto_lock */ ++ int rto_loop; ++ int rto_cpu; ++ /* These atomics are updated outside of a lock */ ++ atomic_t rto_loop_next; ++ atomic_t rto_loop_start; ++#endif + /* + * The "RT overload" flag: it gets set if a CPU has more than + * one runnable RT task. +@@ -655,6 +662,9 @@ extern void init_defrootdomain(void); + extern int sched_init_domains(const struct cpumask *cpu_map); + extern void rq_attach_root(struct rq *rq, struct root_domain *rd); + ++#ifdef HAVE_RT_PUSH_IPI ++extern void rto_push_irq_work_func(struct irq_work *work); ++#endif + #endif /* CONFIG_SMP */ + + /* +diff --git a/kernel/sched/topology.c b/kernel/sched/topology.c +index 6798276d29af..093f2ceba2e2 100644 +--- a/kernel/sched/topology.c ++++ b/kernel/sched/topology.c +@@ -269,6 +269,12 @@ static int init_rootdomain(struct root_domain *rd) + if (!zalloc_cpumask_var(&rd->rto_mask, GFP_KERNEL)) + goto free_dlo_mask; + ++#ifdef HAVE_RT_PUSH_IPI ++ rd->rto_cpu = -1; ++ raw_spin_lock_init(&rd->rto_lock); ++ init_irq_work(&rd->rto_push_work, rto_push_irq_work_func); ++#endif ++ + init_dl_bw(&rd->dl_bw); + if (cpudl_init(&rd->cpudl) != 0) + goto free_rto_mask; +diff --git a/lib/mpi/mpi-pow.c b/lib/mpi/mpi-pow.c +index e24388a863a7..468fb7cd1221 100644 +--- a/lib/mpi/mpi-pow.c ++++ b/lib/mpi/mpi-pow.c +@@ -26,6 +26,7 @@ + * however I decided to publish this code under the plain GPL. + */ + ++#include <linux/sched.h> + #include <linux/string.h> + #include "mpi-internal.h" + #include "longlong.h" +@@ -256,6 +257,7 @@ int mpi_powm(MPI res, MPI base, MPI exp, MPI mod) + } + e <<= 1; + c--; ++ cond_resched(); + } + + i--; +diff --git a/mm/z3fold.c b/mm/z3fold.c +index b2ba2ba585f3..39e19125d6a0 100644 +--- a/mm/z3fold.c ++++ b/mm/z3fold.c +@@ -404,8 +404,7 @@ static void do_compact_page(struct z3fold_header *zhdr, bool locked) + WARN_ON(z3fold_page_trylock(zhdr)); + else + z3fold_page_lock(zhdr); +- if (test_bit(PAGE_STALE, &page->private) || +- !test_and_clear_bit(NEEDS_COMPACTING, &page->private)) { ++ if (WARN_ON(!test_and_clear_bit(NEEDS_COMPACTING, &page->private))) { + z3fold_page_unlock(zhdr); + return; + } +@@ -413,6 +412,11 @@ static void do_compact_page(struct z3fold_header *zhdr, bool locked) + list_del_init(&zhdr->buddy); + spin_unlock(&pool->lock); + ++ if (kref_put(&zhdr->refcount, release_z3fold_page_locked)) { ++ atomic64_dec(&pool->pages_nr); ++ return; ++ } ++ + z3fold_compact_page(zhdr); + unbuddied = get_cpu_ptr(pool->unbuddied); + fchunks = num_free_chunks(zhdr); +@@ -753,9 +757,11 @@ static void z3fold_free(struct z3fold_pool *pool, unsigned long handle) + list_del_init(&zhdr->buddy); + spin_unlock(&pool->lock); + zhdr->cpu = -1; ++ kref_get(&zhdr->refcount); + do_compact_page(zhdr, true); + return; + } ++ kref_get(&zhdr->refcount); + queue_work_on(zhdr->cpu, pool->compact_wq, &zhdr->work); + z3fold_page_unlock(zhdr); + } +diff --git a/net/9p/client.c b/net/9p/client.c +index 4674235b0d9b..b433aff5ff13 100644 +--- a/net/9p/client.c ++++ b/net/9p/client.c +@@ -82,7 +82,7 @@ int p9_show_client_options(struct seq_file *m, struct p9_client *clnt) + { + if (clnt->msize != 8192) + seq_printf(m, ",msize=%u", clnt->msize); +- seq_printf(m, "trans=%s", clnt->trans_mod->name); ++ seq_printf(m, ",trans=%s", clnt->trans_mod->name); + + switch (clnt->proto_version) { + case p9_proto_legacy: +@@ -773,8 +773,7 @@ p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...) + } + again: + /* Wait for the response */ +- err = wait_event_interruptible(*req->wq, +- req->status >= REQ_STATUS_RCVD); ++ err = wait_event_killable(*req->wq, req->status >= REQ_STATUS_RCVD); + + /* + * Make sure our req is coherent with regard to updates in other +diff --git a/net/9p/trans_fd.c b/net/9p/trans_fd.c +index 903a190319b9..985046ae4231 100644 +--- a/net/9p/trans_fd.c ++++ b/net/9p/trans_fd.c +@@ -724,12 +724,12 @@ static int p9_fd_show_options(struct seq_file *m, struct p9_client *clnt) + { + if (clnt->trans_mod == &p9_tcp_trans) { + if (clnt->trans_opts.tcp.port != P9_PORT) +- seq_printf(m, "port=%u", clnt->trans_opts.tcp.port); ++ seq_printf(m, ",port=%u", clnt->trans_opts.tcp.port); + } else if (clnt->trans_mod == &p9_fd_trans) { + if (clnt->trans_opts.fd.rfd != ~0) +- seq_printf(m, "rfd=%u", clnt->trans_opts.fd.rfd); ++ seq_printf(m, ",rfd=%u", clnt->trans_opts.fd.rfd); + if (clnt->trans_opts.fd.wfd != ~0) +- seq_printf(m, "wfd=%u", clnt->trans_opts.fd.wfd); ++ seq_printf(m, ",wfd=%u", clnt->trans_opts.fd.wfd); + } + return 0; + } +diff --git a/net/9p/trans_virtio.c b/net/9p/trans_virtio.c +index f24b25c25106..f3a4efcf1456 100644 +--- a/net/9p/trans_virtio.c ++++ b/net/9p/trans_virtio.c +@@ -286,8 +286,8 @@ p9_virtio_request(struct p9_client *client, struct p9_req_t *req) + if (err == -ENOSPC) { + chan->ring_bufs_avail = 0; + spin_unlock_irqrestore(&chan->lock, flags); +- err = wait_event_interruptible(*chan->vc_wq, +- chan->ring_bufs_avail); ++ err = wait_event_killable(*chan->vc_wq, ++ chan->ring_bufs_avail); + if (err == -ERESTARTSYS) + return err; + +@@ -327,7 +327,7 @@ static int p9_get_mapped_pages(struct virtio_chan *chan, + * Other zc request to finish here + */ + if (atomic_read(&vp_pinned) >= chan->p9_max_pages) { +- err = wait_event_interruptible(vp_wq, ++ err = wait_event_killable(vp_wq, + (atomic_read(&vp_pinned) < chan->p9_max_pages)); + if (err == -ERESTARTSYS) + return err; +@@ -471,8 +471,8 @@ p9_virtio_zc_request(struct p9_client *client, struct p9_req_t *req, + if (err == -ENOSPC) { + chan->ring_bufs_avail = 0; + spin_unlock_irqrestore(&chan->lock, flags); +- err = wait_event_interruptible(*chan->vc_wq, +- chan->ring_bufs_avail); ++ err = wait_event_killable(*chan->vc_wq, ++ chan->ring_bufs_avail); + if (err == -ERESTARTSYS) + goto err_out; + +@@ -489,8 +489,7 @@ p9_virtio_zc_request(struct p9_client *client, struct p9_req_t *req, + virtqueue_kick(chan->vq); + spin_unlock_irqrestore(&chan->lock, flags); + p9_debug(P9_DEBUG_TRANS, "virtio request kicked\n"); +- err = wait_event_interruptible(*req->wq, +- req->status >= REQ_STATUS_RCVD); ++ err = wait_event_killable(*req->wq, req->status >= REQ_STATUS_RCVD); + /* + * Non kernel buffers are pinned, unpin them + */ +diff --git a/net/9p/trans_xen.c b/net/9p/trans_xen.c +index 6ad3e043c617..325c56043007 100644 +--- a/net/9p/trans_xen.c ++++ b/net/9p/trans_xen.c +@@ -156,8 +156,8 @@ static int p9_xen_request(struct p9_client *client, struct p9_req_t *p9_req) + ring = &priv->rings[num]; + + again: +- while (wait_event_interruptible(ring->wq, +- p9_xen_write_todo(ring, size)) != 0) ++ while (wait_event_killable(ring->wq, ++ p9_xen_write_todo(ring, size)) != 0) + ; + + spin_lock_irqsave(&ring->lock, flags); +diff --git a/net/ceph/crypto.c b/net/ceph/crypto.c +index 489610ac1cdd..bf9d079cbafd 100644 +--- a/net/ceph/crypto.c ++++ b/net/ceph/crypto.c +@@ -37,7 +37,9 @@ static int set_secret(struct ceph_crypto_key *key, void *buf) + return -ENOTSUPP; + } + +- WARN_ON(!key->len); ++ if (!key->len) ++ return -EINVAL; ++ + key->key = kmemdup(buf, key->len, GFP_NOIO); + if (!key->key) { + ret = -ENOMEM; +diff --git a/net/nfc/core.c b/net/nfc/core.c +index 5cf33df888c3..c699d64a0753 100644 +--- a/net/nfc/core.c ++++ b/net/nfc/core.c +@@ -1106,7 +1106,7 @@ struct nfc_dev *nfc_allocate_device(struct nfc_ops *ops, + err_free_dev: + kfree(dev); + +- return ERR_PTR(rc); ++ return NULL; + } + EXPORT_SYMBOL(nfc_allocate_device); + +diff --git a/net/sunrpc/xprtrdma/svc_rdma_backchannel.c b/net/sunrpc/xprtrdma/svc_rdma_backchannel.c +index 992594b7cc6b..af7893501e40 100644 +--- a/net/sunrpc/xprtrdma/svc_rdma_backchannel.c ++++ b/net/sunrpc/xprtrdma/svc_rdma_backchannel.c +@@ -133,6 +133,10 @@ static int svc_rdma_bc_sendto(struct svcxprt_rdma *rdma, + if (ret) + goto out_err; + ++ /* Bump page refcnt so Send completion doesn't release ++ * the rq_buffer before all retransmits are complete. ++ */ ++ get_page(virt_to_page(rqst->rq_buffer)); + ret = svc_rdma_post_send_wr(rdma, ctxt, 1, 0); + if (ret) + goto out_unmap; +@@ -165,7 +169,6 @@ xprt_rdma_bc_allocate(struct rpc_task *task) + return -EINVAL; + } + +- /* svc_rdma_sendto releases this page */ + page = alloc_page(RPCRDMA_DEF_GFP); + if (!page) + return -ENOMEM; +@@ -184,6 +187,7 @@ xprt_rdma_bc_free(struct rpc_task *task) + { + struct rpc_rqst *rqst = task->tk_rqstp; + ++ put_page(virt_to_page(rqst->rq_buffer)); + kfree(rqst->rq_rbuffer); + } + +diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c +index a93a4235a332..10e7ef7a8804 100644 +--- a/sound/core/pcm_lib.c ++++ b/sound/core/pcm_lib.c +@@ -248,8 +248,10 @@ static void update_audio_tstamp(struct snd_pcm_substream *substream, + runtime->rate); + *audio_tstamp = ns_to_timespec(audio_nsecs); + } +- runtime->status->audio_tstamp = *audio_tstamp; +- runtime->status->tstamp = *curr_tstamp; ++ if (!timespec_equal(&runtime->status->audio_tstamp, audio_tstamp)) { ++ runtime->status->audio_tstamp = *audio_tstamp; ++ runtime->status->tstamp = *curr_tstamp; ++ } + + /* + * re-take a driver timestamp to let apps detect if the reference tstamp +diff --git a/sound/core/timer_compat.c b/sound/core/timer_compat.c +index 59127b6ef39e..e00f7e399e46 100644 +--- a/sound/core/timer_compat.c ++++ b/sound/core/timer_compat.c +@@ -66,11 +66,11 @@ static int snd_timer_user_info_compat(struct file *file, + struct snd_timer *t; + + tu = file->private_data; +- if (snd_BUG_ON(!tu->timeri)) +- return -ENXIO; ++ if (!tu->timeri) ++ return -EBADFD; + t = tu->timeri->timer; +- if (snd_BUG_ON(!t)) +- return -ENXIO; ++ if (!t) ++ return -EBADFD; + memset(&info, 0, sizeof(info)); + info.card = t->card ? t->card->number : -1; + if (t->hw.flags & SNDRV_TIMER_HW_SLAVE) +@@ -99,8 +99,8 @@ static int snd_timer_user_status_compat(struct file *file, + struct snd_timer_status32 status; + + tu = file->private_data; +- if (snd_BUG_ON(!tu->timeri)) +- return -ENXIO; ++ if (!tu->timeri) ++ return -EBADFD; + memset(&status, 0, sizeof(status)); + status.tstamp.tv_sec = tu->tstamp.tv_sec; + status.tstamp.tv_nsec = tu->tstamp.tv_nsec; +diff --git a/sound/core/vmaster.c b/sound/core/vmaster.c +index e43af18d4383..8632301489fa 100644 +--- a/sound/core/vmaster.c ++++ b/sound/core/vmaster.c +@@ -495,7 +495,9 @@ EXPORT_SYMBOL_GPL(snd_ctl_sync_vmaster); + * Returns 0 if successful, or a negative error code. + */ + int snd_ctl_apply_vmaster_slaves(struct snd_kcontrol *kctl, +- int (*func)(struct snd_kcontrol *, void *), ++ int (*func)(struct snd_kcontrol *vslave, ++ struct snd_kcontrol *slave, ++ void *arg), + void *arg) + { + struct link_master *master; +@@ -507,7 +509,7 @@ int snd_ctl_apply_vmaster_slaves(struct snd_kcontrol *kctl, + if (err < 0) + return err; + list_for_each_entry(slave, &master->slaves, list) { +- err = func(&slave->slave, arg); ++ err = func(slave->kctl, &slave->slave, arg); + if (err < 0) + return err; + } +diff --git a/sound/hda/hdmi_chmap.c b/sound/hda/hdmi_chmap.c +index 81acc20c2535..f21633cd9b38 100644 +--- a/sound/hda/hdmi_chmap.c ++++ b/sound/hda/hdmi_chmap.c +@@ -746,7 +746,7 @@ static int hdmi_chmap_ctl_get(struct snd_kcontrol *kcontrol, + memset(pcm_chmap, 0, sizeof(pcm_chmap)); + chmap->ops.get_chmap(chmap->hdac, pcm_idx, pcm_chmap); + +- for (i = 0; i < sizeof(chmap); i++) ++ for (i = 0; i < ARRAY_SIZE(pcm_chmap); i++) + ucontrol->value.integer.value[i] = pcm_chmap[i]; + + return 0; +diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c +index a0989d231fd0..417abbb1f72c 100644 +--- a/sound/pci/hda/hda_codec.c ++++ b/sound/pci/hda/hda_codec.c +@@ -1823,7 +1823,9 @@ struct slave_init_arg { + }; + + /* initialize the slave volume with 0dB via snd_ctl_apply_vmaster_slaves() */ +-static int init_slave_0dB(struct snd_kcontrol *kctl, void *_arg) ++static int init_slave_0dB(struct snd_kcontrol *slave, ++ struct snd_kcontrol *kctl, ++ void *_arg) + { + struct slave_init_arg *arg = _arg; + int _tlv[4]; +@@ -1860,7 +1862,7 @@ static int init_slave_0dB(struct snd_kcontrol *kctl, void *_arg) + arg->step = step; + val = -tlv[2] / step; + if (val > 0) { +- put_kctl_with_value(kctl, val); ++ put_kctl_with_value(slave, val); + return val; + } + +@@ -1868,7 +1870,9 @@ static int init_slave_0dB(struct snd_kcontrol *kctl, void *_arg) + } + + /* unmute the slave via snd_ctl_apply_vmaster_slaves() */ +-static int init_slave_unmute(struct snd_kcontrol *slave, void *_arg) ++static int init_slave_unmute(struct snd_kcontrol *slave, ++ struct snd_kcontrol *kctl, ++ void *_arg) + { + return put_kctl_with_value(slave, 1); + } +diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c +index f958d8d54d15..c71dcacea807 100644 +--- a/sound/pci/hda/hda_intel.c ++++ b/sound/pci/hda/hda_intel.c +@@ -2463,6 +2463,9 @@ static const struct pci_device_id azx_ids[] = { + /* AMD Hudson */ + { PCI_DEVICE(0x1022, 0x780d), + .driver_data = AZX_DRIVER_GENERIC | AZX_DCAPS_PRESET_ATI_SB }, ++ /* AMD Raven */ ++ { PCI_DEVICE(0x1022, 0x15e3), ++ .driver_data = AZX_DRIVER_GENERIC | AZX_DCAPS_PRESET_ATI_SB }, + /* ATI HDMI */ + { PCI_DEVICE(0x1002, 0x0002), + .driver_data = AZX_DRIVER_ATIHDMI_NS | AZX_DCAPS_PRESET_ATI_HDMI_NS }, +diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c +index dce0682c5001..7c39114d124f 100644 +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -341,6 +341,9 @@ static void alc_fill_eapd_coef(struct hda_codec *codec) + case 0x10ec0299: + alc_update_coef_idx(codec, 0x10, 1<<9, 0); + break; ++ case 0x10ec0275: ++ alc_update_coef_idx(codec, 0xe, 0, 1<<0); ++ break; + case 0x10ec0293: + alc_update_coef_idx(codec, 0xa, 1<<13, 0); + break; +@@ -6863,7 +6866,7 @@ static int patch_alc269(struct hda_codec *codec) + case 0x10ec0703: + spec->codec_variant = ALC269_TYPE_ALC700; + spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */ +- alc_update_coef_idx(codec, 0x4a, 0, 1 << 15); /* Combo jack auto trigger control */ ++ alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */ + break; + + } +diff --git a/sound/soc/sunxi/sun8i-codec.c b/sound/soc/sunxi/sun8i-codec.c +index abfb710df7cb..7a312168f864 100644 +--- a/sound/soc/sunxi/sun8i-codec.c ++++ b/sound/soc/sunxi/sun8i-codec.c +@@ -73,6 +73,7 @@ + #define SUN8I_SYS_SR_CTRL_AIF2_FS_MASK GENMASK(11, 8) + #define SUN8I_AIF1CLK_CTRL_AIF1_WORD_SIZ_MASK GENMASK(5, 4) + #define SUN8I_AIF1CLK_CTRL_AIF1_LRCK_DIV_MASK GENMASK(8, 6) ++#define SUN8I_AIF1CLK_CTRL_AIF1_BCLK_DIV_MASK GENMASK(12, 9) + + struct sun8i_codec { + struct device *dev; +@@ -170,11 +171,11 @@ static int sun8i_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) + + /* clock masters */ + switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { +- case SND_SOC_DAIFMT_CBS_CFS: /* DAI Slave */ +- value = 0x0; /* Codec Master */ ++ case SND_SOC_DAIFMT_CBS_CFS: /* Codec slave, DAI master */ ++ value = 0x1; + break; +- case SND_SOC_DAIFMT_CBM_CFM: /* DAI Master */ +- value = 0x1; /* Codec Slave */ ++ case SND_SOC_DAIFMT_CBM_CFM: /* Codec Master, DAI slave */ ++ value = 0x0; + break; + default: + return -EINVAL; +@@ -199,7 +200,7 @@ static int sun8i_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) + value << SUN8I_AIF1CLK_CTRL_AIF1_BCLK_INV); + regmap_update_bits(scodec->regmap, SUN8I_AIF1CLK_CTRL, + BIT(SUN8I_AIF1CLK_CTRL_AIF1_LRCK_INV), +- value << SUN8I_AIF1CLK_CTRL_AIF1_LRCK_INV); ++ !value << SUN8I_AIF1CLK_CTRL_AIF1_LRCK_INV); + + /* DAI format */ + switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { +@@ -226,12 +227,57 @@ static int sun8i_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) + return 0; + } + ++struct sun8i_codec_clk_div { ++ u8 div; ++ u8 val; ++}; ++ ++static const struct sun8i_codec_clk_div sun8i_codec_bclk_div[] = { ++ { .div = 1, .val = 0 }, ++ { .div = 2, .val = 1 }, ++ { .div = 4, .val = 2 }, ++ { .div = 6, .val = 3 }, ++ { .div = 8, .val = 4 }, ++ { .div = 12, .val = 5 }, ++ { .div = 16, .val = 6 }, ++ { .div = 24, .val = 7 }, ++ { .div = 32, .val = 8 }, ++ { .div = 48, .val = 9 }, ++ { .div = 64, .val = 10 }, ++ { .div = 96, .val = 11 }, ++ { .div = 128, .val = 12 }, ++ { .div = 192, .val = 13 }, ++}; ++ ++static u8 sun8i_codec_get_bclk_div(struct sun8i_codec *scodec, ++ unsigned int rate, ++ unsigned int word_size) ++{ ++ unsigned long clk_rate = clk_get_rate(scodec->clk_module); ++ unsigned int div = clk_rate / rate / word_size / 2; ++ unsigned int best_val = 0, best_diff = ~0; ++ int i; ++ ++ for (i = 0; i < ARRAY_SIZE(sun8i_codec_bclk_div); i++) { ++ const struct sun8i_codec_clk_div *bdiv = &sun8i_codec_bclk_div[i]; ++ unsigned int diff = abs(bdiv->div - div); ++ ++ if (diff < best_diff) { ++ best_diff = diff; ++ best_val = bdiv->val; ++ } ++ } ++ ++ return best_val; ++} ++ + static int sun8i_codec_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, + struct snd_soc_dai *dai) + { + struct sun8i_codec *scodec = snd_soc_codec_get_drvdata(dai->codec); + int sample_rate; ++ u8 bclk_div; + + /* + * The CPU DAI handles only a sample of 16 bits. Configure the +@@ -241,6 +287,11 @@ static int sun8i_codec_hw_params(struct snd_pcm_substream *substream, + SUN8I_AIF1CLK_CTRL_AIF1_WORD_SIZ_MASK, + SUN8I_AIF1CLK_CTRL_AIF1_WORD_SIZ_16); + ++ bclk_div = sun8i_codec_get_bclk_div(scodec, params_rate(params), 16); ++ regmap_update_bits(scodec->regmap, SUN8I_AIF1CLK_CTRL, ++ SUN8I_AIF1CLK_CTRL_AIF1_BCLK_DIV_MASK, ++ bclk_div << SUN8I_AIF1CLK_CTRL_AIF1_BCLK_DIV); ++ + regmap_update_bits(scodec->regmap, SUN8I_AIF1CLK_CTRL, + SUN8I_AIF1CLK_CTRL_AIF1_LRCK_DIV_MASK, + SUN8I_AIF1CLK_CTRL_AIF1_LRCK_DIV_16); +diff --git a/sound/usb/clock.c b/sound/usb/clock.c +index 26dd5f20f149..eb3396ffba4c 100644 +--- a/sound/usb/clock.c ++++ b/sound/usb/clock.c +@@ -43,7 +43,7 @@ static struct uac_clock_source_descriptor * + while ((cs = snd_usb_find_csint_desc(ctrl_iface->extra, + ctrl_iface->extralen, + cs, UAC2_CLOCK_SOURCE))) { +- if (cs->bClockID == clock_id) ++ if (cs->bLength >= sizeof(*cs) && cs->bClockID == clock_id) + return cs; + } + +@@ -59,8 +59,11 @@ static struct uac_clock_selector_descriptor * + while ((cs = snd_usb_find_csint_desc(ctrl_iface->extra, + ctrl_iface->extralen, + cs, UAC2_CLOCK_SELECTOR))) { +- if (cs->bClockID == clock_id) ++ if (cs->bLength >= sizeof(*cs) && cs->bClockID == clock_id) { ++ if (cs->bLength < 5 + cs->bNrInPins) ++ return NULL; + return cs; ++ } + } + + return NULL; +@@ -75,7 +78,7 @@ static struct uac_clock_multiplier_descriptor * + while ((cs = snd_usb_find_csint_desc(ctrl_iface->extra, + ctrl_iface->extralen, + cs, UAC2_CLOCK_MULTIPLIER))) { +- if (cs->bClockID == clock_id) ++ if (cs->bLength >= sizeof(*cs) && cs->bClockID == clock_id) + return cs; + } + +diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c +index 91bc8f18791e..2b835cca41b1 100644 +--- a/sound/usb/mixer.c ++++ b/sound/usb/mixer.c +@@ -1469,6 +1469,12 @@ static int parse_audio_feature_unit(struct mixer_build *state, int unitid, + __u8 *bmaControls; + + if (state->mixer->protocol == UAC_VERSION_1) { ++ if (hdr->bLength < 7) { ++ usb_audio_err(state->chip, ++ "unit %u: invalid UAC_FEATURE_UNIT descriptor\n", ++ unitid); ++ return -EINVAL; ++ } + csize = hdr->bControlSize; + if (!csize) { + usb_audio_dbg(state->chip, +@@ -1486,6 +1492,12 @@ static int parse_audio_feature_unit(struct mixer_build *state, int unitid, + } + } else { + struct uac2_feature_unit_descriptor *ftr = _ftr; ++ if (hdr->bLength < 6) { ++ usb_audio_err(state->chip, ++ "unit %u: invalid UAC_FEATURE_UNIT descriptor\n", ++ unitid); ++ return -EINVAL; ++ } + csize = 4; + channels = (hdr->bLength - 6) / 4 - 1; + bmaControls = ftr->bmaControls; +@@ -2086,7 +2098,8 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, + const struct usbmix_name_map *map; + char **namelist; + +- if (!desc->bNrInPins || desc->bLength < 5 + desc->bNrInPins) { ++ if (desc->bLength < 5 || !desc->bNrInPins || ++ desc->bLength < 5 + desc->bNrInPins) { + usb_audio_err(state->chip, + "invalid SELECTOR UNIT descriptor %d\n", unitid); + return -EINVAL; |