diff options
| -rw-r--r-- | 0000_README | 4 | ||||
| -rw-r--r-- | 1137_linux-5.10.138.patch | 6440 |
2 files changed, 6444 insertions, 0 deletions
diff --git a/0000_README b/0000_README index 4c11c230..8ea943aa 100644 --- a/0000_README +++ b/0000_README @@ -591,6 +591,10 @@ Patch: 1136_linux-5.10.137.patch From: http://www.kernel.org Desc: Linux 5.10.137 +Patch: 1137_linux-5.10.138.patch +From: http://www.kernel.org +Desc: Linux 5.10.138 + 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/1137_linux-5.10.138.patch b/1137_linux-5.10.138.patch new file mode 100644 index 00000000..e11f8d0d --- /dev/null +++ b/1137_linux-5.10.138.patch @@ -0,0 +1,6440 @@ +diff --git a/Documentation/atomic_bitops.txt b/Documentation/atomic_bitops.txt +index 093cdaefdb373..d8b101c97031b 100644 +--- a/Documentation/atomic_bitops.txt ++++ b/Documentation/atomic_bitops.txt +@@ -59,7 +59,7 @@ Like with atomic_t, the rule of thumb is: + - RMW operations that have a return value are fully ordered. + + - RMW operations that are conditional are unordered on FAILURE, +- otherwise the above rules apply. In the case of test_and_{}_bit() operations, ++ otherwise the above rules apply. In the case of test_and_set_bit_lock(), + if the bit in memory is unchanged by the operation then it is deemed to have + failed. + +diff --git a/Documentation/devicetree/bindings/arm/qcom.yaml b/Documentation/devicetree/bindings/arm/qcom.yaml +index c97d4a580f47b..42ec1d5fed386 100644 +--- a/Documentation/devicetree/bindings/arm/qcom.yaml ++++ b/Documentation/devicetree/bindings/arm/qcom.yaml +@@ -123,8 +123,8 @@ properties: + - const: qcom,msm8974 + + - items: +- - const: qcom,msm8916-mtp/1 + - const: qcom,msm8916-mtp ++ - const: qcom,msm8916-mtp/1 + - const: qcom,msm8916 + + - items: +diff --git a/Documentation/devicetree/bindings/clock/qcom,gcc-msm8996.yaml b/Documentation/devicetree/bindings/clock/qcom,gcc-msm8996.yaml +index 5a5b2214f0cae..005e0edd4609a 100644 +--- a/Documentation/devicetree/bindings/clock/qcom,gcc-msm8996.yaml ++++ b/Documentation/devicetree/bindings/clock/qcom,gcc-msm8996.yaml +@@ -22,16 +22,32 @@ properties: + const: qcom,gcc-msm8996 + + clocks: ++ minItems: 3 + items: + - description: XO source + - description: Second XO source + - description: Sleep clock source ++ - description: PCIe 0 PIPE clock (optional) ++ - description: PCIe 1 PIPE clock (optional) ++ - description: PCIe 2 PIPE clock (optional) ++ - description: USB3 PIPE clock (optional) ++ - description: UFS RX symbol 0 clock (optional) ++ - description: UFS RX symbol 1 clock (optional) ++ - description: UFS TX symbol 0 clock (optional) + + clock-names: ++ minItems: 3 + items: + - const: cxo + - const: cxo2 + - const: sleep_clk ++ - const: pcie_0_pipe_clk_src ++ - const: pcie_1_pipe_clk_src ++ - const: pcie_2_pipe_clk_src ++ - const: usb3_phy_pipe_clk_src ++ - const: ufs_rx_symbol_0_clk_src ++ - const: ufs_rx_symbol_1_clk_src ++ - const: ufs_tx_symbol_0_clk_src + + '#clock-cells': + const: 1 +diff --git a/Documentation/devicetree/bindings/regulator/nxp,pca9450-regulator.yaml b/Documentation/devicetree/bindings/regulator/nxp,pca9450-regulator.yaml +index c2b0a8b6da1ec..7cebd9ddfffd0 100644 +--- a/Documentation/devicetree/bindings/regulator/nxp,pca9450-regulator.yaml ++++ b/Documentation/devicetree/bindings/regulator/nxp,pca9450-regulator.yaml +@@ -47,12 +47,6 @@ properties: + description: + Properties for single LDO regulator. + +- properties: +- regulator-name: +- pattern: "^LDO[1-5]$" +- description: +- should be "LDO1", ..., "LDO5" +- + unevaluatedProperties: false + + "^BUCK[1-6]$": +@@ -62,11 +56,6 @@ properties: + Properties for single BUCK regulator. + + properties: +- regulator-name: +- pattern: "^BUCK[1-6]$" +- description: +- should be "BUCK1", ..., "BUCK6" +- + nxp,dvs-run-voltage: + $ref: "/schemas/types.yaml#/definitions/uint32" + minimum: 600000 +diff --git a/Documentation/firmware-guide/acpi/apei/einj.rst b/Documentation/firmware-guide/acpi/apei/einj.rst +index e588bccf51583..344284236a810 100644 +--- a/Documentation/firmware-guide/acpi/apei/einj.rst ++++ b/Documentation/firmware-guide/acpi/apei/einj.rst +@@ -168,7 +168,7 @@ An error injection example:: + 0x00000008 Memory Correctable + 0x00000010 Memory Uncorrectable non-fatal + # echo 0x12345000 > param1 # Set memory address for injection +- # echo $((-1 << 12)) > param2 # Mask 0xfffffffffffff000 - anywhere in this page ++ # echo 0xfffffffffffff000 > param2 # Mask - anywhere in this page + # echo 0x8 > error_type # Choose correctable memory error + # echo 1 > error_inject # Inject now + +diff --git a/Makefile b/Makefile +index b3bfdf51232f3..234c8032c2b4a 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 10 +-SUBLEVEL = 137 ++SUBLEVEL = 138 + EXTRAVERSION = + NAME = Dare mighty things + +@@ -1133,13 +1133,11 @@ vmlinux-alldirs := $(sort $(vmlinux-dirs) Documentation \ + $(patsubst %/,%,$(filter %/, $(core-) \ + $(drivers-) $(libs-)))) + +-subdir-modorder := $(addsuffix modules.order,$(filter %/, \ +- $(core-y) $(core-m) $(libs-y) $(libs-m) \ +- $(drivers-y) $(drivers-m))) +- + build-dirs := $(vmlinux-dirs) + clean-dirs := $(vmlinux-alldirs) + ++subdir-modorder := $(addsuffix /modules.order, $(build-dirs)) ++ + # Externally visible symbols (used by link-vmlinux.sh) + KBUILD_VMLINUX_OBJS := $(head-y) $(patsubst %/,%/built-in.a, $(core-y)) + KBUILD_VMLINUX_OBJS += $(addsuffix built-in.a, $(filter %/, $(libs-y))) +diff --git a/arch/csky/kernel/probes/kprobes.c b/arch/csky/kernel/probes/kprobes.c +index 556b9ba61ec06..79272dde72db3 100644 +--- a/arch/csky/kernel/probes/kprobes.c ++++ b/arch/csky/kernel/probes/kprobes.c +@@ -124,6 +124,10 @@ void __kprobes arch_disarm_kprobe(struct kprobe *p) + + void __kprobes arch_remove_kprobe(struct kprobe *p) + { ++ if (p->ainsn.api.insn) { ++ free_insn_slot(p->ainsn.api.insn, 0); ++ p->ainsn.api.insn = NULL; ++ } + } + + static void __kprobes save_previous_kprobe(struct kprobe_ctlblk *kcb) +diff --git a/arch/mips/cavium-octeon/octeon-platform.c b/arch/mips/cavium-octeon/octeon-platform.c +index a994022e32c9f..ce05c0dd3acd7 100644 +--- a/arch/mips/cavium-octeon/octeon-platform.c ++++ b/arch/mips/cavium-octeon/octeon-platform.c +@@ -86,11 +86,12 @@ static void octeon2_usb_clocks_start(struct device *dev) + "refclk-frequency", &clock_rate); + if (i) { + dev_err(dev, "No UCTL \"refclk-frequency\"\n"); ++ of_node_put(uctl_node); + goto exit; + } + i = of_property_read_string(uctl_node, + "refclk-type", &clock_type); +- ++ of_node_put(uctl_node); + if (!i && strcmp("crystal", clock_type) == 0) + is_crystal_clock = true; + } +diff --git a/arch/mips/mm/tlbex.c b/arch/mips/mm/tlbex.c +index a7521b8f76586..e8e3635dda09a 100644 +--- a/arch/mips/mm/tlbex.c ++++ b/arch/mips/mm/tlbex.c +@@ -633,7 +633,7 @@ static __maybe_unused void build_convert_pte_to_entrylo(u32 **p, + return; + } + +- if (cpu_has_rixi && !!_PAGE_NO_EXEC) { ++ if (cpu_has_rixi && _PAGE_NO_EXEC != 0) { + if (fill_includes_sw_bits) { + UASM_i_ROTR(p, reg, reg, ilog2(_PAGE_GLOBAL)); + } else { +@@ -2572,7 +2572,7 @@ static void check_pabits(void) + unsigned long entry; + unsigned pabits, fillbits; + +- if (!cpu_has_rixi || !_PAGE_NO_EXEC) { ++ if (!cpu_has_rixi || _PAGE_NO_EXEC == 0) { + /* + * We'll only be making use of the fact that we can rotate bits + * into the fill if the CPU supports RIXI, so don't bother +diff --git a/arch/nios2/include/asm/entry.h b/arch/nios2/include/asm/entry.h +index cf37f55efbc22..bafb7b2ca59fc 100644 +--- a/arch/nios2/include/asm/entry.h ++++ b/arch/nios2/include/asm/entry.h +@@ -50,7 +50,8 @@ + stw r13, PT_R13(sp) + stw r14, PT_R14(sp) + stw r15, PT_R15(sp) +- stw r2, PT_ORIG_R2(sp) ++ movi r24, -1 ++ stw r24, PT_ORIG_R2(sp) + stw r7, PT_ORIG_R7(sp) + + stw ra, PT_RA(sp) +diff --git a/arch/nios2/include/asm/ptrace.h b/arch/nios2/include/asm/ptrace.h +index 6424621448728..9da34c3022a27 100644 +--- a/arch/nios2/include/asm/ptrace.h ++++ b/arch/nios2/include/asm/ptrace.h +@@ -74,6 +74,8 @@ extern void show_regs(struct pt_regs *); + ((struct pt_regs *)((unsigned long)current_thread_info() + THREAD_SIZE)\ + - 1) + ++#define force_successful_syscall_return() (current_pt_regs()->orig_r2 = -1) ++ + int do_syscall_trace_enter(void); + void do_syscall_trace_exit(void); + #endif /* __ASSEMBLY__ */ +diff --git a/arch/nios2/kernel/entry.S b/arch/nios2/kernel/entry.S +index 0794cd7803dfe..99f0a65e62347 100644 +--- a/arch/nios2/kernel/entry.S ++++ b/arch/nios2/kernel/entry.S +@@ -185,6 +185,7 @@ ENTRY(handle_system_call) + ldw r5, PT_R5(sp) + + local_restart: ++ stw r2, PT_ORIG_R2(sp) + /* Check that the requested system call is within limits */ + movui r1, __NR_syscalls + bgeu r2, r1, ret_invsyscall +@@ -192,7 +193,6 @@ local_restart: + movhi r11, %hiadj(sys_call_table) + add r1, r1, r11 + ldw r1, %lo(sys_call_table)(r1) +- beq r1, r0, ret_invsyscall + + /* Check if we are being traced */ + GET_THREAD_INFO r11 +@@ -213,6 +213,9 @@ local_restart: + translate_rc_and_ret: + movi r1, 0 + bge r2, zero, 3f ++ ldw r1, PT_ORIG_R2(sp) ++ addi r1, r1, 1 ++ beq r1, zero, 3f + sub r2, zero, r2 + movi r1, 1 + 3: +@@ -255,9 +258,9 @@ traced_system_call: + ldw r6, PT_R6(sp) + ldw r7, PT_R7(sp) + +- /* Fetch the syscall function, we don't need to check the boundaries +- * since this is already done. +- */ ++ /* Fetch the syscall function. */ ++ movui r1, __NR_syscalls ++ bgeu r2, r1, traced_invsyscall + slli r1, r2, 2 + movhi r11,%hiadj(sys_call_table) + add r1, r1, r11 +@@ -276,6 +279,9 @@ traced_system_call: + translate_rc_and_ret2: + movi r1, 0 + bge r2, zero, 4f ++ ldw r1, PT_ORIG_R2(sp) ++ addi r1, r1, 1 ++ beq r1, zero, 4f + sub r2, zero, r2 + movi r1, 1 + 4: +@@ -287,6 +293,11 @@ end_translate_rc_and_ret2: + RESTORE_SWITCH_STACK + br ret_from_exception + ++ /* If the syscall number was invalid return ENOSYS */ ++traced_invsyscall: ++ movi r2, -ENOSYS ++ br translate_rc_and_ret2 ++ + Luser_return: + GET_THREAD_INFO r11 /* get thread_info pointer */ + ldw r10, TI_FLAGS(r11) /* get thread_info->flags */ +@@ -336,9 +347,6 @@ external_interrupt: + /* skip if no interrupt is pending */ + beq r12, r0, ret_from_interrupt + +- movi r24, -1 +- stw r24, PT_ORIG_R2(sp) +- + /* + * Process an external hardware interrupt. + */ +diff --git a/arch/nios2/kernel/signal.c b/arch/nios2/kernel/signal.c +index e45491d1d3e44..916180e4a9978 100644 +--- a/arch/nios2/kernel/signal.c ++++ b/arch/nios2/kernel/signal.c +@@ -242,7 +242,7 @@ static int do_signal(struct pt_regs *regs) + /* + * If we were from a system call, check for system call restarting... + */ +- if (regs->orig_r2 >= 0) { ++ if (regs->orig_r2 >= 0 && regs->r1) { + continue_addr = regs->ea; + restart_addr = continue_addr - 4; + retval = regs->r2; +@@ -264,6 +264,7 @@ static int do_signal(struct pt_regs *regs) + regs->ea = restart_addr; + break; + } ++ regs->orig_r2 = -1; + } + + if (get_signal(&ksig)) { +diff --git a/arch/nios2/kernel/syscall_table.c b/arch/nios2/kernel/syscall_table.c +index 6176d63023c1d..c2875a6dd5a4a 100644 +--- a/arch/nios2/kernel/syscall_table.c ++++ b/arch/nios2/kernel/syscall_table.c +@@ -13,5 +13,6 @@ + #define __SYSCALL(nr, call) [nr] = (call), + + void *sys_call_table[__NR_syscalls] = { ++ [0 ... __NR_syscalls-1] = sys_ni_syscall, + #include <asm/unistd.h> + }; +diff --git a/arch/powerpc/Makefile b/arch/powerpc/Makefile +index 7a96cdefbd4e4..59175651f0b9e 100644 +--- a/arch/powerpc/Makefile ++++ b/arch/powerpc/Makefile +@@ -17,23 +17,6 @@ HAS_BIARCH := $(call cc-option-yn, -m32) + # Set default 32 bits cross compilers for vdso and boot wrapper + CROSS32_COMPILE ?= + +-ifeq ($(HAS_BIARCH),y) +-ifeq ($(CROSS32_COMPILE),) +-ifdef CONFIG_PPC32 +-# These options will be overridden by any -mcpu option that the CPU +-# or platform code sets later on the command line, but they are needed +-# to set a sane 32-bit cpu target for the 64-bit cross compiler which +-# may default to the wrong ISA. +-KBUILD_CFLAGS += -mcpu=powerpc +-KBUILD_AFLAGS += -mcpu=powerpc +-endif +-endif +-endif +- +-ifdef CONFIG_PPC_BOOK3S_32 +-KBUILD_CFLAGS += -mcpu=powerpc +-endif +- + # If we're on a ppc/ppc64/ppc64le machine use that defconfig, otherwise just use + # ppc64_defconfig because we have nothing better to go on. + uname := $(shell uname -m) +@@ -190,6 +173,7 @@ endif + endif + + CFLAGS-$(CONFIG_TARGET_CPU_BOOL) += $(call cc-option,-mcpu=$(CONFIG_TARGET_CPU)) ++AFLAGS-$(CONFIG_TARGET_CPU_BOOL) += $(call cc-option,-mcpu=$(CONFIG_TARGET_CPU)) + + # Altivec option not allowed with e500mc64 in GCC. + ifdef CONFIG_ALTIVEC +@@ -200,14 +184,6 @@ endif + CFLAGS-$(CONFIG_E5500_CPU) += $(E5500_CPU) + CFLAGS-$(CONFIG_E6500_CPU) += $(call cc-option,-mcpu=e6500,$(E5500_CPU)) + +-ifdef CONFIG_PPC32 +-ifdef CONFIG_PPC_E500MC +-CFLAGS-y += $(call cc-option,-mcpu=e500mc,-mcpu=powerpc) +-else +-CFLAGS-$(CONFIG_E500) += $(call cc-option,-mcpu=8540 -msoft-float,-mcpu=powerpc) +-endif +-endif +- + asinstr := $(call as-instr,lis 9$(comma)foo@high,-DHAVE_AS_ATHIGH=1) + + KBUILD_CPPFLAGS += -I $(srctree)/arch/$(ARCH) $(asinstr) +diff --git a/arch/powerpc/kernel/pci-common.c b/arch/powerpc/kernel/pci-common.c +index f9d35c9ea4aed..cfc461413a5f8 100644 +--- a/arch/powerpc/kernel/pci-common.c ++++ b/arch/powerpc/kernel/pci-common.c +@@ -66,10 +66,6 @@ void set_pci_dma_ops(const struct dma_map_ops *dma_ops) + pci_dma_ops = dma_ops; + } + +-/* +- * This function should run under locking protection, specifically +- * hose_spinlock. +- */ + static int get_phb_number(struct device_node *dn) + { + int ret, phb_id = -1; +@@ -106,15 +102,20 @@ static int get_phb_number(struct device_node *dn) + if (!ret) + phb_id = (int)(prop & (MAX_PHBS - 1)); + ++ spin_lock(&hose_spinlock); ++ + /* We need to be sure to not use the same PHB number twice. */ + if ((phb_id >= 0) && !test_and_set_bit(phb_id, phb_bitmap)) +- return phb_id; ++ goto out_unlock; + + /* If everything fails then fallback to dynamic PHB numbering. */ + phb_id = find_first_zero_bit(phb_bitmap, MAX_PHBS); + BUG_ON(phb_id >= MAX_PHBS); + set_bit(phb_id, phb_bitmap); + ++out_unlock: ++ spin_unlock(&hose_spinlock); ++ + return phb_id; + } + +@@ -125,10 +126,13 @@ struct pci_controller *pcibios_alloc_controller(struct device_node *dev) + phb = zalloc_maybe_bootmem(sizeof(struct pci_controller), GFP_KERNEL); + if (phb == NULL) + return NULL; +- spin_lock(&hose_spinlock); ++ + phb->global_number = get_phb_number(dev); ++ ++ spin_lock(&hose_spinlock); + list_add_tail(&phb->list_node, &hose_list); + spin_unlock(&hose_spinlock); ++ + phb->dn = dev; + phb->is_dynamic = slab_is_available(); + #ifdef CONFIG_PPC64 +diff --git a/arch/powerpc/kernel/prom.c b/arch/powerpc/kernel/prom.c +index 7a14a094be8ac..1dfb4c213feae 100644 +--- a/arch/powerpc/kernel/prom.c ++++ b/arch/powerpc/kernel/prom.c +@@ -750,6 +750,13 @@ void __init early_init_devtree(void *params) + of_scan_flat_dt(early_init_dt_scan_root, NULL); + of_scan_flat_dt(early_init_dt_scan_memory_ppc, NULL); + ++ /* ++ * As generic code authors expect to be able to use static keys ++ * in early_param() handlers, we initialize the static keys just ++ * before parsing early params (it's fine to call jump_label_init() ++ * more than once). ++ */ ++ jump_label_init(); + parse_early_param(); + + /* make sure we've parsed cmdline for mem= before this */ +diff --git a/arch/powerpc/platforms/Kconfig.cputype b/arch/powerpc/platforms/Kconfig.cputype +index 75ebfbff4debc..84f9dd476bbba 100644 +--- a/arch/powerpc/platforms/Kconfig.cputype ++++ b/arch/powerpc/platforms/Kconfig.cputype +@@ -119,9 +119,9 @@ config GENERIC_CPU + depends on PPC64 && CPU_LITTLE_ENDIAN + select ARCH_HAS_FAST_MULTIPLIER + +-config GENERIC_CPU ++config POWERPC_CPU + bool "Generic 32 bits powerpc" +- depends on PPC32 && !PPC_8xx ++ depends on PPC32 && !PPC_8xx && !PPC_85xx + + config CELL_CPU + bool "Cell Broadband Engine" +@@ -175,11 +175,23 @@ config G4_CPU + depends on PPC_BOOK3S_32 + select ALTIVEC + ++config E500_CPU ++ bool "e500 (8540)" ++ depends on PPC_85xx && !PPC_E500MC ++ ++config E500MC_CPU ++ bool "e500mc" ++ depends on PPC_85xx && PPC_E500MC ++ ++config TOOLCHAIN_DEFAULT_CPU ++ bool "Rely on the toolchain's implicit default CPU" ++ depends on PPC32 ++ + endchoice + + config TARGET_CPU_BOOL + bool +- default !GENERIC_CPU ++ default !GENERIC_CPU && !TOOLCHAIN_DEFAULT_CPU + + config TARGET_CPU + string +@@ -194,6 +206,9 @@ config TARGET_CPU + default "e300c2" if E300C2_CPU + default "e300c3" if E300C3_CPU + default "G4" if G4_CPU ++ default "8540" if E500_CPU ++ default "e500mc" if E500MC_CPU ++ default "powerpc" if POWERPC_CPU + + config PPC_BOOK3S + def_bool y +diff --git a/arch/riscv/kernel/sys_riscv.c b/arch/riscv/kernel/sys_riscv.c +index 12f8a7fce78b1..8a7880b9c433e 100644 +--- a/arch/riscv/kernel/sys_riscv.c ++++ b/arch/riscv/kernel/sys_riscv.c +@@ -18,9 +18,8 @@ static long riscv_sys_mmap(unsigned long addr, unsigned long len, + if (unlikely(offset & (~PAGE_MASK >> page_shift_offset))) + return -EINVAL; + +- if ((prot & PROT_WRITE) && (prot & PROT_EXEC)) +- if (unlikely(!(prot & PROT_READ))) +- return -EINVAL; ++ if (unlikely((prot & PROT_WRITE) && !(prot & PROT_READ))) ++ return -EINVAL; + + return ksys_mmap_pgoff(addr, len, prot, flags, fd, + offset >> (PAGE_SHIFT - page_shift_offset)); +diff --git a/arch/riscv/kernel/traps.c b/arch/riscv/kernel/traps.c +index ad14f4466d924..c1a13011fb8e5 100644 +--- a/arch/riscv/kernel/traps.c ++++ b/arch/riscv/kernel/traps.c +@@ -15,6 +15,7 @@ + #include <linux/mm.h> + #include <linux/module.h> + #include <linux/irq.h> ++#include <linux/kexec.h> + + #include <asm/processor.h> + #include <asm/ptrace.h> +@@ -43,6 +44,9 @@ void die(struct pt_regs *regs, const char *str) + + ret = notify_die(DIE_OOPS, str, regs, 0, regs->cause, SIGSEGV); + ++ if (regs && kexec_should_crash(current)) ++ crash_kexec(regs); ++ + bust_spinlocks(0); + add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE); + spin_unlock_irq(&die_lock); +diff --git a/arch/um/os-Linux/skas/process.c b/arch/um/os-Linux/skas/process.c +index 94a7c4125ebc8..eecde73b2e782 100644 +--- a/arch/um/os-Linux/skas/process.c ++++ b/arch/um/os-Linux/skas/process.c +@@ -5,6 +5,7 @@ + */ + + #include <stdlib.h> ++#include <stdbool.h> + #include <unistd.h> + #include <sched.h> + #include <errno.h> +@@ -644,10 +645,24 @@ void halt_skas(void) + UML_LONGJMP(&initial_jmpbuf, INIT_JMP_HALT); + } + ++static bool noreboot; ++ ++static int __init noreboot_cmd_param(char *str, int *add) ++{ ++ noreboot = true; ++ return 0; ++} ++ ++__uml_setup("noreboot", noreboot_cmd_param, ++"noreboot\n" ++" Rather than rebooting, exit always, akin to QEMU's -no-reboot option.\n" ++" This is useful if you're using CONFIG_PANIC_TIMEOUT in order to catch\n" ++" crashes in CI\n"); ++ + void reboot_skas(void) + { + block_signals_trace(); +- UML_LONGJMP(&initial_jmpbuf, INIT_JMP_REBOOT); ++ UML_LONGJMP(&initial_jmpbuf, noreboot ? INIT_JMP_HALT : INIT_JMP_REBOOT); + } + + void __switch_mm(struct mm_id *mm_idp) +diff --git a/arch/x86/mm/init_64.c b/arch/x86/mm/init_64.c +index 067ca92e69ef9..20951ab522a1d 100644 +--- a/arch/x86/mm/init_64.c ++++ b/arch/x86/mm/init_64.c +@@ -645,7 +645,7 @@ phys_pud_init(pud_t *pud_page, unsigned long paddr, unsigned long paddr_end, + pages++; + spin_lock(&init_mm.page_table_lock); + +- prot = __pgprot(pgprot_val(prot) | __PAGE_KERNEL_LARGE); ++ prot = __pgprot(pgprot_val(prot) | _PAGE_PSE); + + set_pte_init((pte_t *)pud, + pfn_pte((paddr & PUD_MASK) >> PAGE_SHIFT, +diff --git a/drivers/acpi/pci_mcfg.c b/drivers/acpi/pci_mcfg.c +index 95f23acd5b802..2709ef2b0351b 100644 +--- a/drivers/acpi/pci_mcfg.c ++++ b/drivers/acpi/pci_mcfg.c +@@ -41,6 +41,8 @@ struct mcfg_fixup { + static struct mcfg_fixup mcfg_quirks[] = { + /* { OEM_ID, OEM_TABLE_ID, REV, SEGMENT, BUS_RANGE, ops, cfgres }, */ + ++#ifdef CONFIG_ARM64 ++ + #define AL_ECAM(table_id, rev, seg, ops) \ + { "AMAZON", table_id, rev, seg, MCFG_BUS_ANY, ops } + +@@ -162,6 +164,7 @@ static struct mcfg_fixup mcfg_quirks[] = { + ALTRA_ECAM_QUIRK(1, 13), + ALTRA_ECAM_QUIRK(1, 14), + ALTRA_ECAM_QUIRK(1, 15), ++#endif /* ARM64 */ + }; + + static char mcfg_oem_id[ACPI_OEM_ID_SIZE]; +diff --git a/drivers/acpi/property.c b/drivers/acpi/property.c +index 619d34d73dcfe..80e92c298055d 100644 +--- a/drivers/acpi/property.c ++++ b/drivers/acpi/property.c +@@ -155,10 +155,10 @@ static bool acpi_nondev_subnode_ok(acpi_handle scope, + return acpi_nondev_subnode_data_ok(handle, link, list, parent); + } + +-static int acpi_add_nondev_subnodes(acpi_handle scope, +- const union acpi_object *links, +- struct list_head *list, +- struct fwnode_handle *parent) ++static bool acpi_add_nondev_subnodes(acpi_handle scope, ++ const union acpi_object *links, ++ struct list_head *list, ++ struct fwnode_handle *parent) + { + bool ret = false; + int i; +diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c +index 018ed8736a64d..973f4d34d7cda 100644 +--- a/drivers/ata/libata-eh.c ++++ b/drivers/ata/libata-eh.c +@@ -2131,6 +2131,7 @@ const char *ata_get_cmd_descript(u8 command) + { ATA_CMD_WRITE_QUEUED_FUA_EXT, "WRITE DMA QUEUED FUA EXT" }, + { ATA_CMD_FPDMA_READ, "READ FPDMA QUEUED" }, + { ATA_CMD_FPDMA_WRITE, "WRITE FPDMA QUEUED" }, ++ { ATA_CMD_NCQ_NON_DATA, "NCQ NON-DATA" }, + { ATA_CMD_FPDMA_SEND, "SEND FPDMA QUEUED" }, + { ATA_CMD_FPDMA_RECV, "RECEIVE FPDMA QUEUED" }, + { ATA_CMD_PIO_READ, "READ SECTOR(S)" }, +diff --git a/drivers/atm/idt77252.c b/drivers/atm/idt77252.c +index 5f0472c18bcbd..82f6f1fbe9e78 100644 +--- a/drivers/atm/idt77252.c ++++ b/drivers/atm/idt77252.c +@@ -3767,6 +3767,7 @@ static void __exit idt77252_exit(void) + card = idt77252_chain; + dev = card->atmdev; + idt77252_chain = card->next; ++ del_timer_sync(&card->tst_timer); + + if (dev->phy->stop) + dev->phy->stop(dev); +diff --git a/drivers/block/zram/zcomp.c b/drivers/block/zram/zcomp.c +index 33e3b76c4fa91..b08650417bf00 100644 +--- a/drivers/block/zram/zcomp.c ++++ b/drivers/block/zram/zcomp.c +@@ -61,12 +61,6 @@ static int zcomp_strm_init(struct zcomp_strm *zstrm, struct zcomp *comp) + + bool zcomp_available_algorithm(const char *comp) + { +- int i; +- +- i = sysfs_match_string(backends, comp); +- if (i >= 0) +- return true; +- + /* + * Crypto does not ignore a trailing new line symbol, + * so make sure you don't supply a string containing +@@ -215,6 +209,11 @@ struct zcomp *zcomp_create(const char *compress) + struct zcomp *comp; + int error; + ++ /* ++ * Crypto API will execute /sbin/modprobe if the compression module ++ * is not loaded yet. We must do it here, otherwise we are about to ++ * call /sbin/modprobe under CPU hot-plug lock. ++ */ + if (!zcomp_available_algorithm(compress)) + return ERR_PTR(-EINVAL); + +diff --git a/drivers/clk/qcom/clk-alpha-pll.c b/drivers/clk/qcom/clk-alpha-pll.c +index 1a571c04a76cb..cf265ab035ea9 100644 +--- a/drivers/clk/qcom/clk-alpha-pll.c ++++ b/drivers/clk/qcom/clk-alpha-pll.c +@@ -1379,7 +1379,7 @@ const struct clk_ops clk_alpha_pll_postdiv_fabia_ops = { + EXPORT_SYMBOL_GPL(clk_alpha_pll_postdiv_fabia_ops); + + /** +- * clk_lucid_pll_configure - configure the lucid pll ++ * clk_trion_pll_configure - configure the trion pll + * + * @pll: clk alpha pll + * @regmap: register map +diff --git a/drivers/clk/qcom/gcc-ipq8074.c b/drivers/clk/qcom/gcc-ipq8074.c +index 2c2ecfc5e61f5..d6d5defb82c9f 100644 +--- a/drivers/clk/qcom/gcc-ipq8074.c ++++ b/drivers/clk/qcom/gcc-ipq8074.c +@@ -662,6 +662,7 @@ static struct clk_branch gcc_sleep_clk_src = { + }, + .num_parents = 1, + .ops = &clk_branch2_ops, ++ .flags = CLK_IS_CRITICAL, + }, + }, + }; +diff --git a/drivers/clk/ti/clk-44xx.c b/drivers/clk/ti/clk-44xx.c +index a38c921539793..cbf9922d93d4e 100644 +--- a/drivers/clk/ti/clk-44xx.c ++++ b/drivers/clk/ti/clk-44xx.c +@@ -56,7 +56,7 @@ static const struct omap_clkctrl_bit_data omap4_aess_bit_data[] __initconst = { + }; + + static const char * const omap4_func_dmic_abe_gfclk_parents[] __initconst = { +- "abe_cm:clk:0018:26", ++ "abe-clkctrl:0018:26", + "pad_clks_ck", + "slimbus_clk", + NULL, +@@ -76,7 +76,7 @@ static const struct omap_clkctrl_bit_data omap4_dmic_bit_data[] __initconst = { + }; + + static const char * const omap4_func_mcasp_abe_gfclk_parents[] __initconst = { +- "abe_cm:clk:0020:26", ++ "abe-clkctrl:0020:26", + "pad_clks_ck", + "slimbus_clk", + NULL, +@@ -89,7 +89,7 @@ static const struct omap_clkctrl_bit_data omap4_mcasp_bit_data[] __initconst = { + }; + + static const char * const omap4_func_mcbsp1_gfclk_parents[] __initconst = { +- "abe_cm:clk:0028:26", ++ "abe-clkctrl:0028:26", + "pad_clks_ck", + "slimbus_clk", + NULL, +@@ -102,7 +102,7 @@ static const struct omap_clkctrl_bit_data omap4_mcbsp1_bit_data[] __initconst = + }; + + static const char * const omap4_func_mcbsp2_gfclk_parents[] __initconst = { +- "abe_cm:clk:0030:26", ++ "abe-clkctrl:0030:26", + "pad_clks_ck", + "slimbus_clk", + NULL, +@@ -115,7 +115,7 @@ static const struct omap_clkctrl_bit_data omap4_mcbsp2_bit_data[] __initconst = + }; + + static const char * const omap4_func_mcbsp3_gfclk_parents[] __initconst = { +- "abe_cm:clk:0038:26", ++ "abe-clkctrl:0038:26", + "pad_clks_ck", + "slimbus_clk", + NULL, +@@ -183,18 +183,18 @@ static const struct omap_clkctrl_bit_data omap4_timer8_bit_data[] __initconst = + + static const struct omap_clkctrl_reg_data omap4_abe_clkctrl_regs[] __initconst = { + { OMAP4_L4_ABE_CLKCTRL, NULL, 0, "ocp_abe_iclk" }, +- { OMAP4_AESS_CLKCTRL, omap4_aess_bit_data, CLKF_SW_SUP, "abe_cm:clk:0008:24" }, ++ { OMAP4_AESS_CLKCTRL, omap4_aess_bit_data, CLKF_SW_SUP, "abe-clkctrl:0008:24" }, + { OMAP4_MCPDM_CLKCTRL, NULL, CLKF_SW_SUP, "pad_clks_ck" }, +- { OMAP4_DMIC_CLKCTRL, omap4_dmic_bit_data, CLKF_SW_SUP, "abe_cm:clk:0018:24" }, +- { OMAP4_MCASP_CLKCTRL, omap4_mcasp_bit_data, CLKF_SW_SUP, "abe_cm:clk:0020:24" }, +- { OMAP4_MCBSP1_CLKCTRL, omap4_mcbsp1_bit_data, CLKF_SW_SUP, "abe_cm:clk:0028:24" }, +- { OMAP4_MCBSP2_CLKCTRL, omap4_mcbsp2_bit_data, CLKF_SW_SUP, "abe_cm:clk:0030:24" }, +- { OMAP4_MCBSP3_CLKCTRL, omap4_mcbsp3_bit_data, CLKF_SW_SUP, "abe_cm:clk:0038:24" }, +- { OMAP4_SLIMBUS1_CLKCTRL, omap4_slimbus1_bit_data, CLKF_SW_SUP, "abe_cm:clk:0040:8" }, +- { OMAP4_TIMER5_CLKCTRL, omap4_timer5_bit_data, CLKF_SW_SUP, "abe_cm:clk:0048:24" }, +- { OMAP4_TIMER6_CLKCTRL, omap4_timer6_bit_data, CLKF_SW_SUP, "abe_cm:clk:0050:24" }, +- { OMAP4_TIMER7_CLKCTRL, omap4_timer7_bit_data, CLKF_SW_SUP, "abe_cm:clk:0058:24" }, +- { OMAP4_TIMER8_CLKCTRL, omap4_timer8_bit_data, CLKF_SW_SUP, "abe_cm:clk:0060:24" }, ++ { OMAP4_DMIC_CLKCTRL, omap4_dmic_bit_data, CLKF_SW_SUP, "abe-clkctrl:0018:24" }, ++ { OMAP4_MCASP_CLKCTRL, omap4_mcasp_bit_data, CLKF_SW_SUP, "abe-clkctrl:0020:24" }, ++ { OMAP4_MCBSP1_CLKCTRL, omap4_mcbsp1_bit_data, CLKF_SW_SUP, "abe-clkctrl:0028:24" }, ++ { OMAP4_MCBSP2_CLKCTRL, omap4_mcbsp2_bit_data, CLKF_SW_SUP, "abe-clkctrl:0030:24" }, ++ { OMAP4_MCBSP3_CLKCTRL, omap4_mcbsp3_bit_data, CLKF_SW_SUP, "abe-clkctrl:0038:24" }, ++ { OMAP4_SLIMBUS1_CLKCTRL, omap4_slimbus1_bit_data, CLKF_SW_SUP, "abe-clkctrl:0040:8" }, ++ { OMAP4_TIMER5_CLKCTRL, omap4_timer5_bit_data, CLKF_SW_SUP, "abe-clkctrl:0048:24" }, ++ { OMAP4_TIMER6_CLKCTRL, omap4_timer6_bit_data, CLKF_SW_SUP, "abe-clkctrl:0050:24" }, ++ { OMAP4_TIMER7_CLKCTRL, omap4_timer7_bit_data, CLKF_SW_SUP, "abe-clkctrl:0058:24" }, ++ { OMAP4_TIMER8_CLKCTRL, omap4_timer8_bit_data, CLKF_SW_SUP, "abe-clkctrl:0060:24" }, + { OMAP4_WD_TIMER3_CLKCTRL, NULL, CLKF_SW_SUP, "sys_32k_ck" }, + { 0 }, + }; +@@ -287,7 +287,7 @@ static const struct omap_clkctrl_bit_data omap4_fdif_bit_data[] __initconst = { + + static const struct omap_clkctrl_reg_data omap4_iss_clkctrl_regs[] __initconst = { + { OMAP4_ISS_CLKCTRL, omap4_iss_bit_data, CLKF_SW_SUP, "ducati_clk_mux_ck" }, +- { OMAP4_FDIF_CLKCTRL, omap4_fdif_bit_data, CLKF_SW_SUP, "iss_cm:clk:0008:24" }, ++ { OMAP4_FDIF_CLKCTRL, omap4_fdif_bit_data, CLKF_SW_SUP, "iss-clkctrl:0008:24" }, + { 0 }, + }; + +@@ -320,7 +320,7 @@ static const struct omap_clkctrl_bit_data omap4_dss_core_bit_data[] __initconst + }; + + static const struct omap_clkctrl_reg_data omap4_l3_dss_clkctrl_regs[] __initconst = { +- { OMAP4_DSS_CORE_CLKCTRL, omap4_dss_core_bit_data, CLKF_SW_SUP, "l3_dss_cm:clk:0000:8" }, ++ { OMAP4_DSS_CORE_CLKCTRL, omap4_dss_core_bit_data, CLKF_SW_SUP, "l3-dss-clkctrl:0000:8" }, + { 0 }, + }; + +@@ -336,7 +336,7 @@ static const struct omap_clkctrl_bit_data omap4_gpu_bit_data[] __initconst = { + }; + + static const struct omap_clkctrl_reg_data omap4_l3_gfx_clkctrl_regs[] __initconst = { +- { OMAP4_GPU_CLKCTRL, omap4_gpu_bit_data, CLKF_SW_SUP, "l3_gfx_cm:clk:0000:24" }, ++ { OMAP4_GPU_CLKCTRL, omap4_gpu_bit_data, CLKF_SW_SUP, "l3-gfx-clkctrl:0000:24" }, + { 0 }, + }; + +@@ -372,12 +372,12 @@ static const struct omap_clkctrl_bit_data omap4_hsi_bit_data[] __initconst = { + }; + + static const char * const omap4_usb_host_hs_utmi_p1_clk_parents[] __initconst = { +- "l3_init_cm:clk:0038:24", ++ "l3-init-clkctrl:0038:24", + NULL, + }; + + static const char * const omap4_usb_host_hs_utmi_p2_clk_parents[] __initconst = { +- "l3_init_cm:clk:0038:25", ++ "l3-init-clkctrl:0038:25", + NULL, + }; + +@@ -418,7 +418,7 @@ static const struct omap_clkctrl_bit_data omap4_usb_host_hs_bit_data[] __initcon + }; + + static const char * const omap4_usb_otg_hs_xclk_parents[] __initconst = { +- "l3_init_cm:clk:0040:24", ++ "l3-init-clkctrl:0040:24", + NULL, + }; + +@@ -452,14 +452,14 @@ static const struct omap_clkctrl_bit_data omap4_ocp2scp_usb_phy_bit_data[] __ini + }; + + static const struct omap_clkctrl_reg_data omap4_l3_init_clkctrl_regs[] __initconst = { +- { OMAP4_MMC1_CLKCTRL, omap4_mmc1_bit_data, CLKF_SW_SUP, "l3_init_cm:clk:0008:24" }, +- { OMAP4_MMC2_CLKCTRL, omap4_mmc2_bit_data, CLKF_SW_SUP, "l3_init_cm:clk:0010:24" }, +- { OMAP4_HSI_CLKCTRL, omap4_hsi_bit_data, CLKF_HW_SUP, "l3_init_cm:clk:0018:24" }, ++ { OMAP4_MMC1_CLKCTRL, omap4_mmc1_bit_data, CLKF_SW_SUP, "l3-init-clkctrl:0008:24" }, ++ { OMAP4_MMC2_CLKCTRL, omap4_mmc2_bit_data, CLKF_SW_SUP, "l3-init-clkctrl:0010:24" }, ++ { OMAP4_HSI_CLKCTRL, omap4_hsi_bit_data, CLKF_HW_SUP, "l3-init-clkctrl:0018:24" }, + { OMAP4_USB_HOST_HS_CLKCTRL, omap4_usb_host_hs_bit_data, CLKF_SW_SUP, "init_60m_fclk" }, + { OMAP4_USB_OTG_HS_CLKCTRL, omap4_usb_otg_hs_bit_data, CLKF_HW_SUP, "l3_div_ck" }, + { OMAP4_USB_TLL_HS_CLKCTRL, omap4_usb_tll_hs_bit_data, CLKF_HW_SUP, "l4_div_ck" }, + { OMAP4_USB_HOST_FS_CLKCTRL, NULL, CLKF_SW_SUP, "func_48mc_fclk" }, +- { OMAP4_OCP2SCP_USB_PHY_CLKCTRL, omap4_ocp2scp_usb_phy_bit_data, CLKF_HW_SUP, "l3_init_cm:clk:00c0:8" }, ++ { OMAP4_OCP2SCP_USB_PHY_CLKCTRL, omap4_ocp2scp_usb_phy_bit_data, CLKF_HW_SUP, "l3-init-clkctrl:00c0:8" }, + { 0 }, + }; + +@@ -530,7 +530,7 @@ static const struct omap_clkctrl_bit_data omap4_gpio6_bit_data[] __initconst = { + }; + + static const char * const omap4_per_mcbsp4_gfclk_parents[] __initconst = { +- "l4_per_cm:clk:00c0:26", ++ "l4-per-clkctrl:00c0:26", + "pad_clks_ck", + NULL, + }; +@@ -570,12 +570,12 @@ static const struct omap_clkctrl_bit_data omap4_slimbus2_bit_data[] __initconst + }; + + static const struct omap_clkctrl_reg_data omap4_l4_per_clkctrl_regs[] __initconst = { +- { OMAP4_TIMER10_CLKCTRL, omap4_timer10_bit_data, CLKF_SW_SUP, "l4_per_cm:clk:0008:24" }, +- { OMAP4_TIMER11_CLKCTRL, omap4_timer11_bit_data, CLKF_SW_SUP, "l4_per_cm:clk:0010:24" }, +- { OMAP4_TIMER2_CLKCTRL, omap4_timer2_bit_data, CLKF_SW_SUP, "l4_per_cm:clk:0018:24" }, +- { OMAP4_TIMER3_CLKCTRL, omap4_timer3_bit_data, CLKF_SW_SUP, "l4_per_cm:clk:0020:24" }, +- { OMAP4_TIMER4_CLKCTRL, omap4_timer4_bit_data, CLKF_SW_SUP, "l4_per_cm:clk:0028:24" }, +- { OMAP4_TIMER9_CLKCTRL, omap4_timer9_bit_data, CLKF_SW_SUP, "l4_per_cm:clk:0030:24" }, ++ { OMAP4_TIMER10_CLKCTRL, omap4_timer10_bit_data, CLKF_SW_SUP, "l4-per-clkctrl:0008:24" }, ++ { OMAP4_TIMER11_CLKCTRL, omap4_timer11_bit_data, CLKF_SW_SUP, "l4-per-clkctrl:0010:24" }, ++ { OMAP4_TIMER2_CLKCTRL, omap4_timer2_bit_data, CLKF_SW_SUP, "l4-per-clkctrl:0018:24" }, ++ { OMAP4_TIMER3_CLKCTRL, omap4_timer3_bit_data, CLKF_SW_SUP, "l4-per-clkctrl:0020:24" }, ++ { OMAP4_TIMER4_CLKCTRL, omap4_timer4_bit_data, CLKF_SW_SUP, "l4-per-clkctrl:0028:24" }, ++ { OMAP4_TIMER9_CLKCTRL, omap4_timer9_bit_data, CLKF_SW_SUP, "l4-per-clkctrl:0030:24" }, + { OMAP4_ELM_CLKCTRL, NULL, 0, "l4_div_ck" }, + { OMAP4_GPIO2_CLKCTRL, omap4_gpio2_bit_data, CLKF_HW_SUP, "l4_div_ck" }, + { OMAP4_GPIO3_CLKCTRL, omap4_gpio3_bit_data, CLKF_HW_SUP, "l4_div_ck" }, +@@ -588,14 +588,14 @@ static const struct omap_clkctrl_reg_data omap4_l4_per_clkctrl_regs[] __initcons + { OMAP4_I2C3_CLKCTRL, NULL, CLKF_SW_SUP, "func_96m_fclk" }, + { OMAP4_I2C4_CLKCTRL, NULL, CLKF_SW_SUP, "func_96m_fclk" }, + { OMAP4_L4_PER_CLKCTRL, NULL, 0, "l4_div_ck" }, +- { OMAP4_MCBSP4_CLKCTRL, omap4_mcbsp4_bit_data, CLKF_SW_SUP, "l4_per_cm:clk:00c0:24" }, ++ { OMAP4_MCBSP4_CLKCTRL, omap4_mcbsp4_bit_data, CLKF_SW_SUP, "l4-per-clkctrl:00c0:24" }, + { OMAP4_MCSPI1_CLKCTRL, NULL, CLKF_SW_SUP, "func_48m_fclk" }, + { OMAP4_MCSPI2_CLKCTRL, NULL, CLKF_SW_SUP, "func_48m_fclk" }, + { OMAP4_MCSPI3_CLKCTRL, NULL, CLKF_SW_SUP, "func_48m_fclk" }, + { OMAP4_MCSPI4_CLKCTRL, NULL, CLKF_SW_SUP, "func_48m_fclk" }, + { OMAP4_MMC3_CLKCTRL, NULL, CLKF_SW_SUP, "func_48m_fclk" }, + { OMAP4_MMC4_CLKCTRL, NULL, CLKF_SW_SUP, "func_48m_fclk" }, +- { OMAP4_SLIMBUS2_CLKCTRL, omap4_slimbus2_bit_data, CLKF_SW_SUP, "l4_per_cm:clk:0118:8" }, ++ { OMAP4_SLIMBUS2_CLKCTRL, omap4_slimbus2_bit_data, CLKF_SW_SUP, "l4-per-clkctrl:0118:8" }, + { OMAP4_UART1_CLKCTRL, NULL, CLKF_SW_SUP, "func_48m_fclk" }, + { OMAP4_UART2_CLKCTRL, NULL, CLKF_SW_SUP, "func_48m_fclk" }, + { OMAP4_UART3_CLKCTRL, NULL, CLKF_SW_SUP, "func_48m_fclk" }, +@@ -630,7 +630,7 @@ static const struct omap_clkctrl_reg_data omap4_l4_wkup_clkctrl_regs[] __initcon + { OMAP4_L4_WKUP_CLKCTRL, NULL, 0, "l4_wkup_clk_mux_ck" }, + { OMAP4_WD_TIMER2_CLKCTRL, NULL, CLKF_SW_SUP, "sys_32k_ck" }, + { OMAP4_GPIO1_CLKCTRL, omap4_gpio1_bit_data, CLKF_HW_SUP, "l4_wkup_clk_mux_ck" }, +- { OMAP4_TIMER1_CLKCTRL, omap4_timer1_bit_data, CLKF_SW_SUP, "l4_wkup_cm:clk:0020:24" }, ++ { OMAP4_TIMER1_CLKCTRL, omap4_timer1_bit_data, CLKF_SW_SUP, "l4-wkup-clkctrl:0020:24" }, + { OMAP4_COUNTER_32K_CLKCTRL, NULL, 0, "sys_32k_ck" }, + { OMAP4_KBD_CLKCTRL, NULL, CLKF_SW_SUP, "sys_32k_ck" }, + { 0 }, +@@ -644,7 +644,7 @@ static const char * const omap4_pmd_stm_clock_mux_ck_parents[] __initconst = { + }; + + static const char * const omap4_trace_clk_div_div_ck_parents[] __initconst = { +- "emu_sys_cm:clk:0000:22", ++ "emu-sys-clkctrl:0000:22", + NULL, + }; + +@@ -662,7 +662,7 @@ static const struct omap_clkctrl_div_data omap4_trace_clk_div_div_ck_data __init + }; + + static const char * const omap4_stm_clk_div_ck_parents[] __initconst = { +- "emu_sys_cm:clk:0000:20", ++ "emu-sys-clkctrl:0000:20", + NULL, + }; + +@@ -716,73 +716,73 @@ static struct ti_dt_clk omap44xx_clks[] = { + * hwmod support. Once hwmod is removed, these can be removed + * also. + */ +- DT_CLK(NULL, "aess_fclk", "abe_cm:0008:24"), +- DT_CLK(NULL, "cm2_dm10_mux", "l4_per_cm:0008:24"), +- DT_CLK(NULL, "cm2_dm11_mux", "l4_per_cm:0010:24"), +- DT_CLK(NULL, "cm2_dm2_mux", "l4_per_cm:0018:24"), +- DT_CLK(NULL, "cm2_dm3_mux", "l4_per_cm:0020:24"), +- DT_CLK(NULL, "cm2_dm4_mux", "l4_per_cm:0028:24"), +- DT_CLK(NULL, "cm2_dm9_mux", "l4_per_cm:0030:24"), +- DT_CLK(NULL, "dmic_sync_mux_ck", "abe_cm:0018:26"), +- DT_CLK(NULL, "dmt1_clk_mux", "l4_wkup_cm:0020:24"), +- DT_CLK(NULL, "dss_48mhz_clk", "l3_dss_cm:0000:9"), +- DT_CLK(NULL, "dss_dss_clk", "l3_dss_cm:0000:8"), +- DT_CLK(NULL, "dss_sys_clk", "l3_dss_cm:0000:10"), +- DT_CLK(NULL, "dss_tv_clk", "l3_dss_cm:0000:11"), +- DT_CLK(NULL, "fdif_fck", "iss_cm:0008:24"), +- DT_CLK(NULL, "func_dmic_abe_gfclk", "abe_cm:0018:24"), +- DT_CLK(NULL, "func_mcasp_abe_gfclk", "abe_cm:0020:24"), +- DT_CLK(NULL, "func_mcbsp1_gfclk", "abe_cm:0028:24"), +- DT_CLK(NULL, "func_mcbsp2_gfclk", "abe_cm:0030:24"), +- DT_CLK(NULL, "func_mcbsp3_gfclk", "abe_cm:0038:24"), +- DT_CLK(NULL, "gpio1_dbclk", "l4_wkup_cm:0018:8"), +- DT_CLK(NULL, "gpio2_dbclk", "l4_per_cm:0040:8"), +- DT_CLK(NULL, "gpio3_dbclk", "l4_per_cm:0048:8"), +- DT_CLK(NULL, "gpio4_dbclk", "l4_per_cm:0050:8"), +- DT_CLK(NULL, "gpio5_dbclk", "l4_per_cm:0058:8"), +- DT_CLK(NULL, "gpio6_dbclk", "l4_per_cm:0060:8"), +- DT_CLK(NULL, "hsi_fck", "l3_init_cm:0018:24"), +- DT_CLK(NULL, "hsmmc1_fclk", "l3_init_cm:0008:24"), +- DT_CLK(NULL, "hsmmc2_fclk", "l3_init_cm:0010:24"), +- DT_CLK(NULL, "iss_ctrlclk", "iss_cm:0000:8"), +- DT_CLK(NULL, "mcasp_sync_mux_ck", "abe_cm:0020:26"), +- DT_CLK(NULL, "mcbsp1_sync_mux_ck", "abe_cm:0028:26"), +- DT_CLK(NULL, "mcbsp2_sync_mux_ck", "abe_cm:0030:26"), +- DT_CLK(NULL, "mcbsp3_sync_mux_ck", "abe_cm:0038:26"), +- DT_CLK(NULL, "mcbsp4_sync_mux_ck", "l4_per_cm:00c0:26"), +- DT_CLK(NULL, "ocp2scp_usb_phy_phy_48m", "l3_init_cm:00c0:8"), +- DT_CLK(NULL, "otg_60m_gfclk", "l3_init_cm:0040:24"), +- DT_CLK(NULL, "per_mcbsp4_gfclk", "l4_per_cm:00c0:24"), +- DT_CLK(NULL, "pmd_stm_clock_mux_ck", "emu_sys_cm:0000:20"), +- DT_CLK(NULL, "pmd_trace_clk_mux_ck", "emu_sys_cm:0000:22"), +- DT_CLK(NULL, "sgx_clk_mux", "l3_gfx_cm:0000:24"), +- DT_CLK(NULL, "slimbus1_fclk_0", "abe_cm:0040:8"), +- DT_CLK(NULL, "slimbus1_fclk_1", "abe_cm:0040:9"), +- DT_CLK(NULL, "slimbus1_fclk_2", "abe_cm:0040:10"), +- DT_CLK(NULL, "slimbus1_slimbus_clk", "abe_cm:0040:11"), +- DT_CLK(NULL, "slimbus2_fclk_0", "l4_per_cm:0118:8"), +- DT_CLK(NULL, "slimbus2_fclk_1", "l4_per_cm:0118:9"), +- DT_CLK(NULL, "slimbus2_slimbus_clk", "l4_per_cm:0118:10"), +- DT_CLK(NULL, "stm_clk_div_ck", "emu_sys_cm:0000:27"), +- DT_CLK(NULL, "timer5_sync_mux", "abe_cm:0048:24"), +- DT_CLK(NULL, "timer6_sync_mux", "abe_cm:0050:24"), +- DT_CLK(NULL, "timer7_sync_mux", "abe_cm:0058:24"), +- DT_CLK(NULL, "timer8_sync_mux", "abe_cm:0060:24"), +- DT_CLK(NULL, "trace_clk_div_div_ck", "emu_sys_cm:0000:24"), +- DT_CLK(NULL, "usb_host_hs_func48mclk", "l3_init_cm:0038:15"), +- DT_CLK(NULL, "usb_host_hs_hsic480m_p1_clk", "l3_init_cm:0038:13"), +- DT_CLK(NULL, "usb_host_hs_hsic480m_p2_clk", "l3_init_cm:0038:14"), +- DT_CLK(NULL, "usb_host_hs_hsic60m_p1_clk", "l3_init_cm:0038:11"), +- DT_CLK(NULL, "usb_host_hs_hsic60m_p2_clk", "l3_init_cm:0038:12"), +- DT_CLK(NULL, "usb_host_hs_utmi_p1_clk", "l3_init_cm:0038:8"), +- DT_CLK(NULL, "usb_host_hs_utmi_p2_clk", "l3_init_cm:0038:9"), +- DT_CLK(NULL, "usb_host_hs_utmi_p3_clk", "l3_init_cm:0038:10"), +- DT_CLK(NULL, "usb_otg_hs_xclk", "l3_init_cm:0040:8"), +- DT_CLK(NULL, "usb_tll_hs_usb_ch0_clk", "l3_init_cm:0048:8"), +- DT_CLK(NULL, "usb_tll_hs_usb_ch1_clk", "l3_init_cm:0048:9"), +- DT_CLK(NULL, "usb_tll_hs_usb_ch2_clk", "l3_init_cm:0048:10"), +- DT_CLK(NULL, "utmi_p1_gfclk", "l3_init_cm:0038:24"), +- DT_CLK(NULL, "utmi_p2_gfclk", "l3_init_cm:0038:25"), ++ DT_CLK(NULL, "aess_fclk", "abe-clkctrl:0008:24"), ++ DT_CLK(NULL, "cm2_dm10_mux", "l4-per-clkctrl:0008:24"), ++ DT_CLK(NULL, "cm2_dm11_mux", "l4-per-clkctrl:0010:24"), ++ DT_CLK(NULL, "cm2_dm2_mux", "l4-per-clkctrl:0018:24"), ++ DT_CLK(NULL, "cm2_dm3_mux", "l4-per-clkctrl:0020:24"), ++ DT_CLK(NULL, "cm2_dm4_mux", "l4-per-clkctrl:0028:24"), ++ DT_CLK(NULL, "cm2_dm9_mux", "l4-per-clkctrl:0030:24"), ++ DT_CLK(NULL, "dmic_sync_mux_ck", "abe-clkctrl:0018:26"), ++ DT_CLK(NULL, "dmt1_clk_mux", "l4-wkup-clkctrl:0020:24"), ++ DT_CLK(NULL, "dss_48mhz_clk", "l3-dss-clkctrl:0000:9"), ++ DT_CLK(NULL, "dss_dss_clk", "l3-dss-clkctrl:0000:8"), ++ DT_CLK(NULL, "dss_sys_clk", "l3-dss-clkctrl:0000:10"), ++ DT_CLK(NULL, "dss_tv_clk", "l3-dss-clkctrl:0000:11"), ++ DT_CLK(NULL, "fdif_fck", "iss-clkctrl:0008:24"), ++ DT_CLK(NULL, "func_dmic_abe_gfclk", "abe-clkctrl:0018:24"), ++ DT_CLK(NULL, "func_mcasp_abe_gfclk", "abe-clkctrl:0020:24"), ++ DT_CLK(NULL, "func_mcbsp1_gfclk", "abe-clkctrl:0028:24"), ++ DT_CLK(NULL, "func_mcbsp2_gfclk", "abe-clkctrl:0030:24"), ++ DT_CLK(NULL, "func_mcbsp3_gfclk", "abe-clkctrl:0038:24"), ++ DT_CLK(NULL, "gpio1_dbclk", "l4-wkup-clkctrl:0018:8"), ++ DT_CLK(NULL, "gpio2_dbclk", "l4-per-clkctrl:0040:8"), ++ DT_CLK(NULL, "gpio3_dbclk", "l4-per-clkctrl:0048:8"), ++ DT_CLK(NULL, "gpio4_dbclk", "l4-per-clkctrl:0050:8"), ++ DT_CLK(NULL, "gpio5_dbclk", "l4-per-clkctrl:0058:8"), ++ DT_CLK(NULL, "gpio6_dbclk", "l4-per-clkctrl:0060:8"), ++ DT_CLK(NULL, "hsi_fck", "l3-init-clkctrl:0018:24"), ++ DT_CLK(NULL, "hsmmc1_fclk", "l3-init-clkctrl:0008:24"), ++ DT_CLK(NULL, "hsmmc2_fclk", "l3-init-clkctrl:0010:24"), ++ DT_CLK(NULL, "iss_ctrlclk", "iss-clkctrl:0000:8"), ++ DT_CLK(NULL, "mcasp_sync_mux_ck", "abe-clkctrl:0020:26"), ++ DT_CLK(NULL, "mcbsp1_sync_mux_ck", "abe-clkctrl:0028:26"), ++ DT_CLK(NULL, "mcbsp2_sync_mux_ck", "abe-clkctrl:0030:26"), ++ DT_CLK(NULL, "mcbsp3_sync_mux_ck", "abe-clkctrl:0038:26"), ++ DT_CLK(NULL, "mcbsp4_sync_mux_ck", "l4-per-clkctrl:00c0:26"), ++ DT_CLK(NULL, "ocp2scp_usb_phy_phy_48m", "l3-init-clkctrl:00c0:8"), ++ DT_CLK(NULL, "otg_60m_gfclk", "l3-init-clkctrl:0040:24"), ++ DT_CLK(NULL, "per_mcbsp4_gfclk", "l4-per-clkctrl:00c0:24"), ++ DT_CLK(NULL, "pmd_stm_clock_mux_ck", "emu-sys-clkctrl:0000:20"), ++ DT_CLK(NULL, "pmd_trace_clk_mux_ck", "emu-sys-clkctrl:0000:22"), ++ DT_CLK(NULL, "sgx_clk_mux", "l3-gfx-clkctrl:0000:24"), ++ DT_CLK(NULL, "slimbus1_fclk_0", "abe-clkctrl:0040:8"), ++ DT_CLK(NULL, "slimbus1_fclk_1", "abe-clkctrl:0040:9"), ++ DT_CLK(NULL, "slimbus1_fclk_2", "abe-clkctrl:0040:10"), ++ DT_CLK(NULL, "slimbus1_slimbus_clk", "abe-clkctrl:0040:11"), ++ DT_CLK(NULL, "slimbus2_fclk_0", "l4-per-clkctrl:0118:8"), ++ DT_CLK(NULL, "slimbus2_fclk_1", "l4-per-clkctrl:0118:9"), ++ DT_CLK(NULL, "slimbus2_slimbus_clk", "l4-per-clkctrl:0118:10"), ++ DT_CLK(NULL, "stm_clk_div_ck", "emu-sys-clkctrl:0000:27"), ++ DT_CLK(NULL, "timer5_sync_mux", "abe-clkctrl:0048:24"), ++ DT_CLK(NULL, "timer6_sync_mux", "abe-clkctrl:0050:24"), ++ DT_CLK(NULL, "timer7_sync_mux", "abe-clkctrl:0058:24"), ++ DT_CLK(NULL, "timer8_sync_mux", "abe-clkctrl:0060:24"), ++ DT_CLK(NULL, "trace_clk_div_div_ck", "emu-sys-clkctrl:0000:24"), ++ DT_CLK(NULL, "usb_host_hs_func48mclk", "l3-init-clkctrl:0038:15"), ++ DT_CLK(NULL, "usb_host_hs_hsic480m_p1_clk", "l3-init-clkctrl:0038:13"), ++ DT_CLK(NULL, "usb_host_hs_hsic480m_p2_clk", "l3-init-clkctrl:0038:14"), ++ DT_CLK(NULL, "usb_host_hs_hsic60m_p1_clk", "l3-init-clkctrl:0038:11"), ++ DT_CLK(NULL, "usb_host_hs_hsic60m_p2_clk", "l3-init-clkctrl:0038:12"), ++ DT_CLK(NULL, "usb_host_hs_utmi_p1_clk", "l3-init-clkctrl:0038:8"), ++ DT_CLK(NULL, "usb_host_hs_utmi_p2_clk", "l3-init-clkctrl:0038:9"), ++ DT_CLK(NULL, "usb_host_hs_utmi_p3_clk", "l3_init-clkctrl:0038:10"), ++ DT_CLK(NULL, "usb_otg_hs_xclk", "l3-init-clkctrl:0040:8"), ++ DT_CLK(NULL, "usb_tll_hs_usb_ch0_clk", "l3-init-clkctrl:0048:8"), ++ DT_CLK(NULL, "usb_tll_hs_usb_ch1_clk", "l3-init-clkctrl:0048:9"), ++ DT_CLK(NULL, "usb_tll_hs_usb_ch2_clk", "l3-init-clkctrl:0048:10"), ++ DT_CLK(NULL, "utmi_p1_gfclk", "l3-init-clkctrl:0038:24"), ++ DT_CLK(NULL, "utmi_p2_gfclk", "l3-init-clkctrl:0038:25"), + { .node_name = NULL }, + }; + +diff --git a/drivers/clk/ti/clk-54xx.c b/drivers/clk/ti/clk-54xx.c +index 8694bc9f5fc7f..04a5408085acc 100644 +--- a/drivers/clk/ti/clk-54xx.c ++++ b/drivers/clk/ti/clk-54xx.c +@@ -50,7 +50,7 @@ static const struct omap_clkctrl_bit_data omap5_aess_bit_data[] __initconst = { + }; + + static const char * const omap5_dmic_gfclk_parents[] __initconst = { +- "abe_cm:clk:0018:26", ++ "abe-clkctrl:0018:26", + "pad_clks_ck", + "slimbus_clk", + NULL, +@@ -70,7 +70,7 @@ static const struct omap_clkctrl_bit_data omap5_dmic_bit_data[] __initconst = { + }; + + static const char * const omap5_mcbsp1_gfclk_parents[] __initconst = { +- "abe_cm:clk:0028:26", ++ "abe-clkctrl:0028:26", + "pad_clks_ck", + "slimbus_clk", + NULL, +@@ -83,7 +83,7 @@ static const struct omap_clkctrl_bit_data omap5_mcbsp1_bit_data[] __initconst = + }; + + static const char * const omap5_mcbsp2_gfclk_parents[] __initconst = { +- "abe_cm:clk:0030:26", ++ "abe-clkctrl:0030:26", + "pad_clks_ck", + "slimbus_clk", + NULL, +@@ -96,7 +96,7 @@ static const struct omap_clkctrl_bit_data omap5_mcbsp2_bit_data[] __initconst = + }; + + static const char * const omap5_mcbsp3_gfclk_parents[] __initconst = { +- "abe_cm:clk:0038:26", ++ "abe-clkctrl:0038:26", + "pad_clks_ck", + "slimbus_clk", + NULL, +@@ -136,16 +136,16 @@ static const struct omap_clkctrl_bit_data omap5_timer8_bit_data[] __initconst = + + static const struct omap_clkctrl_reg_data omap5_abe_clkctrl_regs[] __initconst = { + { OMAP5_L4_ABE_CLKCTRL, NULL, 0, "abe_iclk" }, +- { OMAP5_AESS_CLKCTRL, omap5_aess_bit_data, CLKF_SW_SUP, "abe_cm:clk:0008:24" }, ++ { OMAP5_AESS_CLKCTRL, omap5_aess_bit_data, CLKF_SW_SUP, "abe-clkctrl:0008:24" }, + { OMAP5_MCPDM_CLKCTRL, NULL, CLKF_SW_SUP, "pad_clks_ck" }, +- { OMAP5_DMIC_CLKCTRL, omap5_dmic_bit_data, CLKF_SW_SUP, "abe_cm:clk:0018:24" }, +- { OMAP5_MCBSP1_CLKCTRL, omap5_mcbsp1_bit_data, CLKF_SW_SUP, "abe_cm:clk:0028:24" }, +- { OMAP5_MCBSP2_CLKCTRL, omap5_mcbsp2_bit_data, CLKF_SW_SUP, "abe_cm:clk:0030:24" }, +- { OMAP5_MCBSP3_CLKCTRL, omap5_mcbsp3_bit_data, CLKF_SW_SUP, "abe_cm:clk:0038:24" }, +- { OMAP5_TIMER5_CLKCTRL, omap5_timer5_bit_data, CLKF_SW_SUP, "abe_cm:clk:0048:24" }, +- { OMAP5_TIMER6_CLKCTRL, omap5_timer6_bit_data, CLKF_SW_SUP, "abe_cm:clk:0050:24" }, +- { OMAP5_TIMER7_CLKCTRL, omap5_timer7_bit_data, CLKF_SW_SUP, "abe_cm:clk:0058:24" }, +- { OMAP5_TIMER8_CLKCTRL, omap5_timer8_bit_data, CLKF_SW_SUP, "abe_cm:clk:0060:24" }, ++ { OMAP5_DMIC_CLKCTRL, omap5_dmic_bit_data, CLKF_SW_SUP, "abe-clkctrl:0018:24" }, ++ { OMAP5_MCBSP1_CLKCTRL, omap5_mcbsp1_bit_data, CLKF_SW_SUP, "abe-clkctrl:0028:24" }, ++ { OMAP5_MCBSP2_CLKCTRL, omap5_mcbsp2_bit_data, CLKF_SW_SUP, "abe-clkctrl:0030:24" }, ++ { OMAP5_MCBSP3_CLKCTRL, omap5_mcbsp3_bit_data, CLKF_SW_SUP, "abe-clkctrl:0038:24" }, ++ { OMAP5_TIMER5_CLKCTRL, omap5_timer5_bit_data, CLKF_SW_SUP, "abe-clkctrl:0048:24" }, ++ { OMAP5_TIMER6_CLKCTRL, omap5_timer6_bit_data, CLKF_SW_SUP, "abe-clkctrl:0050:24" }, ++ { OMAP5_TIMER7_CLKCTRL, omap5_timer7_bit_data, CLKF_SW_SUP, "abe-clkctrl:0058:24" }, ++ { OMAP5_TIMER8_CLKCTRL, omap5_timer8_bit_data, CLKF_SW_SUP, "abe-clkctrl:0060:24" }, + { 0 }, + }; + +@@ -266,12 +266,12 @@ static const struct omap_clkctrl_bit_data omap5_gpio8_bit_data[] __initconst = { + }; + + static const struct omap_clkctrl_reg_data omap5_l4per_clkctrl_regs[] __initconst = { +- { OMAP5_TIMER10_CLKCTRL, omap5_timer10_bit_data, CLKF_SW_SUP, "l4per_cm:clk:0008:24" }, +- { OMAP5_TIMER11_CLKCTRL, omap5_timer11_bit_data, CLKF_SW_SUP, "l4per_cm:clk:0010:24" }, +- { OMAP5_TIMER2_CLKCTRL, omap5_timer2_bit_data, CLKF_SW_SUP, "l4per_cm:clk:0018:24" }, +- { OMAP5_TIMER3_CLKCTRL, omap5_timer3_bit_data, CLKF_SW_SUP, "l4per_cm:clk:0020:24" }, +- { OMAP5_TIMER4_CLKCTRL, omap5_timer4_bit_data, CLKF_SW_SUP, "l4per_cm:clk:0028:24" }, +- { OMAP5_TIMER9_CLKCTRL, omap5_timer9_bit_data, CLKF_SW_SUP, "l4per_cm:clk:0030:24" }, ++ { OMAP5_TIMER10_CLKCTRL, omap5_timer10_bit_data, CLKF_SW_SUP, "l4per-clkctrl:0008:24" }, ++ { OMAP5_TIMER11_CLKCTRL, omap5_timer11_bit_data, CLKF_SW_SUP, "l4per-clkctrl:0010:24" }, ++ { OMAP5_TIMER2_CLKCTRL, omap5_timer2_bit_data, CLKF_SW_SUP, "l4per-clkctrl:0018:24" }, ++ { OMAP5_TIMER3_CLKCTRL, omap5_timer3_bit_data, CLKF_SW_SUP, "l4per-clkctrl:0020:24" }, ++ { OMAP5_TIMER4_CLKCTRL, omap5_timer4_bit_data, CLKF_SW_SUP, "l4per-clkctrl:0028:24" }, ++ { OMAP5_TIMER9_CLKCTRL, omap5_timer9_bit_data, CLKF_SW_SUP, "l4per-clkctrl:0030:24" }, + { OMAP5_GPIO2_CLKCTRL, omap5_gpio2_bit_data, CLKF_HW_SUP, "l4_root_clk_div" }, + { OMAP5_GPIO3_CLKCTRL, omap5_gpio3_bit_data, CLKF_HW_SUP, "l4_root_clk_div" }, + { OMAP5_GPIO4_CLKCTRL, omap5_gpio4_bit_data, CLKF_HW_SUP, "l4_root_clk_div" }, +@@ -343,7 +343,7 @@ static const struct omap_clkctrl_bit_data omap5_dss_core_bit_data[] __initconst + }; + + static const struct omap_clkctrl_reg_data omap5_dss_clkctrl_regs[] __initconst = { +- { OMAP5_DSS_CORE_CLKCTRL, omap5_dss_core_bit_data, CLKF_SW_SUP, "dss_cm:clk:0000:8" }, ++ { OMAP5_DSS_CORE_CLKCTRL, omap5_dss_core_bit_data, CLKF_SW_SUP, "dss-clkctrl:0000:8" }, + { 0 }, + }; + +@@ -376,7 +376,7 @@ static const struct omap_clkctrl_bit_data omap5_gpu_core_bit_data[] __initconst + }; + + static const struct omap_clkctrl_reg_data omap5_gpu_clkctrl_regs[] __initconst = { +- { OMAP5_GPU_CLKCTRL, omap5_gpu_core_bit_data, CLKF_SW_SUP, "gpu_cm:clk:0000:24" }, ++ { OMAP5_GPU_CLKCTRL, omap5_gpu_core_bit_data, CLKF_SW_SUP, "gpu-clkctrl:0000:24" }, + { 0 }, + }; + +@@ -387,7 +387,7 @@ static const char * const omap5_mmc1_fclk_mux_parents[] __initconst = { + }; + + static const char * const omap5_mmc1_fclk_parents[] __initconst = { +- "l3init_cm:clk:0008:24", ++ "l3init-clkctrl:0008:24", + NULL, + }; + +@@ -403,7 +403,7 @@ static const struct omap_clkctrl_bit_data omap5_mmc1_bit_data[] __initconst = { + }; + + static const char * const omap5_mmc2_fclk_parents[] __initconst = { +- "l3init_cm:clk:0010:24", ++ "l3init-clkctrl:0010:24", + NULL, + }; + +@@ -428,12 +428,12 @@ static const char * const omap5_usb_host_hs_hsic480m_p3_clk_parents[] __initcons + }; + + static const char * const omap5_usb_host_hs_utmi_p1_clk_parents[] __initconst = { +- "l3init_cm:clk:0038:24", ++ "l3init-clkctrl:0038:24", + NULL, + }; + + static const char * const omap5_usb_host_hs_utmi_p2_clk_parents[] __initconst = { +- "l3init_cm:clk:0038:25", ++ "l3init-clkctrl:0038:25", + NULL, + }; + +@@ -492,8 +492,8 @@ static const struct omap_clkctrl_bit_data omap5_usb_otg_ss_bit_data[] __initcons + }; + + static const struct omap_clkctrl_reg_data omap5_l3init_clkctrl_regs[] __initconst = { +- { OMAP5_MMC1_CLKCTRL, omap5_mmc1_bit_data, CLKF_SW_SUP, "l3init_cm:clk:0008:25" }, +- { OMAP5_MMC2_CLKCTRL, omap5_mmc2_bit_data, CLKF_SW_SUP, "l3init_cm:clk:0010:25" }, ++ { OMAP5_MMC1_CLKCTRL, omap5_mmc1_bit_data, CLKF_SW_SUP, "l3init-clkctrl:0008:25" }, ++ { OMAP5_MMC2_CLKCTRL, omap5_mmc2_bit_data, CLKF_SW_SUP, "l3init-clkctrl:0010:25" }, + { OMAP5_USB_HOST_HS_CLKCTRL, omap5_usb_host_hs_bit_data, CLKF_SW_SUP, "l3init_60m_fclk" }, + { OMAP5_USB_TLL_HS_CLKCTRL, omap5_usb_tll_hs_bit_data, CLKF_HW_SUP, "l4_root_clk_div" }, + { OMAP5_SATA_CLKCTRL, omap5_sata_bit_data, CLKF_SW_SUP, "func_48m_fclk" }, +@@ -517,7 +517,7 @@ static const struct omap_clkctrl_reg_data omap5_wkupaon_clkctrl_regs[] __initcon + { OMAP5_L4_WKUP_CLKCTRL, NULL, 0, "wkupaon_iclk_mux" }, + { OMAP5_WD_TIMER2_CLKCTRL, NULL, CLKF_SW_SUP, "sys_32k_ck" }, + { OMAP5_GPIO1_CLKCTRL, omap5_gpio1_bit_data, CLKF_HW_SUP, "wkupaon_iclk_mux" }, +- { OMAP5_TIMER1_CLKCTRL, omap5_timer1_bit_data, CLKF_SW_SUP, "wkupaon_cm:clk:0020:24" }, ++ { OMAP5_TIMER1_CLKCTRL, omap5_timer1_bit_data, CLKF_SW_SUP, "wkupaon-clkctrl:0020:24" }, + { OMAP5_COUNTER_32K_CLKCTRL, NULL, 0, "wkupaon_iclk_mux" }, + { OMAP5_KBD_CLKCTRL, NULL, CLKF_SW_SUP, "sys_32k_ck" }, + { 0 }, +@@ -547,58 +547,58 @@ const struct omap_clkctrl_data omap5_clkctrl_data[] __initconst = { + static struct ti_dt_clk omap54xx_clks[] = { + DT_CLK(NULL, "timer_32k_ck", "sys_32k_ck"), + DT_CLK(NULL, "sys_clkin_ck", "sys_clkin"), +- DT_CLK(NULL, "dmic_gfclk", "abe_cm:0018:24"), +- DT_CLK(NULL, "dmic_sync_mux_ck", "abe_cm:0018:26"), +- DT_CLK(NULL, "dss_32khz_clk", "dss_cm:0000:11"), +- DT_CLK(NULL, "dss_48mhz_clk", "dss_cm:0000:9"), +- DT_CLK(NULL, "dss_dss_clk", "dss_cm:0000:8"), +- DT_CLK(NULL, "dss_sys_clk", "dss_cm:0000:10"), +- DT_CLK(NULL, "gpio1_dbclk", "wkupaon_cm:0018:8"), +- DT_CLK(NULL, "gpio2_dbclk", "l4per_cm:0040:8"), +- DT_CLK(NULL, "gpio3_dbclk", "l4per_cm:0048:8"), +- DT_CLK(NULL, "gpio4_dbclk", "l4per_cm:0050:8"), +- DT_CLK(NULL, "gpio5_dbclk", "l4per_cm:0058:8"), +- DT_CLK(NULL, "gpio6_dbclk", "l4per_cm:0060:8"), +- DT_CLK(NULL, "gpio7_dbclk", "l4per_cm:00f0:8"), +- DT_CLK(NULL, "gpio8_dbclk", "l4per_cm:00f8:8"), +- DT_CLK(NULL, "mcbsp1_gfclk", "abe_cm:0028:24"), +- DT_CLK(NULL, "mcbsp1_sync_mux_ck", "abe_cm:0028:26"), +- DT_CLK(NULL, "mcbsp2_gfclk", "abe_cm:0030:24"), +- DT_CLK(NULL, "mcbsp2_sync_mux_ck", "abe_cm:0030:26"), +- DT_CLK(NULL, "mcbsp3_gfclk", "abe_cm:0038:24"), +- DT_CLK(NULL, "mcbsp3_sync_mux_ck", "abe_cm:0038:26"), +- DT_CLK(NULL, "mmc1_32khz_clk", "l3init_cm:0008:8"), +- DT_CLK(NULL, "mmc1_fclk", "l3init_cm:0008:25"), +- DT_CLK(NULL, "mmc1_fclk_mux", "l3init_cm:0008:24"), +- DT_CLK(NULL, "mmc2_fclk", "l3init_cm:0010:25"), +- DT_CLK(NULL, "mmc2_fclk_mux", "l3init_cm:0010:24"), +- DT_CLK(NULL, "sata_ref_clk", "l3init_cm:0068:8"), +- DT_CLK(NULL, "timer10_gfclk_mux", "l4per_cm:0008:24"), +- DT_CLK(NULL, "timer11_gfclk_mux", "l4per_cm:0010:24"), +- DT_CLK(NULL, "timer1_gfclk_mux", "wkupaon_cm:0020:24"), +- DT_CLK(NULL, "timer2_gfclk_mux", "l4per_cm:0018:24"), +- DT_CLK(NULL, "timer3_gfclk_mux", "l4per_cm:0020:24"), +- DT_CLK(NULL, "timer4_gfclk_mux", "l4per_cm:0028:24"), +- DT_CLK(NULL, "timer5_gfclk_mux", "abe_cm:0048:24"), +- DT_CLK(NULL, "timer6_gfclk_mux", "abe_cm:0050:24"), +- DT_CLK(NULL, "timer7_gfclk_mux", "abe_cm:0058:24"), +- DT_CLK(NULL, "timer8_gfclk_mux", "abe_cm:0060:24"), +- DT_CLK(NULL, "timer9_gfclk_mux", "l4per_cm:0030:24"), +- DT_CLK(NULL, "usb_host_hs_hsic480m_p1_clk", "l3init_cm:0038:13"), +- DT_CLK(NULL, "usb_host_hs_hsic480m_p2_clk", "l3init_cm:0038:14"), +- DT_CLK(NULL, "usb_host_hs_hsic480m_p3_clk", "l3init_cm:0038:7"), +- DT_CLK(NULL, "usb_host_hs_hsic60m_p1_clk", "l3init_cm:0038:11"), +- DT_CLK(NULL, "usb_host_hs_hsic60m_p2_clk", "l3init_cm:0038:12"), +- DT_CLK(NULL, "usb_host_hs_hsic60m_p3_clk", "l3init_cm:0038:6"), +- DT_CLK(NULL, "usb_host_hs_utmi_p1_clk", "l3init_cm:0038:8"), +- DT_CLK(NULL, "usb_host_hs_utmi_p2_clk", "l3init_cm:0038:9"), +- DT_CLK(NULL, "usb_host_hs_utmi_p3_clk", "l3init_cm:0038:10"), +- DT_CLK(NULL, "usb_otg_ss_refclk960m", "l3init_cm:00d0:8"), +- DT_CLK(NULL, "usb_tll_hs_usb_ch0_clk", "l3init_cm:0048:8"), +- DT_CLK(NULL, "usb_tll_hs_usb_ch1_clk", "l3init_cm:0048:9"), +- DT_CLK(NULL, "usb_tll_hs_usb_ch2_clk", "l3init_cm:0048:10"), +- DT_CLK(NULL, "utmi_p1_gfclk", "l3init_cm:0038:24"), +- DT_CLK(NULL, "utmi_p2_gfclk", "l3init_cm:0038:25"), ++ DT_CLK(NULL, "dmic_gfclk", "abe-clkctrl:0018:24"), ++ DT_CLK(NULL, "dmic_sync_mux_ck", "abe-clkctrl:0018:26"), ++ DT_CLK(NULL, "dss_32khz_clk", "dss-clkctrl:0000:11"), ++ DT_CLK(NULL, "dss_48mhz_clk", "dss-clkctrl:0000:9"), ++ DT_CLK(NULL, "dss_dss_clk", "dss-clkctrl:0000:8"), ++ DT_CLK(NULL, "dss_sys_clk", "dss-clkctrl:0000:10"), ++ DT_CLK(NULL, "gpio1_dbclk", "wkupaon-clkctrl:0018:8"), ++ DT_CLK(NULL, "gpio2_dbclk", "l4per-clkctrl:0040:8"), ++ DT_CLK(NULL, "gpio3_dbclk", "l4per-clkctrl:0048:8"), ++ DT_CLK(NULL, "gpio4_dbclk", "l4per-clkctrl:0050:8"), ++ DT_CLK(NULL, "gpio5_dbclk", "l4per-clkctrl:0058:8"), ++ DT_CLK(NULL, "gpio6_dbclk", "l4per-clkctrl:0060:8"), ++ DT_CLK(NULL, "gpio7_dbclk", "l4per-clkctrl:00f0:8"), ++ DT_CLK(NULL, "gpio8_dbclk", "l4per-clkctrl:00f8:8"), ++ DT_CLK(NULL, "mcbsp1_gfclk", "abe-clkctrl:0028:24"), ++ DT_CLK(NULL, "mcbsp1_sync_mux_ck", "abe-clkctrl:0028:26"), ++ DT_CLK(NULL, "mcbsp2_gfclk", "abe-clkctrl:0030:24"), ++ DT_CLK(NULL, "mcbsp2_sync_mux_ck", "abe-clkctrl:0030:26"), ++ DT_CLK(NULL, "mcbsp3_gfclk", "abe-clkctrl:0038:24"), ++ DT_CLK(NULL, "mcbsp3_sync_mux_ck", "abe-clkctrl:0038:26"), ++ DT_CLK(NULL, "mmc1_32khz_clk", "l3init-clkctrl:0008:8"), ++ DT_CLK(NULL, "mmc1_fclk", "l3init-clkctrl:0008:25"), ++ DT_CLK(NULL, "mmc1_fclk_mux", "l3init-clkctrl:0008:24"), ++ DT_CLK(NULL, "mmc2_fclk", "l3init-clkctrl:0010:25"), ++ DT_CLK(NULL, "mmc2_fclk_mux", "l3init-clkctrl:0010:24"), ++ DT_CLK(NULL, "sata_ref_clk", "l3init-clkctrl:0068:8"), ++ DT_CLK(NULL, "timer10_gfclk_mux", "l4per-clkctrl:0008:24"), ++ DT_CLK(NULL, "timer11_gfclk_mux", "l4per-clkctrl:0010:24"), ++ DT_CLK(NULL, "timer1_gfclk_mux", "wkupaon-clkctrl:0020:24"), ++ DT_CLK(NULL, "timer2_gfclk_mux", "l4per-clkctrl:0018:24"), ++ DT_CLK(NULL, "timer3_gfclk_mux", "l4per-clkctrl:0020:24"), ++ DT_CLK(NULL, "timer4_gfclk_mux", "l4per-clkctrl:0028:24"), ++ DT_CLK(NULL, "timer5_gfclk_mux", "abe-clkctrl:0048:24"), ++ DT_CLK(NULL, "timer6_gfclk_mux", "abe-clkctrl:0050:24"), ++ DT_CLK(NULL, "timer7_gfclk_mux", "abe-clkctrl:0058:24"), ++ DT_CLK(NULL, "timer8_gfclk_mux", "abe-clkctrl:0060:24"), ++ DT_CLK(NULL, "timer9_gfclk_mux", "l4per-clkctrl:0030:24"), ++ DT_CLK(NULL, "usb_host_hs_hsic480m_p1_clk", "l3init-clkctrl:0038:13"), ++ DT_CLK(NULL, "usb_host_hs_hsic480m_p2_clk", "l3init-clkctrl:0038:14"), ++ DT_CLK(NULL, "usb_host_hs_hsic480m_p3_clk", "l3init-clkctrl:0038:7"), ++ DT_CLK(NULL, "usb_host_hs_hsic60m_p1_clk", "l3init-clkctrl:0038:11"), ++ DT_CLK(NULL, "usb_host_hs_hsic60m_p2_clk", "l3init-clkctrl:0038:12"), ++ DT_CLK(NULL, "usb_host_hs_hsic60m_p3_clk", "l3init-clkctrl:0038:6"), ++ DT_CLK(NULL, "usb_host_hs_utmi_p1_clk", "l3init-clkctrl:0038:8"), ++ DT_CLK(NULL, "usb_host_hs_utmi_p2_clk", "l3init-clkctrl:0038:9"), ++ DT_CLK(NULL, "usb_host_hs_utmi_p3_clk", "l3init-clkctrl:0038:10"), ++ DT_CLK(NULL, "usb_otg_ss_refclk960m", "l3init-clkctrl:00d0:8"), ++ DT_CLK(NULL, "usb_tll_hs_usb_ch0_clk", "l3init-clkctrl:0048:8"), ++ DT_CLK(NULL, "usb_tll_hs_usb_ch1_clk", "l3init-clkctrl:0048:9"), ++ DT_CLK(NULL, "usb_tll_hs_usb_ch2_clk", "l3init-clkctrl:0048:10"), ++ DT_CLK(NULL, "utmi_p1_gfclk", "l3init-clkctrl:0038:24"), ++ DT_CLK(NULL, "utmi_p2_gfclk", "l3init-clkctrl:0038:25"), + { .node_name = NULL }, + }; + +diff --git a/drivers/clk/ti/clkctrl.c b/drivers/clk/ti/clkctrl.c +index 864c484bde1b4..08a85c559f795 100644 +--- a/drivers/clk/ti/clkctrl.c ++++ b/drivers/clk/ti/clkctrl.c +@@ -511,10 +511,6 @@ static void __init _ti_omap4_clkctrl_setup(struct device_node *node) + char *c; + u16 soc_mask = 0; + +- if (!(ti_clk_get_features()->flags & TI_CLK_CLKCTRL_COMPAT) && +- of_node_name_eq(node, "clk")) +- ti_clk_features.flags |= TI_CLK_CLKCTRL_COMPAT; +- + addrp = of_get_address(node, 0, NULL, NULL); + addr = (u32)of_translate_address(node, addrp); + +diff --git a/drivers/dma/sprd-dma.c b/drivers/dma/sprd-dma.c +index 4357d2395e6b7..60115d8d40832 100644 +--- a/drivers/dma/sprd-dma.c ++++ b/drivers/dma/sprd-dma.c +@@ -1236,11 +1236,8 @@ static int sprd_dma_remove(struct platform_device *pdev) + { + struct sprd_dma_dev *sdev = platform_get_drvdata(pdev); + struct sprd_dma_chn *c, *cn; +- int ret; + +- ret = pm_runtime_get_sync(&pdev->dev); +- if (ret < 0) +- return ret; ++ pm_runtime_get_sync(&pdev->dev); + + /* explicitly free the irq */ + if (sdev->irq > 0) +diff --git a/drivers/gpu/drm/meson/meson_drv.c b/drivers/gpu/drm/meson/meson_drv.c +index 728fea5094124..2d022f3fb437e 100644 +--- a/drivers/gpu/drm/meson/meson_drv.c ++++ b/drivers/gpu/drm/meson/meson_drv.c +@@ -116,8 +116,11 @@ static bool meson_vpu_has_available_connectors(struct device *dev) + for_each_endpoint_of_node(dev->of_node, ep) { + /* If the endpoint node exists, consider it enabled */ + remote = of_graph_get_remote_port(ep); +- if (remote) ++ if (remote) { ++ of_node_put(remote); ++ of_node_put(ep); + return true; ++ } + } + + return false; +diff --git a/drivers/gpu/drm/meson/meson_viu.c b/drivers/gpu/drm/meson/meson_viu.c +index 259f3e6bec90a..bb7e109534de1 100644 +--- a/drivers/gpu/drm/meson/meson_viu.c ++++ b/drivers/gpu/drm/meson/meson_viu.c +@@ -469,17 +469,17 @@ void meson_viu_init(struct meson_drm *priv) + priv->io_base + _REG(VD2_IF0_LUMA_FIFO_SIZE)); + + if (meson_vpu_is_compatible(priv, VPU_COMPATIBLE_G12A)) { +- writel_relaxed(VIU_OSD_BLEND_REORDER(0, 1) | +- VIU_OSD_BLEND_REORDER(1, 0) | +- VIU_OSD_BLEND_REORDER(2, 0) | +- VIU_OSD_BLEND_REORDER(3, 0) | +- VIU_OSD_BLEND_DIN_EN(1) | +- VIU_OSD_BLEND1_DIN3_BYPASS_TO_DOUT1 | +- VIU_OSD_BLEND1_DOUT_BYPASS_TO_BLEND2 | +- VIU_OSD_BLEND_DIN0_BYPASS_TO_DOUT0 | +- VIU_OSD_BLEND_BLEN2_PREMULT_EN(1) | +- VIU_OSD_BLEND_HOLD_LINES(4), +- priv->io_base + _REG(VIU_OSD_BLEND_CTRL)); ++ u32 val = (u32)VIU_OSD_BLEND_REORDER(0, 1) | ++ (u32)VIU_OSD_BLEND_REORDER(1, 0) | ++ (u32)VIU_OSD_BLEND_REORDER(2, 0) | ++ (u32)VIU_OSD_BLEND_REORDER(3, 0) | ++ (u32)VIU_OSD_BLEND_DIN_EN(1) | ++ (u32)VIU_OSD_BLEND1_DIN3_BYPASS_TO_DOUT1 | ++ (u32)VIU_OSD_BLEND1_DOUT_BYPASS_TO_BLEND2 | ++ (u32)VIU_OSD_BLEND_DIN0_BYPASS_TO_DOUT0 | ++ (u32)VIU_OSD_BLEND_BLEN2_PREMULT_EN(1) | ++ (u32)VIU_OSD_BLEND_HOLD_LINES(4); ++ writel_relaxed(val, priv->io_base + _REG(VIU_OSD_BLEND_CTRL)); + + writel_relaxed(OSD_BLEND_PATH_SEL_ENABLE, + priv->io_base + _REG(OSD1_BLEND_SRC_CTRL)); +diff --git a/drivers/gpu/drm/sun4i/sun6i_mipi_dsi.c b/drivers/gpu/drm/sun4i/sun6i_mipi_dsi.c +index 4f5efcace68ea..51edb4244af7c 100644 +--- a/drivers/gpu/drm/sun4i/sun6i_mipi_dsi.c ++++ b/drivers/gpu/drm/sun4i/sun6i_mipi_dsi.c +@@ -531,7 +531,7 @@ static void sun6i_dsi_setup_timings(struct sun6i_dsi *dsi, + struct drm_display_mode *mode) + { + struct mipi_dsi_device *device = dsi->device; +- unsigned int Bpp = mipi_dsi_pixel_format_to_bpp(device->format) / 8; ++ int Bpp = mipi_dsi_pixel_format_to_bpp(device->format) / 8; + u16 hbp = 0, hfp = 0, hsa = 0, hblk = 0, vblk = 0; + u32 basic_ctl = 0; + size_t bytes; +@@ -555,7 +555,7 @@ static void sun6i_dsi_setup_timings(struct sun6i_dsi *dsi, + * (4 bytes). Its minimal size is therefore 10 bytes + */ + #define HSA_PACKET_OVERHEAD 10 +- hsa = max((unsigned int)HSA_PACKET_OVERHEAD, ++ hsa = max(HSA_PACKET_OVERHEAD, + (mode->hsync_end - mode->hsync_start) * Bpp - HSA_PACKET_OVERHEAD); + + /* +@@ -564,7 +564,7 @@ static void sun6i_dsi_setup_timings(struct sun6i_dsi *dsi, + * therefore 6 bytes + */ + #define HBP_PACKET_OVERHEAD 6 +- hbp = max((unsigned int)HBP_PACKET_OVERHEAD, ++ hbp = max(HBP_PACKET_OVERHEAD, + (mode->htotal - mode->hsync_end) * Bpp - HBP_PACKET_OVERHEAD); + + /* +@@ -574,7 +574,7 @@ static void sun6i_dsi_setup_timings(struct sun6i_dsi *dsi, + * 16 bytes + */ + #define HFP_PACKET_OVERHEAD 16 +- hfp = max((unsigned int)HFP_PACKET_OVERHEAD, ++ hfp = max(HFP_PACKET_OVERHEAD, + (mode->hsync_start - mode->hdisplay) * Bpp - HFP_PACKET_OVERHEAD); + + /* +@@ -583,7 +583,7 @@ static void sun6i_dsi_setup_timings(struct sun6i_dsi *dsi, + * bytes). Its minimal size is therefore 10 bytes. + */ + #define HBLK_PACKET_OVERHEAD 10 +- hblk = max((unsigned int)HBLK_PACKET_OVERHEAD, ++ hblk = max(HBLK_PACKET_OVERHEAD, + (mode->htotal - (mode->hsync_end - mode->hsync_start)) * Bpp - + HBLK_PACKET_OVERHEAD); + +diff --git a/drivers/i2c/busses/i2c-imx.c b/drivers/i2c/busses/i2c-imx.c +index 72af4b4d13180..d3719df1c40dc 100644 +--- a/drivers/i2c/busses/i2c-imx.c ++++ b/drivers/i2c/busses/i2c-imx.c +@@ -1280,9 +1280,7 @@ static int i2c_imx_remove(struct platform_device *pdev) + struct imx_i2c_struct *i2c_imx = platform_get_drvdata(pdev); + int irq, ret; + +- ret = pm_runtime_resume_and_get(&pdev->dev); +- if (ret < 0) +- return ret; ++ ret = pm_runtime_get_sync(&pdev->dev); + + /* remove adapter */ + dev_dbg(&i2c_imx->adapter.dev, "adapter removed\n"); +@@ -1291,17 +1289,21 @@ static int i2c_imx_remove(struct platform_device *pdev) + if (i2c_imx->dma) + i2c_imx_dma_free(i2c_imx); + +- /* setup chip registers to defaults */ +- imx_i2c_write_reg(0, i2c_imx, IMX_I2C_IADR); +- imx_i2c_write_reg(0, i2c_imx, IMX_I2C_IFDR); +- imx_i2c_write_reg(0, i2c_imx, IMX_I2C_I2CR); +- imx_i2c_write_reg(0, i2c_imx, IMX_I2C_I2SR); ++ if (ret == 0) { ++ /* setup chip registers to defaults */ ++ imx_i2c_write_reg(0, i2c_imx, IMX_I2C_IADR); ++ imx_i2c_write_reg(0, i2c_imx, IMX_I2C_IFDR); ++ imx_i2c_write_reg(0, i2c_imx, IMX_I2C_I2CR); ++ imx_i2c_write_reg(0, i2c_imx, IMX_I2C_I2SR); ++ clk_disable(i2c_imx->clk); ++ } + + clk_notifier_unregister(i2c_imx->clk, &i2c_imx->clk_change_nb); + irq = platform_get_irq(pdev, 0); + if (irq >= 0) + free_irq(irq, i2c_imx); +- clk_disable_unprepare(i2c_imx->clk); ++ ++ clk_unprepare(i2c_imx->clk); + + pm_runtime_put_noidle(&pdev->dev); + pm_runtime_disable(&pdev->dev); +diff --git a/drivers/infiniband/sw/rxe/rxe_param.h b/drivers/infiniband/sw/rxe/rxe_param.h +index f9fb56ec6dfda..dca86422b0a2c 100644 +--- a/drivers/infiniband/sw/rxe/rxe_param.h ++++ b/drivers/infiniband/sw/rxe/rxe_param.h +@@ -98,6 +98,12 @@ enum rxe_device_param { + RXE_INFLIGHT_SKBS_PER_QP_HIGH = 64, + RXE_INFLIGHT_SKBS_PER_QP_LOW = 16, + ++ /* Max number of interations of each tasklet ++ * before yielding the cpu to let other ++ * work make progress ++ */ ++ RXE_MAX_ITERATIONS = 1024, ++ + /* Delay before calling arbiter timer */ + RXE_NSEC_ARB_TIMER_DELAY = 200, + +diff --git a/drivers/infiniband/sw/rxe/rxe_task.c b/drivers/infiniband/sw/rxe/rxe_task.c +index 6951fdcb31bf5..568cf56c236bc 100644 +--- a/drivers/infiniband/sw/rxe/rxe_task.c ++++ b/drivers/infiniband/sw/rxe/rxe_task.c +@@ -8,7 +8,7 @@ + #include <linux/interrupt.h> + #include <linux/hardirq.h> + +-#include "rxe_task.h" ++#include "rxe.h" + + int __rxe_do_task(struct rxe_task *task) + +@@ -34,6 +34,7 @@ void rxe_do_task(struct tasklet_struct *t) + int ret; + unsigned long flags; + struct rxe_task *task = from_tasklet(task, t, tasklet); ++ unsigned int iterations = RXE_MAX_ITERATIONS; + + spin_lock_irqsave(&task->state_lock, flags); + switch (task->state) { +@@ -62,13 +63,20 @@ void rxe_do_task(struct tasklet_struct *t) + spin_lock_irqsave(&task->state_lock, flags); + switch (task->state) { + case TASK_STATE_BUSY: +- if (ret) ++ if (ret) { + task->state = TASK_STATE_START; +- else ++ } else if (iterations--) { + cont = 1; ++ } else { ++ /* reschedule the tasklet and exit ++ * the loop to give up the cpu ++ */ ++ tasklet_schedule(&task->tasklet); ++ task->state = TASK_STATE_START; ++ } + break; + +- /* soneone tried to run the task since the last time we called ++ /* someone tried to run the task since the last time we called + * func, so we will call one more time regardless of the + * return value + */ +diff --git a/drivers/irqchip/irq-tegra.c b/drivers/irqchip/irq-tegra.c +index e1f771c72fc4c..ad3e2c1b3c87b 100644 +--- a/drivers/irqchip/irq-tegra.c ++++ b/drivers/irqchip/irq-tegra.c +@@ -148,10 +148,10 @@ static int tegra_ictlr_suspend(void) + lic->cop_iep[i] = readl_relaxed(ictlr + ICTLR_COP_IEP_CLASS); + + /* Disable COP interrupts */ +- writel_relaxed(~0ul, ictlr + ICTLR_COP_IER_CLR); ++ writel_relaxed(GENMASK(31, 0), ictlr + ICTLR_COP_IER_CLR); + + /* Disable CPU interrupts */ +- writel_relaxed(~0ul, ictlr + ICTLR_CPU_IER_CLR); ++ writel_relaxed(GENMASK(31, 0), ictlr + ICTLR_CPU_IER_CLR); + + /* Enable the wakeup sources of ictlr */ + writel_relaxed(lic->ictlr_wake_mask[i], ictlr + ICTLR_CPU_IER_SET); +@@ -172,12 +172,12 @@ static void tegra_ictlr_resume(void) + + writel_relaxed(lic->cpu_iep[i], + ictlr + ICTLR_CPU_IEP_CLASS); +- writel_relaxed(~0ul, ictlr + ICTLR_CPU_IER_CLR); ++ writel_relaxed(GENMASK(31, 0), ictlr + ICTLR_CPU_IER_CLR); + writel_relaxed(lic->cpu_ier[i], + ictlr + ICTLR_CPU_IER_SET); + writel_relaxed(lic->cop_iep[i], + ictlr + ICTLR_COP_IEP_CLASS); +- writel_relaxed(~0ul, ictlr + ICTLR_COP_IER_CLR); ++ writel_relaxed(GENMASK(31, 0), ictlr + ICTLR_COP_IER_CLR); + writel_relaxed(lic->cop_ier[i], + ictlr + ICTLR_COP_IER_SET); + } +@@ -312,7 +312,7 @@ static int __init tegra_ictlr_init(struct device_node *node, + lic->base[i] = base; + + /* Disable all interrupts */ +- writel_relaxed(~0UL, base + ICTLR_CPU_IER_CLR); ++ writel_relaxed(GENMASK(31, 0), base + ICTLR_CPU_IER_CLR); + /* All interrupts target IRQ */ + writel_relaxed(0, base + ICTLR_CPU_IEP_CLASS); + +diff --git a/drivers/md/md.c b/drivers/md/md.c +index 4463ef3e3729b..884317ee1759f 100644 +--- a/drivers/md/md.c ++++ b/drivers/md/md.c +@@ -9424,6 +9424,7 @@ void md_reap_sync_thread(struct mddev *mddev) + wake_up(&resync_wait); + /* flag recovery needed just to double check */ + set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); ++ sysfs_notify_dirent_safe(mddev->sysfs_completed); + sysfs_notify_dirent_safe(mddev->sysfs_action); + md_new_event(mddev); + if (mddev->event_work.func) +diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c +index c8cafdb094aaa..01c7edf329367 100644 +--- a/drivers/md/raid5.c ++++ b/drivers/md/raid5.c +@@ -2864,10 +2864,10 @@ static void raid5_end_write_request(struct bio *bi) + if (!test_and_clear_bit(R5_DOUBLE_LOCKED, &sh->dev[i].flags)) + clear_bit(R5_LOCKED, &sh->dev[i].flags); + set_bit(STRIPE_HANDLE, &sh->state); +- raid5_release_stripe(sh); + + if (sh->batch_head && sh != sh->batch_head) + raid5_release_stripe(sh->batch_head); ++ raid5_release_stripe(sh); + } + + static void raid5_error(struct mddev *mddev, struct md_rdev *rdev) +diff --git a/drivers/misc/cxl/irq.c b/drivers/misc/cxl/irq.c +index 4cb829d5d873c..2e4dcfebf19af 100644 +--- a/drivers/misc/cxl/irq.c ++++ b/drivers/misc/cxl/irq.c +@@ -349,6 +349,7 @@ int afu_allocate_irqs(struct cxl_context *ctx, u32 count) + + out: + cxl_ops->release_irq_ranges(&ctx->irqs, ctx->afu->adapter); ++ bitmap_free(ctx->irq_bitmap); + afu_irq_name_free(ctx); + return -ENOMEM; + } +diff --git a/drivers/misc/uacce/uacce.c b/drivers/misc/uacce/uacce.c +index 56dd98ab5a814..95e56eb2cdd06 100644 +--- a/drivers/misc/uacce/uacce.c ++++ b/drivers/misc/uacce/uacce.c +@@ -9,43 +9,38 @@ + + static struct class *uacce_class; + static dev_t uacce_devt; +-static DEFINE_MUTEX(uacce_mutex); + static DEFINE_XARRAY_ALLOC(uacce_xa); + +-static int uacce_start_queue(struct uacce_queue *q) ++/* ++ * If the parent driver or the device disappears, the queue state is invalid and ++ * ops are not usable anymore. ++ */ ++static bool uacce_queue_is_valid(struct uacce_queue *q) + { +- int ret = 0; ++ return q->state == UACCE_Q_INIT || q->state == UACCE_Q_STARTED; ++} + +- mutex_lock(&uacce_mutex); ++static int uacce_start_queue(struct uacce_queue *q) ++{ ++ int ret; + +- if (q->state != UACCE_Q_INIT) { +- ret = -EINVAL; +- goto out_with_lock; +- } ++ if (q->state != UACCE_Q_INIT) ++ return -EINVAL; + + if (q->uacce->ops->start_queue) { + ret = q->uacce->ops->start_queue(q); + if (ret < 0) +- goto out_with_lock; ++ return ret; + } + + q->state = UACCE_Q_STARTED; +- +-out_with_lock: +- mutex_unlock(&uacce_mutex); +- +- return ret; ++ return 0; + } + + static int uacce_put_queue(struct uacce_queue *q) + { + struct uacce_device *uacce = q->uacce; + +- mutex_lock(&uacce_mutex); +- +- if (q->state == UACCE_Q_ZOMBIE) +- goto out; +- + if ((q->state == UACCE_Q_STARTED) && uacce->ops->stop_queue) + uacce->ops->stop_queue(q); + +@@ -54,8 +49,6 @@ static int uacce_put_queue(struct uacce_queue *q) + uacce->ops->put_queue(q); + + q->state = UACCE_Q_ZOMBIE; +-out: +- mutex_unlock(&uacce_mutex); + + return 0; + } +@@ -65,20 +58,36 @@ static long uacce_fops_unl_ioctl(struct file *filep, + { + struct uacce_queue *q = filep->private_data; + struct uacce_device *uacce = q->uacce; ++ long ret = -ENXIO; ++ ++ /* ++ * uacce->ops->ioctl() may take the mmap_lock when copying arg to/from ++ * user. Avoid a circular lock dependency with uacce_fops_mmap(), which ++ * gets called with mmap_lock held, by taking uacce->mutex instead of ++ * q->mutex. Doing this in uacce_fops_mmap() is not possible because ++ * uacce_fops_open() calls iommu_sva_bind_device(), which takes ++ * mmap_lock, while holding uacce->mutex. ++ */ ++ mutex_lock(&uacce->mutex); ++ if (!uacce_queue_is_valid(q)) ++ goto out_unlock; + + switch (cmd) { + case UACCE_CMD_START_Q: +- return uacce_start_queue(q); +- ++ ret = uacce_start_queue(q); ++ break; + case UACCE_CMD_PUT_Q: +- return uacce_put_queue(q); +- ++ ret = uacce_put_queue(q); ++ break; + default: +- if (!uacce->ops->ioctl) +- return -EINVAL; +- +- return uacce->ops->ioctl(q, cmd, arg); ++ if (uacce->ops->ioctl) ++ ret = uacce->ops->ioctl(q, cmd, arg); ++ else ++ ret = -EINVAL; + } ++out_unlock: ++ mutex_unlock(&uacce->mutex); ++ return ret; + } + + #ifdef CONFIG_COMPAT +@@ -136,6 +145,13 @@ static int uacce_fops_open(struct inode *inode, struct file *filep) + if (!q) + return -ENOMEM; + ++ mutex_lock(&uacce->mutex); ++ ++ if (!uacce->parent) { ++ ret = -EINVAL; ++ goto out_with_mem; ++ } ++ + ret = uacce_bind_queue(uacce, q); + if (ret) + goto out_with_mem; +@@ -152,10 +168,9 @@ static int uacce_fops_open(struct inode *inode, struct file *filep) + filep->private_data = q; + uacce->inode = inode; + q->state = UACCE_Q_INIT; +- +- mutex_lock(&uacce->queues_lock); ++ mutex_init(&q->mutex); + list_add(&q->list, &uacce->queues); +- mutex_unlock(&uacce->queues_lock); ++ mutex_unlock(&uacce->mutex); + + return 0; + +@@ -163,18 +178,20 @@ out_with_bond: + uacce_unbind_queue(q); + out_with_mem: + kfree(q); ++ mutex_unlock(&uacce->mutex); + return ret; + } + + static int uacce_fops_release(struct inode *inode, struct file *filep) + { + struct uacce_queue *q = filep->private_data; ++ struct uacce_device *uacce = q->uacce; + +- mutex_lock(&q->uacce->queues_lock); +- list_del(&q->list); +- mutex_unlock(&q->uacce->queues_lock); ++ mutex_lock(&uacce->mutex); + uacce_put_queue(q); + uacce_unbind_queue(q); ++ list_del(&q->list); ++ mutex_unlock(&uacce->mutex); + kfree(q); + + return 0; +@@ -217,10 +234,9 @@ static int uacce_fops_mmap(struct file *filep, struct vm_area_struct *vma) + vma->vm_private_data = q; + qfr->type = type; + +- mutex_lock(&uacce_mutex); +- +- if (q->state != UACCE_Q_INIT && q->state != UACCE_Q_STARTED) { +- ret = -EINVAL; ++ mutex_lock(&q->mutex); ++ if (!uacce_queue_is_valid(q)) { ++ ret = -ENXIO; + goto out_with_lock; + } + +@@ -259,12 +275,12 @@ static int uacce_fops_mmap(struct file *filep, struct vm_area_struct *vma) + } + + q->qfrs[type] = qfr; +- mutex_unlock(&uacce_mutex); ++ mutex_unlock(&q->mutex); + + return ret; + + out_with_lock: +- mutex_unlock(&uacce_mutex); ++ mutex_unlock(&q->mutex); + kfree(qfr); + return ret; + } +@@ -273,12 +289,20 @@ static __poll_t uacce_fops_poll(struct file *file, poll_table *wait) + { + struct uacce_queue *q = file->private_data; + struct uacce_device *uacce = q->uacce; ++ __poll_t ret = 0; ++ ++ mutex_lock(&q->mutex); ++ if (!uacce_queue_is_valid(q)) ++ goto out_unlock; + + poll_wait(file, &q->wait, wait); ++ + if (uacce->ops->is_q_updated && uacce->ops->is_q_updated(q)) +- return EPOLLIN | EPOLLRDNORM; ++ ret = EPOLLIN | EPOLLRDNORM; + +- return 0; ++out_unlock: ++ mutex_unlock(&q->mutex); ++ return ret; + } + + static const struct file_operations uacce_fops = { +@@ -431,7 +455,7 @@ struct uacce_device *uacce_alloc(struct device *parent, + goto err_with_uacce; + + INIT_LIST_HEAD(&uacce->queues); +- mutex_init(&uacce->queues_lock); ++ mutex_init(&uacce->mutex); + device_initialize(&uacce->dev); + uacce->dev.devt = MKDEV(MAJOR(uacce_devt), uacce->dev_id); + uacce->dev.class = uacce_class; +@@ -489,13 +513,23 @@ void uacce_remove(struct uacce_device *uacce) + if (uacce->inode) + unmap_mapping_range(uacce->inode->i_mapping, 0, 0, 1); + ++ /* ++ * uacce_fops_open() may be running concurrently, even after we remove ++ * the cdev. Holding uacce->mutex ensures that open() does not obtain a ++ * removed uacce device. ++ */ ++ mutex_lock(&uacce->mutex); + /* ensure no open queue remains */ +- mutex_lock(&uacce->queues_lock); + list_for_each_entry_safe(q, next_q, &uacce->queues, list) { ++ /* ++ * Taking q->mutex ensures that fops do not use the defunct ++ * uacce->ops after the queue is disabled. ++ */ ++ mutex_lock(&q->mutex); + uacce_put_queue(q); ++ mutex_unlock(&q->mutex); + uacce_unbind_queue(q); + } +- mutex_unlock(&uacce->queues_lock); + + /* disable sva now since no opened queues */ + if (uacce->flags & UACCE_DEV_SVA) +@@ -504,6 +538,13 @@ void uacce_remove(struct uacce_device *uacce) + if (uacce->cdev) + cdev_device_del(uacce->cdev, &uacce->dev); + xa_erase(&uacce_xa, uacce->dev_id); ++ /* ++ * uacce exists as long as there are open fds, but ops will be freed ++ * now. Ensure that bugs cause NULL deref rather than use-after-free. ++ */ ++ uacce->ops = NULL; ++ uacce->parent = NULL; ++ mutex_unlock(&uacce->mutex); + put_device(&uacce->dev); + } + EXPORT_SYMBOL_GPL(uacce_remove); +diff --git a/drivers/mmc/host/meson-gx-mmc.c b/drivers/mmc/host/meson-gx-mmc.c +index 091e0e051d109..bccc85b3fc50a 100644 +--- a/drivers/mmc/host/meson-gx-mmc.c ++++ b/drivers/mmc/host/meson-gx-mmc.c +@@ -1161,8 +1161,10 @@ static int meson_mmc_probe(struct platform_device *pdev) + } + + ret = device_reset_optional(&pdev->dev); +- if (ret) +- return dev_err_probe(&pdev->dev, ret, "device reset failed\n"); ++ if (ret) { ++ dev_err_probe(&pdev->dev, ret, "device reset failed\n"); ++ goto free_host; ++ } + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + host->regs = devm_ioremap_resource(&pdev->dev, res); +diff --git a/drivers/mmc/host/pxamci.c b/drivers/mmc/host/pxamci.c +index 316393c694d7a..55868b6b86583 100644 +--- a/drivers/mmc/host/pxamci.c ++++ b/drivers/mmc/host/pxamci.c +@@ -648,7 +648,7 @@ static int pxamci_probe(struct platform_device *pdev) + + ret = pxamci_of_init(pdev, mmc); + if (ret) +- return ret; ++ goto out; + + host = mmc_priv(mmc); + host->mmc = mmc; +@@ -672,7 +672,7 @@ static int pxamci_probe(struct platform_device *pdev) + + ret = pxamci_init_ocr(host); + if (ret < 0) +- return ret; ++ goto out; + + mmc->caps = 0; + host->cmdat = 0; +diff --git a/drivers/net/can/spi/mcp251x.c b/drivers/net/can/spi/mcp251x.c +index 89897a2d41fa6..5dde3c42d241b 100644 +--- a/drivers/net/can/spi/mcp251x.c ++++ b/drivers/net/can/spi/mcp251x.c +@@ -1074,9 +1074,6 @@ static irqreturn_t mcp251x_can_ist(int irq, void *dev_id) + + mcp251x_read_2regs(spi, CANINTF, &intf, &eflag); + +- /* mask out flags we don't care about */ +- intf &= CANINTF_RX | CANINTF_TX | CANINTF_ERR; +- + /* receive buffer 0 */ + if (intf & CANINTF_RX0IF) { + mcp251x_hw_rx(spi, 0); +@@ -1086,6 +1083,18 @@ static irqreturn_t mcp251x_can_ist(int irq, void *dev_id) + if (mcp251x_is_2510(spi)) + mcp251x_write_bits(spi, CANINTF, + CANINTF_RX0IF, 0x00); ++ ++ /* check if buffer 1 is already known to be full, no need to re-read */ ++ if (!(intf & CANINTF_RX1IF)) { ++ u8 intf1, eflag1; ++ ++ /* intf needs to be read again to avoid a race condition */ ++ mcp251x_read_2regs(spi, CANINTF, &intf1, &eflag1); ++ ++ /* combine flags from both operations for error handling */ ++ intf |= intf1; ++ eflag |= eflag1; ++ } + } + + /* receive buffer 1 */ +@@ -1096,6 +1105,9 @@ static irqreturn_t mcp251x_can_ist(int irq, void *dev_id) + clear_intf |= CANINTF_RX1IF; + } + ++ /* mask out flags we don't care about */ ++ intf &= CANINTF_RX | CANINTF_TX | CANINTF_ERR; ++ + /* any error or tx interrupt we need to clear? */ + if (intf & (CANINTF_ERR | CANINTF_TX)) + clear_intf |= intf & (CANINTF_ERR | CANINTF_TX); +diff --git a/drivers/net/can/usb/ems_usb.c b/drivers/net/can/usb/ems_usb.c +index 6458da9c13b95..ff05b5230f0b8 100644 +--- a/drivers/net/can/usb/ems_usb.c ++++ b/drivers/net/can/usb/ems_usb.c +@@ -194,7 +194,7 @@ struct __packed ems_cpc_msg { + __le32 ts_sec; /* timestamp in seconds */ + __le32 ts_nsec; /* timestamp in nano seconds */ + +- union { ++ union __packed { + u8 generic[64]; + struct cpc_can_msg can_msg; + struct cpc_can_params can_params; +diff --git a/drivers/net/dsa/microchip/ksz9477.c b/drivers/net/dsa/microchip/ksz9477.c +index b3aa99eb6c2c5..ece4c0512ee2d 100644 +--- a/drivers/net/dsa/microchip/ksz9477.c ++++ b/drivers/net/dsa/microchip/ksz9477.c +@@ -762,6 +762,9 @@ static int ksz9477_port_fdb_dump(struct dsa_switch *ds, int port, + goto exit; + } + ++ if (!(ksz_data & ALU_VALID)) ++ continue; ++ + /* read ALU table */ + ksz9477_read_table(dev, alu_table); + +diff --git a/drivers/net/dsa/mv88e6060.c b/drivers/net/dsa/mv88e6060.c +index 24b8219fd6077..dafddf8000d04 100644 +--- a/drivers/net/dsa/mv88e6060.c ++++ b/drivers/net/dsa/mv88e6060.c +@@ -118,6 +118,9 @@ static int mv88e6060_setup_port(struct mv88e6060_priv *priv, int p) + int addr = REG_PORT(p); + int ret; + ++ if (dsa_is_unused_port(priv->ds, p)) ++ return 0; ++ + /* Do not force flow control, disable Ingress and Egress + * Header tagging, disable VLAN tunneling, and set the port + * state to Forwarding. Additionally, if this is the CPU +diff --git a/drivers/net/dsa/ocelot/felix_vsc9959.c b/drivers/net/dsa/ocelot/felix_vsc9959.c +index c96dfc11aa6fc..161a5eac60d62 100644 +--- a/drivers/net/dsa/ocelot/felix_vsc9959.c ++++ b/drivers/net/dsa/ocelot/felix_vsc9959.c +@@ -578,7 +578,8 @@ static const struct ocelot_stat_layout vsc9959_stats_layout[] = { + { .offset = 0x87, .name = "tx_frames_below_65_octets", }, + { .offset = 0x88, .name = "tx_frames_65_to_127_octets", }, + { .offset = 0x89, .name = "tx_frames_128_255_octets", }, +- { .offset = 0x8B, .name = "tx_frames_256_511_octets", }, ++ { .offset = 0x8A, .name = "tx_frames_256_511_octets", }, ++ { .offset = 0x8B, .name = "tx_frames_512_1023_octets", }, + { .offset = 0x8C, .name = "tx_frames_1024_1526_octets", }, + { .offset = 0x8D, .name = "tx_frames_over_1526_octets", }, + { .offset = 0x8E, .name = "tx_yellow_prio_0", }, +diff --git a/drivers/net/dsa/sja1105/sja1105_devlink.c b/drivers/net/dsa/sja1105/sja1105_devlink.c +index 4a2ec395bcb00..ec2ac91abcfa4 100644 +--- a/drivers/net/dsa/sja1105/sja1105_devlink.c ++++ b/drivers/net/dsa/sja1105/sja1105_devlink.c +@@ -93,7 +93,7 @@ static int sja1105_setup_devlink_regions(struct dsa_switch *ds) + + region = dsa_devlink_region_create(ds, ops, 1, size); + if (IS_ERR(region)) { +- while (i-- >= 0) ++ while (--i >= 0) + dsa_devlink_region_destroy(priv->regions[i]); + return PTR_ERR(region); + } +diff --git a/drivers/net/ethernet/aquantia/atlantic/aq_nic.c b/drivers/net/ethernet/aquantia/atlantic/aq_nic.c +index 2fb4126ae8d8a..2d491efa11bdf 100644 +--- a/drivers/net/ethernet/aquantia/atlantic/aq_nic.c ++++ b/drivers/net/ethernet/aquantia/atlantic/aq_nic.c +@@ -265,12 +265,10 @@ static void aq_nic_service_timer_cb(struct timer_list *t) + static void aq_nic_polling_timer_cb(struct timer_list *t) + { + struct aq_nic_s *self = from_timer(self, t, polling_timer); +- struct aq_vec_s *aq_vec = NULL; + unsigned int i = 0U; + +- for (i = 0U, aq_vec = self->aq_vec[0]; +- self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) +- aq_vec_isr(i, (void *)aq_vec); ++ for (i = 0U; self->aq_vecs > i; ++i) ++ aq_vec_isr(i, (void *)self->aq_vec[i]); + + mod_timer(&self->polling_timer, jiffies + + AQ_CFG_POLLING_TIMER_INTERVAL); +@@ -872,7 +870,6 @@ int aq_nic_get_regs_count(struct aq_nic_s *self) + + u64 *aq_nic_get_stats(struct aq_nic_s *self, u64 *data) + { +- struct aq_vec_s *aq_vec = NULL; + struct aq_stats_s *stats; + unsigned int count = 0U; + unsigned int i = 0U; +@@ -922,11 +919,11 @@ u64 *aq_nic_get_stats(struct aq_nic_s *self, u64 *data) + data += i; + + for (tc = 0U; tc < self->aq_nic_cfg.tcs; tc++) { +- for (i = 0U, aq_vec = self->aq_vec[0]; +- aq_vec && self->aq_vecs > i; +- ++i, aq_vec = self->aq_vec[i]) { ++ for (i = 0U; self->aq_vecs > i; ++i) { ++ if (!self->aq_vec[i]) ++ break; + data += count; +- count = aq_vec_get_sw_stats(aq_vec, tc, data); ++ count = aq_vec_get_sw_stats(self->aq_vec[i], tc, data); + } + } + +@@ -1240,7 +1237,6 @@ int aq_nic_set_loopback(struct aq_nic_s *self) + + int aq_nic_stop(struct aq_nic_s *self) + { +- struct aq_vec_s *aq_vec = NULL; + unsigned int i = 0U; + + netif_tx_disable(self->ndev); +@@ -1258,9 +1254,8 @@ int aq_nic_stop(struct aq_nic_s *self) + + aq_ptp_irq_free(self); + +- for (i = 0U, aq_vec = self->aq_vec[0]; +- self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) +- aq_vec_stop(aq_vec); ++ for (i = 0U; self->aq_vecs > i; ++i) ++ aq_vec_stop(self->aq_vec[i]); + + aq_ptp_ring_stop(self); + +diff --git a/drivers/net/ethernet/broadcom/bgmac.c b/drivers/net/ethernet/broadcom/bgmac.c +index 98ec1b8a7d8e5..6290d8bedc92e 100644 +--- a/drivers/net/ethernet/broadcom/bgmac.c ++++ b/drivers/net/ethernet/broadcom/bgmac.c +@@ -189,8 +189,8 @@ static netdev_tx_t bgmac_dma_tx_add(struct bgmac *bgmac, + } + + slot->skb = skb; +- ring->end += nr_frags + 1; + netdev_sent_queue(net_dev, skb->len); ++ ring->end += nr_frags + 1; + + wmb(); + +diff --git a/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c b/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c +index d89ddc165ec24..35401202523ef 100644 +--- a/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c ++++ b/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c +@@ -1349,8 +1349,8 @@ static int dpaa2_eth_add_bufs(struct dpaa2_eth_priv *priv, + buf_array[i] = addr; + + /* tracing point */ +- trace_dpaa2_eth_buf_seed(priv->net_dev, +- page, DPAA2_ETH_RX_BUF_RAW_SIZE, ++ trace_dpaa2_eth_buf_seed(priv->net_dev, page_address(page), ++ DPAA2_ETH_RX_BUF_RAW_SIZE, + addr, priv->rx_buf_size, + bpid); + } +diff --git a/drivers/net/ethernet/freescale/fec_ptp.c b/drivers/net/ethernet/freescale/fec_ptp.c +index d71eac7e19249..c5ae673005908 100644 +--- a/drivers/net/ethernet/freescale/fec_ptp.c ++++ b/drivers/net/ethernet/freescale/fec_ptp.c +@@ -136,11 +136,7 @@ static int fec_ptp_enable_pps(struct fec_enet_private *fep, uint enable) + * NSEC_PER_SEC - ts.tv_nsec. Add the remaining nanoseconds + * to current timer would be next second. + */ +- tempval = readl(fep->hwp + FEC_ATIME_CTRL); +- tempval |= FEC_T_CTRL_CAPTURE; +- writel(tempval, fep->hwp + FEC_ATIME_CTRL); +- +- tempval = readl(fep->hwp + FEC_ATIME); ++ tempval = fep->cc.read(&fep->cc); + /* Convert the ptp local counter to 1588 timestamp */ + ns = timecounter_cyc2time(&fep->tc, tempval); + ts = ns_to_timespec64(ns); +diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c +index 1dad62ecb8a3a..97009cbea7793 100644 +--- a/drivers/net/ethernet/intel/i40e/i40e_main.c ++++ b/drivers/net/ethernet/intel/i40e/i40e_main.c +@@ -382,7 +382,9 @@ static void i40e_tx_timeout(struct net_device *netdev, unsigned int txqueue) + set_bit(__I40E_GLOBAL_RESET_REQUESTED, pf->state); + break; + default: +- netdev_err(netdev, "tx_timeout recovery unsuccessful\n"); ++ netdev_err(netdev, "tx_timeout recovery unsuccessful, device is in non-recoverable state.\n"); ++ set_bit(__I40E_DOWN_REQUESTED, pf->state); ++ set_bit(__I40E_VSI_DOWN_REQUESTED, vsi->state); + break; + } + +diff --git a/drivers/net/ethernet/intel/iavf/iavf_adminq.c b/drivers/net/ethernet/intel/iavf/iavf_adminq.c +index 9fa3fa99b4c20..897b349cdaf1c 100644 +--- a/drivers/net/ethernet/intel/iavf/iavf_adminq.c ++++ b/drivers/net/ethernet/intel/iavf/iavf_adminq.c +@@ -324,6 +324,7 @@ static enum iavf_status iavf_config_arq_regs(struct iavf_hw *hw) + static enum iavf_status iavf_init_asq(struct iavf_hw *hw) + { + enum iavf_status ret_code = 0; ++ int i; + + if (hw->aq.asq.count > 0) { + /* queue already initialized */ +@@ -354,12 +355,17 @@ static enum iavf_status iavf_init_asq(struct iavf_hw *hw) + /* initialize base registers */ + ret_code = iavf_config_asq_regs(hw); + if (ret_code) +- goto init_adminq_free_rings; ++ goto init_free_asq_bufs; + + /* success! */ + hw->aq.asq.count = hw->aq.num_asq_entries; + goto init_adminq_exit; + ++init_free_asq_bufs: ++ for (i = 0; i < hw->aq.num_asq_entries; i++) ++ iavf_free_dma_mem(hw, &hw->aq.asq.r.asq_bi[i]); ++ iavf_free_virt_mem(hw, &hw->aq.asq.dma_head); ++ + init_adminq_free_rings: + iavf_free_adminq_asq(hw); + +@@ -383,6 +389,7 @@ init_adminq_exit: + static enum iavf_status iavf_init_arq(struct iavf_hw *hw) + { + enum iavf_status ret_code = 0; ++ int i; + + if (hw->aq.arq.count > 0) { + /* queue already initialized */ +@@ -413,12 +420,16 @@ static enum iavf_status iavf_init_arq(struct iavf_hw *hw) + /* initialize base registers */ + ret_code = iavf_config_arq_regs(hw); + if (ret_code) +- goto init_adminq_free_rings; ++ goto init_free_arq_bufs; + + /* success! */ + hw->aq.arq.count = hw->aq.num_arq_entries; + goto init_adminq_exit; + ++init_free_arq_bufs: ++ for (i = 0; i < hw->aq.num_arq_entries; i++) ++ iavf_free_dma_mem(hw, &hw->aq.arq.r.arq_bi[i]); ++ iavf_free_virt_mem(hw, &hw->aq.arq.dma_head); + init_adminq_free_rings: + iavf_free_adminq_arq(hw); + +diff --git a/drivers/net/ethernet/intel/ice/ice_switch.c b/drivers/net/ethernet/intel/ice/ice_switch.c +index 5ce8590cdb374..0155c45d9d7f0 100644 +--- a/drivers/net/ethernet/intel/ice/ice_switch.c ++++ b/drivers/net/ethernet/intel/ice/ice_switch.c +@@ -2590,7 +2590,7 @@ ice_set_vlan_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 promisc_mask, + else + status = ice_set_vsi_promisc(hw, vsi_handle, + promisc_mask, vlan_id); +- if (status) ++ if (status && status != -EEXIST) + break; + } + +diff --git a/drivers/net/ethernet/intel/igb/igb.h b/drivers/net/ethernet/intel/igb/igb.h +index 7bda8c5edea5d..e6d2800a8abc5 100644 +--- a/drivers/net/ethernet/intel/igb/igb.h ++++ b/drivers/net/ethernet/intel/igb/igb.h +@@ -664,6 +664,8 @@ struct igb_adapter { + struct igb_mac_addr *mac_table; + struct vf_mac_filter vf_macs; + struct vf_mac_filter *vf_mac_list; ++ /* lock for VF resources */ ++ spinlock_t vfs_lock; + }; + + /* flags controlling PTP/1588 function */ +diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c +index 4e51f4bb58ffc..327196d15a6ae 100644 +--- a/drivers/net/ethernet/intel/igb/igb_main.c ++++ b/drivers/net/ethernet/intel/igb/igb_main.c +@@ -3638,6 +3638,7 @@ static int igb_disable_sriov(struct pci_dev *pdev) + struct net_device *netdev = pci_get_drvdata(pdev); + struct igb_adapter *adapter = netdev_priv(netdev); + struct e1000_hw *hw = &adapter->hw; ++ unsigned long flags; + + /* reclaim resources allocated to VFs */ + if (adapter->vf_data) { +@@ -3650,12 +3651,13 @@ static int igb_disable_sriov(struct pci_dev *pdev) + pci_disable_sriov(pdev); + msleep(500); + } +- ++ spin_lock_irqsave(&adapter->vfs_lock, flags); + kfree(adapter->vf_mac_list); + adapter->vf_mac_list = NULL; + kfree(adapter->vf_data); + adapter->vf_data = NULL; + adapter->vfs_allocated_count = 0; ++ spin_unlock_irqrestore(&adapter->vfs_lock, flags); + wr32(E1000_IOVCTL, E1000_IOVCTL_REUSE_VFQ); + wrfl(); + msleep(100); +@@ -3815,7 +3817,9 @@ static void igb_remove(struct pci_dev *pdev) + igb_release_hw_control(adapter); + + #ifdef CONFIG_PCI_IOV ++ rtnl_lock(); + igb_disable_sriov(pdev); ++ rtnl_unlock(); + #endif + + unregister_netdev(netdev); +@@ -3975,6 +3979,9 @@ static int igb_sw_init(struct igb_adapter *adapter) + + spin_lock_init(&adapter->nfc_lock); + spin_lock_init(&adapter->stats64_lock); ++ ++ /* init spinlock to avoid concurrency of VF resources */ ++ spin_lock_init(&adapter->vfs_lock); + #ifdef CONFIG_PCI_IOV + switch (hw->mac.type) { + case e1000_82576: +@@ -7852,8 +7859,10 @@ unlock: + static void igb_msg_task(struct igb_adapter *adapter) + { + struct e1000_hw *hw = &adapter->hw; ++ unsigned long flags; + u32 vf; + ++ spin_lock_irqsave(&adapter->vfs_lock, flags); + for (vf = 0; vf < adapter->vfs_allocated_count; vf++) { + /* process any reset requests */ + if (!igb_check_for_rst(hw, vf)) +@@ -7867,6 +7876,7 @@ static void igb_msg_task(struct igb_adapter *adapter) + if (!igb_check_for_ack(hw, vf)) + igb_rcv_ack_from_vf(adapter, vf); + } ++ spin_unlock_irqrestore(&adapter->vfs_lock, flags); + } + + /** +diff --git a/drivers/net/ethernet/moxa/moxart_ether.c b/drivers/net/ethernet/moxa/moxart_ether.c +index a0e1ccca505b7..6137000b11c5c 100644 +--- a/drivers/net/ethernet/moxa/moxart_ether.c ++++ b/drivers/net/ethernet/moxa/moxart_ether.c +@@ -77,7 +77,7 @@ static void moxart_mac_free_memory(struct net_device *ndev) + int i; + + for (i = 0; i < RX_DESC_NUM; i++) +- dma_unmap_single(&ndev->dev, priv->rx_mapping[i], ++ dma_unmap_single(&priv->pdev->dev, priv->rx_mapping[i], + priv->rx_buf_size, DMA_FROM_DEVICE); + + if (priv->tx_desc_base) +@@ -147,11 +147,11 @@ static void moxart_mac_setup_desc_ring(struct net_device *ndev) + desc + RX_REG_OFFSET_DESC1); + + priv->rx_buf[i] = priv->rx_buf_base + priv->rx_buf_size * i; +- priv->rx_mapping[i] = dma_map_single(&ndev->dev, ++ priv->rx_mapping[i] = dma_map_single(&priv->pdev->dev, + priv->rx_buf[i], + priv->rx_buf_size, + DMA_FROM_DEVICE); +- if (dma_mapping_error(&ndev->dev, priv->rx_mapping[i])) ++ if (dma_mapping_error(&priv->pdev->dev, priv->rx_mapping[i])) + netdev_err(ndev, "DMA mapping error\n"); + + moxart_desc_write(priv->rx_mapping[i], +@@ -240,7 +240,7 @@ static int moxart_rx_poll(struct napi_struct *napi, int budget) + if (len > RX_BUF_SIZE) + len = RX_BUF_SIZE; + +- dma_sync_single_for_cpu(&ndev->dev, ++ dma_sync_single_for_cpu(&priv->pdev->dev, + priv->rx_mapping[rx_head], + priv->rx_buf_size, DMA_FROM_DEVICE); + skb = netdev_alloc_skb_ip_align(ndev, len); +@@ -294,7 +294,7 @@ static void moxart_tx_finished(struct net_device *ndev) + unsigned int tx_tail = priv->tx_tail; + + while (tx_tail != tx_head) { +- dma_unmap_single(&ndev->dev, priv->tx_mapping[tx_tail], ++ dma_unmap_single(&priv->pdev->dev, priv->tx_mapping[tx_tail], + priv->tx_len[tx_tail], DMA_TO_DEVICE); + + ndev->stats.tx_packets++; +@@ -358,9 +358,9 @@ static netdev_tx_t moxart_mac_start_xmit(struct sk_buff *skb, + + len = skb->len > TX_BUF_SIZE ? TX_BUF_SIZE : skb->len; + +- priv->tx_mapping[tx_head] = dma_map_single(&ndev->dev, skb->data, ++ priv->tx_mapping[tx_head] = dma_map_single(&priv->pdev->dev, skb->data, + len, DMA_TO_DEVICE); +- if (dma_mapping_error(&ndev->dev, priv->tx_mapping[tx_head])) { ++ if (dma_mapping_error(&priv->pdev->dev, priv->tx_mapping[tx_head])) { + netdev_err(ndev, "DMA mapping error\n"); + goto out_unlock; + } +@@ -379,7 +379,7 @@ static netdev_tx_t moxart_mac_start_xmit(struct sk_buff *skb, + len = ETH_ZLEN; + } + +- dma_sync_single_for_device(&ndev->dev, priv->tx_mapping[tx_head], ++ dma_sync_single_for_device(&priv->pdev->dev, priv->tx_mapping[tx_head], + priv->tx_buf_size, DMA_TO_DEVICE); + + txdes1 = TX_DESC1_LTS | TX_DESC1_FTS | (len & TX_DESC1_BUF_SIZE_MASK); +@@ -494,7 +494,7 @@ static int moxart_mac_probe(struct platform_device *pdev) + priv->tx_buf_size = TX_BUF_SIZE; + priv->rx_buf_size = RX_BUF_SIZE; + +- priv->tx_desc_base = dma_alloc_coherent(&pdev->dev, TX_REG_DESC_SIZE * ++ priv->tx_desc_base = dma_alloc_coherent(p_dev, TX_REG_DESC_SIZE * + TX_DESC_NUM, &priv->tx_base, + GFP_DMA | GFP_KERNEL); + if (!priv->tx_desc_base) { +@@ -502,7 +502,7 @@ static int moxart_mac_probe(struct platform_device *pdev) + goto init_fail; + } + +- priv->rx_desc_base = dma_alloc_coherent(&pdev->dev, RX_REG_DESC_SIZE * ++ priv->rx_desc_base = dma_alloc_coherent(p_dev, RX_REG_DESC_SIZE * + RX_DESC_NUM, &priv->rx_base, + GFP_DMA | GFP_KERNEL); + if (!priv->rx_desc_base) { +diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net_ethtool.c b/drivers/net/ethernet/netronome/nfp/nfp_net_ethtool.c +index e0b801d107396..bf8590ef0964b 100644 +--- a/drivers/net/ethernet/netronome/nfp/nfp_net_ethtool.c ++++ b/drivers/net/ethernet/netronome/nfp/nfp_net_ethtool.c +@@ -1225,6 +1225,8 @@ nfp_port_get_module_info(struct net_device *netdev, + u8 data; + + port = nfp_port_from_netdev(netdev); ++ /* update port state to get latest interface */ ++ set_bit(NFP_PORT_CHANGED, &port->flags); + eth_port = nfp_port_get_eth_port(port); + if (!eth_port) + return -EOPNOTSUPP; +diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-intel.c b/drivers/net/ethernet/stmicro/stmmac/dwmac-intel.c +index fb065b074553e..5406f5a9bbe59 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/dwmac-intel.c ++++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-intel.c +@@ -669,6 +669,7 @@ static void intel_eth_pci_remove(struct pci_dev *pdev) + + pci_free_irq_vectors(pdev); + ++ clk_disable_unprepare(priv->plat->stmmac_clk); + clk_unregister_fixed_rate(priv->plat->stmmac_clk); + + pcim_iounmap_regions(pdev, BIT(0)); +diff --git a/drivers/net/geneve.c b/drivers/net/geneve.c +index 5ddb2dbb8572b..081939cb420b0 100644 +--- a/drivers/net/geneve.c ++++ b/drivers/net/geneve.c +@@ -772,7 +772,8 @@ static struct rtable *geneve_get_v4_rt(struct sk_buff *skb, + struct geneve_sock *gs4, + struct flowi4 *fl4, + const struct ip_tunnel_info *info, +- __be16 dport, __be16 sport) ++ __be16 dport, __be16 sport, ++ __u8 *full_tos) + { + bool use_cache = ip_tunnel_dst_cache_usable(skb, info); + struct geneve_dev *geneve = netdev_priv(dev); +@@ -797,6 +798,8 @@ static struct rtable *geneve_get_v4_rt(struct sk_buff *skb, + use_cache = false; + } + fl4->flowi4_tos = RT_TOS(tos); ++ if (full_tos) ++ *full_tos = tos; + + dst_cache = (struct dst_cache *)&info->dst_cache; + if (use_cache) { +@@ -850,8 +853,7 @@ static struct dst_entry *geneve_get_v6_dst(struct sk_buff *skb, + use_cache = false; + } + +- fl6->flowlabel = ip6_make_flowinfo(RT_TOS(prio), +- info->key.label); ++ fl6->flowlabel = ip6_make_flowinfo(prio, info->key.label); + dst_cache = (struct dst_cache *)&info->dst_cache; + if (use_cache) { + dst = dst_cache_get_ip6(dst_cache, &fl6->saddr); +@@ -885,6 +887,7 @@ static int geneve_xmit_skb(struct sk_buff *skb, struct net_device *dev, + const struct ip_tunnel_key *key = &info->key; + struct rtable *rt; + struct flowi4 fl4; ++ __u8 full_tos; + __u8 tos, ttl; + __be16 df = 0; + __be16 sport; +@@ -895,7 +898,7 @@ static int geneve_xmit_skb(struct sk_buff *skb, struct net_device *dev, + + sport = udp_flow_src_port(geneve->net, skb, 1, USHRT_MAX, true); + rt = geneve_get_v4_rt(skb, dev, gs4, &fl4, info, +- geneve->cfg.info.key.tp_dst, sport); ++ geneve->cfg.info.key.tp_dst, sport, &full_tos); + if (IS_ERR(rt)) + return PTR_ERR(rt); + +@@ -939,7 +942,7 @@ static int geneve_xmit_skb(struct sk_buff *skb, struct net_device *dev, + + df = key->tun_flags & TUNNEL_DONT_FRAGMENT ? htons(IP_DF) : 0; + } else { +- tos = ip_tunnel_ecn_encap(fl4.flowi4_tos, ip_hdr(skb), skb); ++ tos = ip_tunnel_ecn_encap(full_tos, ip_hdr(skb), skb); + if (geneve->cfg.ttl_inherit) + ttl = ip_tunnel_get_ttl(ip_hdr(skb), skb); + else +@@ -1121,7 +1124,7 @@ static int geneve_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb) + 1, USHRT_MAX, true); + + rt = geneve_get_v4_rt(skb, dev, gs4, &fl4, info, +- geneve->cfg.info.key.tp_dst, sport); ++ geneve->cfg.info.key.tp_dst, sport, NULL); + if (IS_ERR(rt)) + return PTR_ERR(rt); + +diff --git a/drivers/net/plip/plip.c b/drivers/net/plip/plip.c +index 4406b353123ed..5a0e5a8a8917b 100644 +--- a/drivers/net/plip/plip.c ++++ b/drivers/net/plip/plip.c +@@ -1103,7 +1103,7 @@ plip_open(struct net_device *dev) + /* Any address will do - we take the first. We already + have the first two bytes filled with 0xfc, from + plip_init_dev(). */ +- const struct in_ifaddr *ifa = rcu_dereference(in_dev->ifa_list); ++ const struct in_ifaddr *ifa = rtnl_dereference(in_dev->ifa_list); + if (ifa != NULL) { + memcpy(dev->dev_addr+2, &ifa->ifa_local, 4); + } +diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c +index 0a07c05a610d1..c942cd6a2c65e 100644 +--- a/drivers/net/virtio_net.c ++++ b/drivers/net/virtio_net.c +@@ -968,8 +968,11 @@ static struct sk_buff *receive_mergeable(struct net_device *dev, + case XDP_TX: + stats->xdp_tx++; + xdpf = xdp_convert_buff_to_frame(&xdp); +- if (unlikely(!xdpf)) ++ if (unlikely(!xdpf)) { ++ if (unlikely(xdp_page != page)) ++ put_page(xdp_page); + goto err_xdp; ++ } + err = virtnet_xdp_xmit(dev, 1, &xdpf, 0); + if (unlikely(err < 0)) { + trace_xdp_exception(vi->dev, xdp_prog, act); +diff --git a/drivers/ntb/test/ntb_tool.c b/drivers/ntb/test/ntb_tool.c +index b7bf3f863d79b..5ee0afa621a95 100644 +--- a/drivers/ntb/test/ntb_tool.c ++++ b/drivers/ntb/test/ntb_tool.c +@@ -367,14 +367,16 @@ static ssize_t tool_fn_write(struct tool_ctx *tc, + u64 bits; + int n; + ++ if (*offp) ++ return 0; ++ + buf = kmalloc(size + 1, GFP_KERNEL); + if (!buf) + return -ENOMEM; + +- ret = simple_write_to_buffer(buf, size, offp, ubuf, size); +- if (ret < 0) { ++ if (copy_from_user(buf, ubuf, size)) { + kfree(buf); +- return ret; ++ return -EFAULT; + } + + buf[size] = 0; +diff --git a/drivers/nvme/target/tcp.c b/drivers/nvme/target/tcp.c +index 96b67a70cbbbd..d030d5e69dc50 100644 +--- a/drivers/nvme/target/tcp.c ++++ b/drivers/nvme/target/tcp.c +@@ -1802,7 +1802,8 @@ static int __init nvmet_tcp_init(void) + { + int ret; + +- nvmet_tcp_wq = alloc_workqueue("nvmet_tcp_wq", WQ_HIGHPRI, 0); ++ nvmet_tcp_wq = alloc_workqueue("nvmet_tcp_wq", ++ WQ_MEM_RECLAIM | WQ_HIGHPRI, 0); + if (!nvmet_tcp_wq) + return -ENOMEM; + +diff --git a/drivers/pci/pcie/err.c b/drivers/pci/pcie/err.c +index d89d7ed70768c..984aa023c753f 100644 +--- a/drivers/pci/pcie/err.c ++++ b/drivers/pci/pcie/err.c +@@ -196,8 +196,7 @@ pci_ers_result_t pcie_do_recovery(struct pci_dev *dev, + pci_dbg(bridge, "broadcast error_detected message\n"); + if (state == pci_channel_io_frozen) { + pci_walk_bridge(bridge, report_frozen_detected, &status); +- status = reset_subordinates(bridge); +- if (status != PCI_ERS_RESULT_RECOVERED) { ++ if (reset_subordinates(bridge) != PCI_ERS_RESULT_RECOVERED) { + pci_warn(bridge, "subordinate device reset failed\n"); + goto failed; + } +diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c +index 1be2894ada70c..fb2e52fd01b39 100644 +--- a/drivers/pci/quirks.c ++++ b/drivers/pci/quirks.c +@@ -4897,6 +4897,9 @@ static const struct pci_dev_acs_enabled { + { PCI_VENDOR_ID_AMPERE, 0xE00C, pci_quirk_xgene_acs }, + /* Broadcom multi-function device */ + { PCI_VENDOR_ID_BROADCOM, 0x16D7, pci_quirk_mf_endpoint_acs }, ++ { PCI_VENDOR_ID_BROADCOM, 0x1750, pci_quirk_mf_endpoint_acs }, ++ { PCI_VENDOR_ID_BROADCOM, 0x1751, pci_quirk_mf_endpoint_acs }, ++ { PCI_VENDOR_ID_BROADCOM, 0x1752, pci_quirk_mf_endpoint_acs }, + { PCI_VENDOR_ID_BROADCOM, 0xD714, pci_quirk_brcm_acs }, + /* Amazon Annapurna Labs */ + { PCI_VENDOR_ID_AMAZON_ANNAPURNA_LABS, 0x0031, pci_quirk_al_acs }, +diff --git a/drivers/pinctrl/intel/pinctrl-intel.c b/drivers/pinctrl/intel/pinctrl-intel.c +index 348c670a7b07d..4de832ac47d38 100644 +--- a/drivers/pinctrl/intel/pinctrl-intel.c ++++ b/drivers/pinctrl/intel/pinctrl-intel.c +@@ -1571,16 +1571,14 @@ EXPORT_SYMBOL_GPL(intel_pinctrl_probe_by_uid); + + const struct intel_pinctrl_soc_data *intel_pinctrl_get_soc_data(struct platform_device *pdev) + { ++ const struct intel_pinctrl_soc_data * const *table; + const struct intel_pinctrl_soc_data *data = NULL; +- const struct intel_pinctrl_soc_data **table; +- struct acpi_device *adev; +- unsigned int i; + +- adev = ACPI_COMPANION(&pdev->dev); +- if (adev) { +- const void *match = device_get_match_data(&pdev->dev); ++ table = device_get_match_data(&pdev->dev); ++ if (table) { ++ struct acpi_device *adev = ACPI_COMPANION(&pdev->dev); ++ unsigned int i; + +- table = (const struct intel_pinctrl_soc_data **)match; + for (i = 0; table[i]; i++) { + if (!strcmp(adev->pnp.unique_id, table[i]->uid)) { + data = table[i]; +@@ -1594,7 +1592,7 @@ const struct intel_pinctrl_soc_data *intel_pinctrl_get_soc_data(struct platform_ + if (!id) + return ERR_PTR(-ENODEV); + +- table = (const struct intel_pinctrl_soc_data **)id->driver_data; ++ table = (const struct intel_pinctrl_soc_data * const *)id->driver_data; + data = table[pdev->id]; + } + +diff --git a/drivers/pinctrl/nomadik/pinctrl-nomadik.c b/drivers/pinctrl/nomadik/pinctrl-nomadik.c +index 6d77feda9090a..d80ec0d8eaada 100644 +--- a/drivers/pinctrl/nomadik/pinctrl-nomadik.c ++++ b/drivers/pinctrl/nomadik/pinctrl-nomadik.c +@@ -1421,8 +1421,10 @@ static int nmk_pinctrl_dt_subnode_to_map(struct pinctrl_dev *pctldev, + + has_config = nmk_pinctrl_dt_get_config(np, &configs); + np_config = of_parse_phandle(np, "ste,config", 0); +- if (np_config) ++ if (np_config) { + has_config |= nmk_pinctrl_dt_get_config(np_config, &configs); ++ of_node_put(np_config); ++ } + if (has_config) { + const char *gpio_name; + const char *pin; +diff --git a/drivers/pinctrl/qcom/pinctrl-msm8916.c b/drivers/pinctrl/qcom/pinctrl-msm8916.c +index 396db12ae9048..bf68913ba8212 100644 +--- a/drivers/pinctrl/qcom/pinctrl-msm8916.c ++++ b/drivers/pinctrl/qcom/pinctrl-msm8916.c +@@ -844,8 +844,8 @@ static const struct msm_pingroup msm8916_groups[] = { + PINGROUP(28, pwr_modem_enabled_a, NA, NA, NA, NA, NA, qdss_tracedata_b, NA, atest_combodac), + PINGROUP(29, cci_i2c, NA, NA, NA, NA, NA, qdss_tracedata_b, NA, atest_combodac), + PINGROUP(30, cci_i2c, NA, NA, NA, NA, NA, NA, NA, qdss_tracedata_b), +- PINGROUP(31, cci_timer0, NA, NA, NA, NA, NA, NA, NA, NA), +- PINGROUP(32, cci_timer1, NA, NA, NA, NA, NA, NA, NA, NA), ++ PINGROUP(31, cci_timer0, flash_strobe, NA, NA, NA, NA, NA, NA, NA), ++ PINGROUP(32, cci_timer1, flash_strobe, NA, NA, NA, NA, NA, NA, NA), + PINGROUP(33, cci_async, NA, NA, NA, NA, NA, NA, NA, qdss_tracedata_b), + PINGROUP(34, pwr_nav_enabled_a, NA, NA, NA, NA, NA, NA, NA, qdss_tracedata_b), + PINGROUP(35, pwr_crypto_enabled_a, NA, NA, NA, NA, NA, NA, NA, qdss_tracedata_b), +diff --git a/drivers/pinctrl/qcom/pinctrl-sm8250.c b/drivers/pinctrl/qcom/pinctrl-sm8250.c +index af144e724bd9c..3bd7f9fedcc34 100644 +--- a/drivers/pinctrl/qcom/pinctrl-sm8250.c ++++ b/drivers/pinctrl/qcom/pinctrl-sm8250.c +@@ -1316,7 +1316,7 @@ static const struct msm_pingroup sm8250_groups[] = { + static const struct msm_gpio_wakeirq_map sm8250_pdc_map[] = { + { 0, 79 }, { 1, 84 }, { 2, 80 }, { 3, 82 }, { 4, 107 }, { 7, 43 }, + { 11, 42 }, { 14, 44 }, { 15, 52 }, { 19, 67 }, { 23, 68 }, { 24, 105 }, +- { 27, 92 }, { 28, 106 }, { 31, 69 }, { 35, 70 }, { 39, 37 }, ++ { 27, 92 }, { 28, 106 }, { 31, 69 }, { 35, 70 }, { 39, 73 }, + { 40, 108 }, { 43, 71 }, { 45, 72 }, { 47, 83 }, { 51, 74 }, { 55, 77 }, + { 59, 78 }, { 63, 75 }, { 64, 81 }, { 65, 87 }, { 66, 88 }, { 67, 89 }, + { 68, 54 }, { 70, 85 }, { 77, 46 }, { 80, 90 }, { 81, 91 }, { 83, 97 }, +diff --git a/drivers/pinctrl/sunxi/pinctrl-sun50i-h6-r.c b/drivers/pinctrl/sunxi/pinctrl-sun50i-h6-r.c +index 4557e18d59899..12c40f9c1a247 100644 +--- a/drivers/pinctrl/sunxi/pinctrl-sun50i-h6-r.c ++++ b/drivers/pinctrl/sunxi/pinctrl-sun50i-h6-r.c +@@ -105,6 +105,7 @@ static const struct sunxi_pinctrl_desc sun50i_h6_r_pinctrl_data = { + .npins = ARRAY_SIZE(sun50i_h6_r_pins), + .pin_base = PL_BASE, + .irq_banks = 2, ++ .io_bias_cfg_variant = BIAS_VOLTAGE_PIO_POW_MODE_SEL, + }; + + static int sun50i_h6_r_pinctrl_probe(struct platform_device *pdev) +diff --git a/drivers/pinctrl/sunxi/pinctrl-sunxi.c b/drivers/pinctrl/sunxi/pinctrl-sunxi.c +index 24c861434bf13..e4b41cc6c5860 100644 +--- a/drivers/pinctrl/sunxi/pinctrl-sunxi.c ++++ b/drivers/pinctrl/sunxi/pinctrl-sunxi.c +@@ -624,7 +624,7 @@ static int sunxi_pinctrl_set_io_bias_cfg(struct sunxi_pinctrl *pctl, + unsigned pin, + struct regulator *supply) + { +- unsigned short bank = pin / PINS_PER_BANK; ++ unsigned short bank; + unsigned long flags; + u32 val, reg; + int uV; +@@ -640,6 +640,9 @@ static int sunxi_pinctrl_set_io_bias_cfg(struct sunxi_pinctrl *pctl, + if (uV == 0) + return 0; + ++ pin -= pctl->desc->pin_base; ++ bank = pin / PINS_PER_BANK; ++ + switch (pctl->desc->io_bias_cfg_variant) { + case BIAS_VOLTAGE_GRP_CONFIG: + /* +@@ -657,8 +660,6 @@ static int sunxi_pinctrl_set_io_bias_cfg(struct sunxi_pinctrl *pctl, + else + val = 0xD; /* 3.3V */ + +- pin -= pctl->desc->pin_base; +- + reg = readl(pctl->membase + sunxi_grp_config_reg(pin)); + reg &= ~IO_BIAS_MASK; + writel(reg | val, pctl->membase + sunxi_grp_config_reg(pin)); +diff --git a/drivers/platform/chrome/cros_ec_proto.c b/drivers/platform/chrome/cros_ec_proto.c +index e1fadf059e05e..3a2a78ff33304 100644 +--- a/drivers/platform/chrome/cros_ec_proto.c ++++ b/drivers/platform/chrome/cros_ec_proto.c +@@ -507,13 +507,13 @@ int cros_ec_query_all(struct cros_ec_device *ec_dev) + ret = cros_ec_get_host_command_version_mask(ec_dev, + EC_CMD_GET_NEXT_EVENT, + &ver_mask); +- if (ret < 0 || ver_mask == 0) ++ if (ret < 0 || ver_mask == 0) { + ec_dev->mkbp_event_supported = 0; +- else ++ } else { + ec_dev->mkbp_event_supported = fls(ver_mask); + +- dev_dbg(ec_dev->dev, "MKBP support version %u\n", +- ec_dev->mkbp_event_supported - 1); ++ dev_dbg(ec_dev->dev, "MKBP support version %u\n", ec_dev->mkbp_event_supported - 1); ++ } + + /* Probe if host sleep v1 is supported for S0ix failure detection. */ + ret = cros_ec_get_host_command_version_mask(ec_dev, +diff --git a/drivers/scsi/lpfc/lpfc_debugfs.c b/drivers/scsi/lpfc/lpfc_debugfs.c +index beaf3a8d206f8..fbc76d69ea0b4 100644 +--- a/drivers/scsi/lpfc/lpfc_debugfs.c ++++ b/drivers/scsi/lpfc/lpfc_debugfs.c +@@ -2609,8 +2609,8 @@ lpfc_debugfs_multixripools_write(struct file *file, const char __user *buf, + struct lpfc_sli4_hdw_queue *qp; + struct lpfc_multixri_pool *multixri_pool; + +- if (nbytes > 64) +- nbytes = 64; ++ if (nbytes > sizeof(mybuf) - 1) ++ nbytes = sizeof(mybuf) - 1; + + memset(mybuf, 0, sizeof(mybuf)); + +@@ -2690,8 +2690,8 @@ lpfc_debugfs_nvmestat_write(struct file *file, const char __user *buf, + if (!phba->targetport) + return -ENXIO; + +- if (nbytes > 64) +- nbytes = 64; ++ if (nbytes > sizeof(mybuf) - 1) ++ nbytes = sizeof(mybuf) - 1; + + memset(mybuf, 0, sizeof(mybuf)); + +@@ -2828,8 +2828,8 @@ lpfc_debugfs_ioktime_write(struct file *file, const char __user *buf, + char mybuf[64]; + char *pbuf; + +- if (nbytes > 64) +- nbytes = 64; ++ if (nbytes > sizeof(mybuf) - 1) ++ nbytes = sizeof(mybuf) - 1; + + memset(mybuf, 0, sizeof(mybuf)); + +@@ -2956,8 +2956,8 @@ lpfc_debugfs_nvmeio_trc_write(struct file *file, const char __user *buf, + char mybuf[64]; + char *pbuf; + +- if (nbytes > 63) +- nbytes = 63; ++ if (nbytes > sizeof(mybuf) - 1) ++ nbytes = sizeof(mybuf) - 1; + + memset(mybuf, 0, sizeof(mybuf)); + +@@ -3062,8 +3062,8 @@ lpfc_debugfs_hdwqstat_write(struct file *file, const char __user *buf, + char *pbuf; + int i; + +- if (nbytes > 64) +- nbytes = 64; ++ if (nbytes > sizeof(mybuf) - 1) ++ nbytes = sizeof(mybuf) - 1; + + memset(mybuf, 0, sizeof(mybuf)); + +diff --git a/drivers/spi/spi-meson-spicc.c b/drivers/spi/spi-meson-spicc.c +index 0bc7daa7afc83..e4cb52e1fe261 100644 +--- a/drivers/spi/spi-meson-spicc.c ++++ b/drivers/spi/spi-meson-spicc.c +@@ -156,6 +156,7 @@ struct meson_spicc_device { + void __iomem *base; + struct clk *core; + struct clk *pclk; ++ struct clk_divider pow2_div; + struct clk *clk; + struct spi_message *message; + struct spi_transfer *xfer; +@@ -168,6 +169,8 @@ struct meson_spicc_device { + unsigned long xfer_remain; + }; + ++#define pow2_clk_to_spicc(_div) container_of(_div, struct meson_spicc_device, pow2_div) ++ + static void meson_spicc_oen_enable(struct meson_spicc_device *spicc) + { + u32 conf; +@@ -421,7 +424,7 @@ static int meson_spicc_prepare_message(struct spi_master *master, + { + struct meson_spicc_device *spicc = spi_master_get_devdata(master); + struct spi_device *spi = message->spi; +- u32 conf = 0; ++ u32 conf = readl_relaxed(spicc->base + SPICC_CONREG) & SPICC_DATARATE_MASK; + + /* Store current message */ + spicc->message = message; +@@ -458,8 +461,6 @@ static int meson_spicc_prepare_message(struct spi_master *master, + /* Select CS */ + conf |= FIELD_PREP(SPICC_CS_MASK, spi->chip_select); + +- /* Default Clock rate core/4 */ +- + /* Default 8bit word */ + conf |= FIELD_PREP(SPICC_BITLENGTH_MASK, 8 - 1); + +@@ -476,12 +477,16 @@ static int meson_spicc_prepare_message(struct spi_master *master, + static int meson_spicc_unprepare_transfer(struct spi_master *master) + { + struct meson_spicc_device *spicc = spi_master_get_devdata(master); ++ u32 conf = readl_relaxed(spicc->base + SPICC_CONREG) & SPICC_DATARATE_MASK; + + /* Disable all IRQs */ + writel(0, spicc->base + SPICC_INTREG); + + device_reset_optional(&spicc->pdev->dev); + ++ /* Set default configuration, keeping datarate field */ ++ writel_relaxed(conf, spicc->base + SPICC_CONREG); ++ + return 0; + } + +@@ -518,14 +523,60 @@ static void meson_spicc_cleanup(struct spi_device *spi) + * Clk path for G12A series: + * pclk -> pow2 fixed div -> pow2 div -> mux -> out + * pclk -> enh fixed div -> enh div -> mux -> out ++ * ++ * The pow2 divider is tied to the controller HW state, and the ++ * divider is only valid when the controller is initialized. ++ * ++ * A set of clock ops is added to make sure we don't read/set this ++ * clock rate while the controller is in an unknown state. + */ + +-static int meson_spicc_clk_init(struct meson_spicc_device *spicc) ++static unsigned long meson_spicc_pow2_recalc_rate(struct clk_hw *hw, ++ unsigned long parent_rate) ++{ ++ struct clk_divider *divider = to_clk_divider(hw); ++ struct meson_spicc_device *spicc = pow2_clk_to_spicc(divider); ++ ++ if (!spicc->master->cur_msg || !spicc->master->busy) ++ return 0; ++ ++ return clk_divider_ops.recalc_rate(hw, parent_rate); ++} ++ ++static int meson_spicc_pow2_determine_rate(struct clk_hw *hw, ++ struct clk_rate_request *req) ++{ ++ struct clk_divider *divider = to_clk_divider(hw); ++ struct meson_spicc_device *spicc = pow2_clk_to_spicc(divider); ++ ++ if (!spicc->master->cur_msg || !spicc->master->busy) ++ return -EINVAL; ++ ++ return clk_divider_ops.determine_rate(hw, req); ++} ++ ++static int meson_spicc_pow2_set_rate(struct clk_hw *hw, unsigned long rate, ++ unsigned long parent_rate) ++{ ++ struct clk_divider *divider = to_clk_divider(hw); ++ struct meson_spicc_device *spicc = pow2_clk_to_spicc(divider); ++ ++ if (!spicc->master->cur_msg || !spicc->master->busy) ++ return -EINVAL; ++ ++ return clk_divider_ops.set_rate(hw, rate, parent_rate); ++} ++ ++const struct clk_ops meson_spicc_pow2_clk_ops = { ++ .recalc_rate = meson_spicc_pow2_recalc_rate, ++ .determine_rate = meson_spicc_pow2_determine_rate, ++ .set_rate = meson_spicc_pow2_set_rate, ++}; ++ ++static int meson_spicc_pow2_clk_init(struct meson_spicc_device *spicc) + { + struct device *dev = &spicc->pdev->dev; +- struct clk_fixed_factor *pow2_fixed_div, *enh_fixed_div; +- struct clk_divider *pow2_div, *enh_div; +- struct clk_mux *mux; ++ struct clk_fixed_factor *pow2_fixed_div; + struct clk_init_data init; + struct clk *clk; + struct clk_parent_data parent_data[2]; +@@ -560,31 +611,45 @@ static int meson_spicc_clk_init(struct meson_spicc_device *spicc) + if (WARN_ON(IS_ERR(clk))) + return PTR_ERR(clk); + +- pow2_div = devm_kzalloc(dev, sizeof(*pow2_div), GFP_KERNEL); +- if (!pow2_div) +- return -ENOMEM; +- + snprintf(name, sizeof(name), "%s#pow2_div", dev_name(dev)); + init.name = name; +- init.ops = &clk_divider_ops; +- init.flags = CLK_SET_RATE_PARENT; ++ init.ops = &meson_spicc_pow2_clk_ops; ++ /* ++ * Set NOCACHE here to make sure we read the actual HW value ++ * since we reset the HW after each transfer. ++ */ ++ init.flags = CLK_SET_RATE_PARENT | CLK_GET_RATE_NOCACHE; + parent_data[0].hw = &pow2_fixed_div->hw; + init.num_parents = 1; + +- pow2_div->shift = 16, +- pow2_div->width = 3, +- pow2_div->flags = CLK_DIVIDER_POWER_OF_TWO, +- pow2_div->reg = spicc->base + SPICC_CONREG; +- pow2_div->hw.init = &init; ++ spicc->pow2_div.shift = 16, ++ spicc->pow2_div.width = 3, ++ spicc->pow2_div.flags = CLK_DIVIDER_POWER_OF_TWO, ++ spicc->pow2_div.reg = spicc->base + SPICC_CONREG; ++ spicc->pow2_div.hw.init = &init; + +- clk = devm_clk_register(dev, &pow2_div->hw); +- if (WARN_ON(IS_ERR(clk))) +- return PTR_ERR(clk); ++ spicc->clk = devm_clk_register(dev, &spicc->pow2_div.hw); ++ if (WARN_ON(IS_ERR(spicc->clk))) ++ return PTR_ERR(spicc->clk); + +- if (!spicc->data->has_enhance_clk_div) { +- spicc->clk = clk; +- return 0; +- } ++ return 0; ++} ++ ++static int meson_spicc_enh_clk_init(struct meson_spicc_device *spicc) ++{ ++ struct device *dev = &spicc->pdev->dev; ++ struct clk_fixed_factor *enh_fixed_div; ++ struct clk_divider *enh_div; ++ struct clk_mux *mux; ++ struct clk_init_data init; ++ struct clk *clk; ++ struct clk_parent_data parent_data[2]; ++ char name[64]; ++ ++ memset(&init, 0, sizeof(init)); ++ memset(&parent_data, 0, sizeof(parent_data)); ++ ++ init.parent_data = parent_data; + + /* algorithm for enh div: rate = freq / 2 / (N + 1) */ + +@@ -637,7 +702,7 @@ static int meson_spicc_clk_init(struct meson_spicc_device *spicc) + snprintf(name, sizeof(name), "%s#sel", dev_name(dev)); + init.name = name; + init.ops = &clk_mux_ops; +- parent_data[0].hw = &pow2_div->hw; ++ parent_data[0].hw = &spicc->pow2_div.hw; + parent_data[1].hw = &enh_div->hw; + init.num_parents = 2; + init.flags = CLK_SET_RATE_PARENT; +@@ -754,12 +819,20 @@ static int meson_spicc_probe(struct platform_device *pdev) + + meson_spicc_oen_enable(spicc); + +- ret = meson_spicc_clk_init(spicc); ++ ret = meson_spicc_pow2_clk_init(spicc); + if (ret) { +- dev_err(&pdev->dev, "clock registration failed\n"); ++ dev_err(&pdev->dev, "pow2 clock registration failed\n"); + goto out_clk; + } + ++ if (spicc->data->has_enhance_clk_div) { ++ ret = meson_spicc_enh_clk_init(spicc); ++ if (ret) { ++ dev_err(&pdev->dev, "clock registration failed\n"); ++ goto out_clk; ++ } ++ } ++ + ret = devm_spi_register_master(&pdev->dev, master); + if (ret) { + dev_err(&pdev->dev, "spi master registration failed\n"); +diff --git a/drivers/tee/tee_core.c b/drivers/tee/tee_core.c +index e07f997cf8dd3..9cc4a7b63b0d6 100644 +--- a/drivers/tee/tee_core.c ++++ b/drivers/tee/tee_core.c +@@ -334,6 +334,9 @@ tee_ioctl_shm_register(struct tee_context *ctx, + if (data.flags) + return -EINVAL; + ++ if (!access_ok((void __user *)(unsigned long)data.addr, data.length)) ++ return -EFAULT; ++ + shm = tee_shm_register(ctx, data.addr, data.length, + TEE_SHM_DMA_BUF | TEE_SHM_USER_MAPPED); + if (IS_ERR(shm)) +diff --git a/drivers/tee/tee_shm.c b/drivers/tee/tee_shm.c +index 6e662fb131d55..499fccba3d74b 100644 +--- a/drivers/tee/tee_shm.c ++++ b/drivers/tee/tee_shm.c +@@ -222,9 +222,6 @@ struct tee_shm *tee_shm_register(struct tee_context *ctx, unsigned long addr, + goto err; + } + +- if (!access_ok((void __user *)addr, length)) +- return ERR_PTR(-EFAULT); +- + mutex_lock(&teedev->mutex); + shm->id = idr_alloc(&teedev->idr, shm, 1, 0, GFP_KERNEL); + mutex_unlock(&teedev->mutex); +diff --git a/drivers/tty/serial/ucc_uart.c b/drivers/tty/serial/ucc_uart.c +index d6a8604157aba..d1fecc88330ec 100644 +--- a/drivers/tty/serial/ucc_uart.c ++++ b/drivers/tty/serial/ucc_uart.c +@@ -1137,6 +1137,8 @@ static unsigned int soc_info(unsigned int *rev_h, unsigned int *rev_l) + /* No compatible property, so try the name. */ + soc_string = np->name; + ++ of_node_put(np); ++ + /* Extract the SOC number from the "PowerPC," string */ + if ((sscanf(soc_string, "PowerPC,%u", &soc) != 1) || !soc) + return 0; +diff --git a/drivers/usb/cdns3/gadget.c b/drivers/usb/cdns3/gadget.c +index f120da442d43d..a37ea946459cc 100644 +--- a/drivers/usb/cdns3/gadget.c ++++ b/drivers/usb/cdns3/gadget.c +@@ -655,9 +655,9 @@ static void cdns3_wa2_remove_old_request(struct cdns3_endpoint *priv_ep) + trace_cdns3_wa2(priv_ep, "removes eldest request"); + + kfree(priv_req->request.buf); ++ list_del_init(&priv_req->list); + cdns3_gadget_ep_free_request(&priv_ep->endpoint, + &priv_req->request); +- list_del_init(&priv_req->list); + --priv_ep->wa2_counter; + + if (!chain) +diff --git a/drivers/usb/dwc2/gadget.c b/drivers/usb/dwc2/gadget.c +index 64485f82dc5b9..da0df69cc2344 100644 +--- a/drivers/usb/dwc2/gadget.c ++++ b/drivers/usb/dwc2/gadget.c +@@ -3593,7 +3593,8 @@ void dwc2_hsotg_core_disconnect(struct dwc2_hsotg *hsotg) + void dwc2_hsotg_core_connect(struct dwc2_hsotg *hsotg) + { + /* remove the soft-disconnect and let's go */ +- dwc2_clear_bit(hsotg, DCTL, DCTL_SFTDISCON); ++ if (!hsotg->role_sw || (dwc2_readl(hsotg, GOTGCTL) & GOTGCTL_BSESVLD)) ++ dwc2_clear_bit(hsotg, DCTL, DCTL_SFTDISCON); + } + + /** +diff --git a/drivers/usb/gadget/function/uvc_video.c b/drivers/usb/gadget/function/uvc_video.c +index 633e23d58d868..5ce548c2359d8 100644 +--- a/drivers/usb/gadget/function/uvc_video.c ++++ b/drivers/usb/gadget/function/uvc_video.c +@@ -159,7 +159,7 @@ uvc_video_complete(struct usb_ep *ep, struct usb_request *req) + break; + + default: +- uvcg_info(&video->uvc->func, ++ uvcg_warn(&video->uvc->func, + "VS request completed with status %d.\n", + req->status); + uvcg_queue_cancel(queue, 0); +diff --git a/drivers/usb/gadget/legacy/inode.c b/drivers/usb/gadget/legacy/inode.c +index 454860d52ce77..cd097474b6c39 100644 +--- a/drivers/usb/gadget/legacy/inode.c ++++ b/drivers/usb/gadget/legacy/inode.c +@@ -362,6 +362,7 @@ ep_io (struct ep_data *epdata, void *buf, unsigned len) + spin_unlock_irq (&epdata->dev->lock); + + DBG (epdata->dev, "endpoint gone\n"); ++ wait_for_completion(&done); + epdata->status = -ENODEV; + } + } +diff --git a/drivers/usb/host/ohci-ppc-of.c b/drivers/usb/host/ohci-ppc-of.c +index 45f7cceb6df31..98e46725999e9 100644 +--- a/drivers/usb/host/ohci-ppc-of.c ++++ b/drivers/usb/host/ohci-ppc-of.c +@@ -169,6 +169,7 @@ static int ohci_hcd_ppc_of_probe(struct platform_device *op) + release_mem_region(res.start, 0x4); + } else + pr_debug("%s: cannot get ehci offset from fdt\n", __FILE__); ++ of_node_put(np); + } + + irq_dispose_mapping(irq); +diff --git a/drivers/usb/renesas_usbhs/rza.c b/drivers/usb/renesas_usbhs/rza.c +index 24de64edb674b..2d77edefb4b30 100644 +--- a/drivers/usb/renesas_usbhs/rza.c ++++ b/drivers/usb/renesas_usbhs/rza.c +@@ -23,6 +23,10 @@ static int usbhs_rza1_hardware_init(struct platform_device *pdev) + extal_clk = of_find_node_by_name(NULL, "extal"); + of_property_read_u32(usb_x1_clk, "clock-frequency", &freq_usb); + of_property_read_u32(extal_clk, "clock-frequency", &freq_extal); ++ ++ of_node_put(usb_x1_clk); ++ of_node_put(extal_clk); ++ + if (freq_usb == 0) { + if (freq_extal == 12000000) { + /* Select 12MHz XTAL */ +diff --git a/drivers/vfio/vfio.c b/drivers/vfio/vfio.c +index f886f2db8153e..90db9d66867c7 100644 +--- a/drivers/vfio/vfio.c ++++ b/drivers/vfio/vfio.c +@@ -1783,6 +1783,7 @@ struct vfio_info_cap_header *vfio_info_cap_add(struct vfio_info_cap *caps, + buf = krealloc(caps->buf, caps->size + size, GFP_KERNEL); + if (!buf) { + kfree(caps->buf); ++ caps->buf = NULL; + caps->size = 0; + return ERR_PTR(-ENOMEM); + } +diff --git a/drivers/video/fbdev/i740fb.c b/drivers/video/fbdev/i740fb.c +index 52cce0db8bd34..ad5ced4ef972d 100644 +--- a/drivers/video/fbdev/i740fb.c ++++ b/drivers/video/fbdev/i740fb.c +@@ -400,7 +400,7 @@ static int i740fb_decode_var(const struct fb_var_screeninfo *var, + u32 xres, right, hslen, left, xtotal; + u32 yres, lower, vslen, upper, ytotal; + u32 vxres, xoffset, vyres, yoffset; +- u32 bpp, base, dacspeed24, mem; ++ u32 bpp, base, dacspeed24, mem, freq; + u8 r7; + int i; + +@@ -643,7 +643,12 @@ static int i740fb_decode_var(const struct fb_var_screeninfo *var, + par->atc[VGA_ATC_OVERSCAN] = 0; + + /* Calculate VCLK that most closely matches the requested dot clock */ +- i740_calc_vclk((((u32)1e9) / var->pixclock) * (u32)(1e3), par); ++ freq = (((u32)1e9) / var->pixclock) * (u32)(1e3); ++ if (freq < I740_RFREQ_FIX) { ++ fb_dbg(info, "invalid pixclock\n"); ++ freq = I740_RFREQ_FIX; ++ } ++ i740_calc_vclk(freq, par); + + /* Since we program the clocks ourselves, always use VCLK2. */ + par->misc |= 0x0C; +diff --git a/drivers/virt/vboxguest/vboxguest_linux.c b/drivers/virt/vboxguest/vboxguest_linux.c +index 73eb34849eaba..4ccfd30c2a304 100644 +--- a/drivers/virt/vboxguest/vboxguest_linux.c ++++ b/drivers/virt/vboxguest/vboxguest_linux.c +@@ -356,8 +356,8 @@ static int vbg_pci_probe(struct pci_dev *pci, const struct pci_device_id *id) + goto err_vbg_core_exit; + } + +- ret = devm_request_irq(dev, pci->irq, vbg_core_isr, IRQF_SHARED, +- DEVICE_NAME, gdev); ++ ret = request_irq(pci->irq, vbg_core_isr, IRQF_SHARED, DEVICE_NAME, ++ gdev); + if (ret) { + vbg_err("vboxguest: Error requesting irq: %d\n", ret); + goto err_vbg_core_exit; +@@ -367,7 +367,7 @@ static int vbg_pci_probe(struct pci_dev *pci, const struct pci_device_id *id) + if (ret) { + vbg_err("vboxguest: Error misc_register %s failed: %d\n", + DEVICE_NAME, ret); +- goto err_vbg_core_exit; ++ goto err_free_irq; + } + + ret = misc_register(&gdev->misc_device_user); +@@ -403,6 +403,8 @@ err_unregister_misc_device_user: + misc_deregister(&gdev->misc_device_user); + err_unregister_misc_device: + misc_deregister(&gdev->misc_device); ++err_free_irq: ++ free_irq(pci->irq, gdev); + err_vbg_core_exit: + vbg_core_exit(gdev); + err_disable_pcidev: +@@ -419,6 +421,7 @@ static void vbg_pci_remove(struct pci_dev *pci) + vbg_gdev = NULL; + mutex_unlock(&vbg_gdev_mutex); + ++ free_irq(pci->irq, gdev); + device_remove_file(gdev->dev, &dev_attr_host_features); + device_remove_file(gdev->dev, &dev_attr_host_version); + misc_deregister(&gdev->misc_device_user); +diff --git a/drivers/xen/xenbus/xenbus_dev_frontend.c b/drivers/xen/xenbus/xenbus_dev_frontend.c +index 597af455a522b..0792fda49a15f 100644 +--- a/drivers/xen/xenbus/xenbus_dev_frontend.c ++++ b/drivers/xen/xenbus/xenbus_dev_frontend.c +@@ -128,7 +128,7 @@ static ssize_t xenbus_file_read(struct file *filp, + { + struct xenbus_file_priv *u = filp->private_data; + struct read_buffer *rb; +- unsigned i; ++ ssize_t i; + int ret; + + mutex_lock(&u->reply_mutex); +@@ -148,7 +148,7 @@ again: + rb = list_entry(u->read_buffers.next, struct read_buffer, list); + i = 0; + while (i < len) { +- unsigned sz = min((unsigned)len - i, rb->len - rb->cons); ++ size_t sz = min_t(size_t, len - i, rb->len - rb->cons); + + ret = copy_to_user(ubuf + i, &rb->msg[rb->cons], sz); + +diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c +index c246ccc6bf057..9a8dc16673b43 100644 +--- a/fs/btrfs/tree-log.c ++++ b/fs/btrfs/tree-log.c +@@ -1075,7 +1075,9 @@ again: + extref = btrfs_lookup_inode_extref(NULL, root, path, name, namelen, + inode_objectid, parent_objectid, 0, + 0); +- if (!IS_ERR_OR_NULL(extref)) { ++ if (IS_ERR(extref)) { ++ return PTR_ERR(extref); ++ } else if (extref) { + u32 item_size; + u32 cur_offset = 0; + unsigned long base; +diff --git a/fs/ceph/caps.c b/fs/ceph/caps.c +index d3f67271d3c72..76e43a487bc63 100644 +--- a/fs/ceph/caps.c ++++ b/fs/ceph/caps.c +@@ -3501,24 +3501,23 @@ static void handle_cap_grant(struct inode *inode, + fill_inline = true; + } + +- if (ci->i_auth_cap == cap && +- le32_to_cpu(grant->op) == CEPH_CAP_OP_IMPORT) { +- if (newcaps & ~extra_info->issued) +- wake = true; ++ if (le32_to_cpu(grant->op) == CEPH_CAP_OP_IMPORT) { ++ if (ci->i_auth_cap == cap) { ++ if (newcaps & ~extra_info->issued) ++ wake = true; ++ ++ if (ci->i_requested_max_size > max_size || ++ !(le32_to_cpu(grant->wanted) & CEPH_CAP_ANY_FILE_WR)) { ++ /* re-request max_size if necessary */ ++ ci->i_requested_max_size = 0; ++ wake = true; ++ } + +- if (ci->i_requested_max_size > max_size || +- !(le32_to_cpu(grant->wanted) & CEPH_CAP_ANY_FILE_WR)) { +- /* re-request max_size if necessary */ +- ci->i_requested_max_size = 0; +- wake = true; ++ ceph_kick_flushing_inode_caps(session, ci); + } +- +- ceph_kick_flushing_inode_caps(session, ci); +- spin_unlock(&ci->i_ceph_lock); + up_read(&session->s_mdsc->snap_rwsem); +- } else { +- spin_unlock(&ci->i_ceph_lock); + } ++ spin_unlock(&ci->i_ceph_lock); + + if (fill_inline) + ceph_fill_inline_data(inode, NULL, extra_info->inline_data, +diff --git a/fs/ceph/mds_client.c b/fs/ceph/mds_client.c +index 981a915906314..6859967df2b19 100644 +--- a/fs/ceph/mds_client.c ++++ b/fs/ceph/mds_client.c +@@ -1184,14 +1184,17 @@ static int encode_supported_features(void **p, void *end) + if (count > 0) { + size_t i; + size_t size = FEATURE_BYTES(count); ++ unsigned long bit; + + if (WARN_ON_ONCE(*p + 4 + size > end)) + return -ERANGE; + + ceph_encode_32(p, size); + memset(*p, 0, size); +- for (i = 0; i < count; i++) +- ((unsigned char*)(*p))[i / 8] |= BIT(feature_bits[i] % 8); ++ for (i = 0; i < count; i++) { ++ bit = feature_bits[i]; ++ ((unsigned char *)(*p))[bit / 8] |= BIT(bit % 8); ++ } + *p += size; + } else { + if (WARN_ON_ONCE(*p + 4 > end)) +diff --git a/fs/ceph/mds_client.h b/fs/ceph/mds_client.h +index f5adbebcb38e5..acf33d7192bb6 100644 +--- a/fs/ceph/mds_client.h ++++ b/fs/ceph/mds_client.h +@@ -33,10 +33,6 @@ enum ceph_feature_type { + CEPHFS_FEATURE_MAX = CEPHFS_FEATURE_METRIC_COLLECT, + }; + +-/* +- * This will always have the highest feature bit value +- * as the last element of the array. +- */ + #define CEPHFS_FEATURES_CLIENT_SUPPORTED { \ + 0, 1, 2, 3, 4, 5, 6, 7, \ + CEPHFS_FEATURE_MIMIC, \ +@@ -45,8 +41,6 @@ enum ceph_feature_type { + CEPHFS_FEATURE_MULTI_RECONNECT, \ + CEPHFS_FEATURE_DELEG_INO, \ + CEPHFS_FEATURE_METRIC_COLLECT, \ +- \ +- CEPHFS_FEATURE_MAX, \ + } + #define CEPHFS_FEATURES_CLIENT_REQUIRED {} + +diff --git a/fs/cifs/smb2ops.c b/fs/cifs/smb2ops.c +index b855abfaaf87b..b6d72e3c5ebad 100644 +--- a/fs/cifs/smb2ops.c ++++ b/fs/cifs/smb2ops.c +@@ -1000,9 +1000,7 @@ move_smb2_ea_to_cifs(char *dst, size_t dst_size, + size_t name_len, value_len, user_name_len; + + while (src_size > 0) { +- name = &src->ea_data[0]; + name_len = (size_t)src->ea_name_length; +- value = &src->ea_data[src->ea_name_length + 1]; + value_len = (size_t)le16_to_cpu(src->ea_value_length); + + if (name_len == 0) +@@ -1014,6 +1012,9 @@ move_smb2_ea_to_cifs(char *dst, size_t dst_size, + goto out; + } + ++ name = &src->ea_data[0]; ++ value = &src->ea_data[src->ea_name_length + 1]; ++ + if (ea_name) { + if (ea_name_len == name_len && + memcmp(ea_name, name, name_len) == 0) { +diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c +index afc20d32c9fd6..58b0f1b12095b 100644 +--- a/fs/ext4/namei.c ++++ b/fs/ext4/namei.c +@@ -2961,11 +2961,8 @@ bool ext4_empty_dir(struct inode *inode) + de = (struct ext4_dir_entry_2 *) (bh->b_data + + (offset & (sb->s_blocksize - 1))); + if (ext4_check_dir_entry(inode, NULL, de, bh, +- bh->b_data, bh->b_size, offset)) { +- offset = (offset | (sb->s_blocksize - 1)) + 1; +- continue; +- } +- if (le32_to_cpu(de->inode)) { ++ bh->b_data, bh->b_size, offset) || ++ le32_to_cpu(de->inode)) { + brelse(bh); + return false; + } +diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c +index 5cfea77f33227..f6409ddfd1172 100644 +--- a/fs/ext4/resize.c ++++ b/fs/ext4/resize.c +@@ -1957,6 +1957,16 @@ int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count) + } + brelse(bh); + ++ /* ++ * For bigalloc, trim the requested size to the nearest cluster ++ * boundary to avoid creating an unusable filesystem. We do this ++ * silently, instead of returning an error, to avoid breaking ++ * callers that blindly resize the filesystem to the full size of ++ * the underlying block device. ++ */ ++ if (ext4_has_feature_bigalloc(sb)) ++ n_blocks_count &= ~((1 << EXT4_CLUSTER_BITS(sb)) - 1); ++ + retry: + o_blocks_count = ext4_blocks_count(es); + +diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c +index 5fa10d0b00683..c63274d4b74b0 100644 +--- a/fs/f2fs/node.c ++++ b/fs/f2fs/node.c +@@ -1238,7 +1238,11 @@ struct page *f2fs_new_node_page(struct dnode_of_data *dn, unsigned int ofs) + dec_valid_node_count(sbi, dn->inode, !ofs); + goto fail; + } +- f2fs_bug_on(sbi, new_ni.blk_addr != NULL_ADDR); ++ if (unlikely(new_ni.blk_addr != NULL_ADDR)) { ++ err = -EFSCORRUPTED; ++ set_sbi_flag(sbi, SBI_NEED_FSCK); ++ goto fail; ++ } + #endif + new_ni.nid = dn->nid; + new_ni.ino = dn->inode->i_ino; +diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c +index 20091f4cf84de..19224e7d2ad04 100644 +--- a/fs/f2fs/segment.c ++++ b/fs/f2fs/segment.c +@@ -4449,6 +4449,12 @@ static int build_sit_entries(struct f2fs_sb_info *sbi) + return err; + seg_info_from_raw_sit(se, &sit); + ++ if (se->type >= NR_PERSISTENT_LOG) { ++ f2fs_err(sbi, "Invalid segment type: %u, segno: %u", ++ se->type, start); ++ return -EFSCORRUPTED; ++ } ++ + sit_valid_blocks[SE_PAGETYPE(se)] += se->valid_blocks; + + /* build discard map only one time */ +@@ -4495,6 +4501,13 @@ static int build_sit_entries(struct f2fs_sb_info *sbi) + break; + seg_info_from_raw_sit(se, &sit); + ++ if (se->type >= NR_PERSISTENT_LOG) { ++ f2fs_err(sbi, "Invalid segment type: %u, segno: %u", ++ se->type, start); ++ err = -EFSCORRUPTED; ++ break; ++ } ++ + sit_valid_blocks[SE_PAGETYPE(se)] += se->valid_blocks; + + if (is_set_ckpt_flags(sbi, CP_TRIMMED_FLAG)) { +diff --git a/fs/nfs/nfs4idmap.c b/fs/nfs/nfs4idmap.c +index f331866dd4182..ec6afd3c4bca6 100644 +--- a/fs/nfs/nfs4idmap.c ++++ b/fs/nfs/nfs4idmap.c +@@ -561,22 +561,20 @@ nfs_idmap_prepare_pipe_upcall(struct idmap *idmap, + return true; + } + +-static void +-nfs_idmap_complete_pipe_upcall_locked(struct idmap *idmap, int ret) ++static void nfs_idmap_complete_pipe_upcall(struct idmap_legacy_upcalldata *data, ++ int ret) + { +- struct key *authkey = idmap->idmap_upcall_data->authkey; +- +- kfree(idmap->idmap_upcall_data); +- idmap->idmap_upcall_data = NULL; +- complete_request_key(authkey, ret); +- key_put(authkey); ++ complete_request_key(data->authkey, ret); ++ key_put(data->authkey); ++ kfree(data); + } + +-static void +-nfs_idmap_abort_pipe_upcall(struct idmap *idmap, int ret) ++static void nfs_idmap_abort_pipe_upcall(struct idmap *idmap, ++ struct idmap_legacy_upcalldata *data, ++ int ret) + { +- if (idmap->idmap_upcall_data != NULL) +- nfs_idmap_complete_pipe_upcall_locked(idmap, ret); ++ if (cmpxchg(&idmap->idmap_upcall_data, data, NULL) == data) ++ nfs_idmap_complete_pipe_upcall(data, ret); + } + + static int nfs_idmap_legacy_upcall(struct key *authkey, void *aux) +@@ -613,7 +611,7 @@ static int nfs_idmap_legacy_upcall(struct key *authkey, void *aux) + + ret = rpc_queue_upcall(idmap->idmap_pipe, msg); + if (ret < 0) +- nfs_idmap_abort_pipe_upcall(idmap, ret); ++ nfs_idmap_abort_pipe_upcall(idmap, data, ret); + + return ret; + out2: +@@ -669,6 +667,7 @@ idmap_pipe_downcall(struct file *filp, const char __user *src, size_t mlen) + struct request_key_auth *rka; + struct rpc_inode *rpci = RPC_I(file_inode(filp)); + struct idmap *idmap = (struct idmap *)rpci->private; ++ struct idmap_legacy_upcalldata *data; + struct key *authkey; + struct idmap_msg im; + size_t namelen_in; +@@ -678,10 +677,11 @@ idmap_pipe_downcall(struct file *filp, const char __user *src, size_t mlen) + * will have been woken up and someone else may now have used + * idmap_key_cons - so after this point we may no longer touch it. + */ +- if (idmap->idmap_upcall_data == NULL) ++ data = xchg(&idmap->idmap_upcall_data, NULL); ++ if (data == NULL) + goto out_noupcall; + +- authkey = idmap->idmap_upcall_data->authkey; ++ authkey = data->authkey; + rka = get_request_key_auth(authkey); + + if (mlen != sizeof(im)) { +@@ -703,18 +703,17 @@ idmap_pipe_downcall(struct file *filp, const char __user *src, size_t mlen) + if (namelen_in == 0 || namelen_in == IDMAP_NAMESZ) { + ret = -EINVAL; + goto out; +-} ++ } + +- ret = nfs_idmap_read_and_verify_message(&im, +- &idmap->idmap_upcall_data->idmap_msg, +- rka->target_key, authkey); ++ ret = nfs_idmap_read_and_verify_message(&im, &data->idmap_msg, ++ rka->target_key, authkey); + if (ret >= 0) { + key_set_timeout(rka->target_key, nfs_idmap_cache_timeout); + ret = mlen; + } + + out: +- nfs_idmap_complete_pipe_upcall_locked(idmap, ret); ++ nfs_idmap_complete_pipe_upcall(data, ret); + out_noupcall: + return ret; + } +@@ -728,7 +727,7 @@ idmap_pipe_destroy_msg(struct rpc_pipe_msg *msg) + struct idmap *idmap = data->idmap; + + if (msg->errno) +- nfs_idmap_abort_pipe_upcall(idmap, msg->errno); ++ nfs_idmap_abort_pipe_upcall(idmap, data, msg->errno); + } + + static void +@@ -736,8 +735,11 @@ idmap_release_pipe(struct inode *inode) + { + struct rpc_inode *rpci = RPC_I(inode); + struct idmap *idmap = (struct idmap *)rpci->private; ++ struct idmap_legacy_upcalldata *data; + +- nfs_idmap_abort_pipe_upcall(idmap, -EPIPE); ++ data = xchg(&idmap->idmap_upcall_data, NULL); ++ if (data) ++ nfs_idmap_complete_pipe_upcall(data, -EPIPE); + } + + int nfs_map_name_to_uid(const struct nfs_server *server, const char *name, size_t namelen, kuid_t *uid) +diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c +index b22da4e3165b4..03f09399abf4f 100644 +--- a/fs/nfs/nfs4proc.c ++++ b/fs/nfs/nfs4proc.c +@@ -790,10 +790,9 @@ static void nfs4_slot_sequence_record_sent(struct nfs4_slot *slot, + if ((s32)(seqnr - slot->seq_nr_highest_sent) > 0) + slot->seq_nr_highest_sent = seqnr; + } +-static void nfs4_slot_sequence_acked(struct nfs4_slot *slot, +- u32 seqnr) ++static void nfs4_slot_sequence_acked(struct nfs4_slot *slot, u32 seqnr) + { +- slot->seq_nr_highest_sent = seqnr; ++ nfs4_slot_sequence_record_sent(slot, seqnr); + slot->seq_nr_last_acked = seqnr; + } + +@@ -860,7 +859,6 @@ static int nfs41_sequence_process(struct rpc_task *task, + __func__, + slot->slot_nr, + slot->seq_nr); +- nfs4_slot_sequence_acked(slot, slot->seq_nr); + goto out_retry; + case -NFS4ERR_RETRY_UNCACHED_REP: + case -NFS4ERR_SEQ_FALSE_RETRY: +@@ -3086,12 +3084,13 @@ static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata, + } + + out: +- if (opendata->lgp) { +- nfs4_lgopen_release(opendata->lgp); +- opendata->lgp = NULL; +- } +- if (!opendata->cancelled) ++ if (!opendata->cancelled) { ++ if (opendata->lgp) { ++ nfs4_lgopen_release(opendata->lgp); ++ opendata->lgp = NULL; ++ } + nfs4_sequence_free_slot(&opendata->o_res.seq_res); ++ } + return ret; + } + +@@ -9275,6 +9274,9 @@ static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nf + rpc_delay(task, NFS4_POLL_RETRY_MAX); + fallthrough; + case -NFS4ERR_RETRY_UNCACHED_REP: ++ case -EACCES: ++ dprintk("%s: failed to reclaim complete error %d for server %s, retrying\n", ++ __func__, task->tk_status, clp->cl_hostname); + return -EAGAIN; + case -NFS4ERR_BADSESSION: + case -NFS4ERR_DEADSESSION: +diff --git a/include/asm-generic/bitops/atomic.h b/include/asm-generic/bitops/atomic.h +index 0e7316a86240b..21aa26e7c9882 100644 +--- a/include/asm-generic/bitops/atomic.h ++++ b/include/asm-generic/bitops/atomic.h +@@ -35,9 +35,6 @@ static inline int test_and_set_bit(unsigned int nr, volatile unsigned long *p) + unsigned long mask = BIT_MASK(nr); + + p += BIT_WORD(nr); +- if (READ_ONCE(*p) & mask) +- return 1; +- + old = atomic_long_fetch_or(mask, (atomic_long_t *)p); + return !!(old & mask); + } +@@ -48,9 +45,6 @@ static inline int test_and_clear_bit(unsigned int nr, volatile unsigned long *p) + unsigned long mask = BIT_MASK(nr); + + p += BIT_WORD(nr); +- if (!(READ_ONCE(*p) & mask)) +- return 0; +- + old = atomic_long_fetch_andnot(mask, (atomic_long_t *)p); + return !!(old & mask); + } +diff --git a/include/linux/netfilter/nfnetlink.h b/include/linux/netfilter/nfnetlink.h +index f6267e2883f26..791d516e1e880 100644 +--- a/include/linux/netfilter/nfnetlink.h ++++ b/include/linux/netfilter/nfnetlink.h +@@ -57,6 +57,33 @@ static inline u16 nfnl_msg_type(u8 subsys, u8 msg_type) + return subsys << 8 | msg_type; + } + ++static inline void nfnl_fill_hdr(struct nlmsghdr *nlh, u8 family, u8 version, ++ __be16 res_id) ++{ ++ struct nfgenmsg *nfmsg; ++ ++ nfmsg = nlmsg_data(nlh); ++ nfmsg->nfgen_family = family; ++ nfmsg->version = version; ++ nfmsg->res_id = res_id; ++} ++ ++static inline struct nlmsghdr *nfnl_msg_put(struct sk_buff *skb, u32 portid, ++ u32 seq, int type, int flags, ++ u8 family, u8 version, ++ __be16 res_id) ++{ ++ struct nlmsghdr *nlh; ++ ++ nlh = nlmsg_put(skb, portid, seq, type, sizeof(struct nfgenmsg), flags); ++ if (!nlh) ++ return NULL; ++ ++ nfnl_fill_hdr(nlh, family, version, res_id); ++ ++ return nlh; ++} ++ + void nfnl_lock(__u8 subsys_id); + void nfnl_unlock(__u8 subsys_id); + #ifdef CONFIG_PROVE_LOCKING +diff --git a/include/linux/nmi.h b/include/linux/nmi.h +index 750c7f395ca90..f700ff2df074e 100644 +--- a/include/linux/nmi.h ++++ b/include/linux/nmi.h +@@ -122,6 +122,8 @@ int watchdog_nmi_probe(void); + int watchdog_nmi_enable(unsigned int cpu); + void watchdog_nmi_disable(unsigned int cpu); + ++void lockup_detector_reconfigure(void); ++ + /** + * touch_nmi_watchdog - restart NMI watchdog timeout. + * +diff --git a/include/linux/uacce.h b/include/linux/uacce.h +index 48e319f402751..9ce88c28b0a87 100644 +--- a/include/linux/uacce.h ++++ b/include/linux/uacce.h +@@ -70,6 +70,7 @@ enum uacce_q_state { + * @wait: wait queue head + * @list: index into uacce queues list + * @qfrs: pointer of qfr regions ++ * @mutex: protects queue state + * @state: queue state machine + * @pasid: pasid associated to the mm + * @handle: iommu_sva handle returned by iommu_sva_bind_device() +@@ -80,6 +81,7 @@ struct uacce_queue { + wait_queue_head_t wait; + struct list_head list; + struct uacce_qfile_region *qfrs[UACCE_MAX_REGION]; ++ struct mutex mutex; + enum uacce_q_state state; + u32 pasid; + struct iommu_sva *handle; +@@ -97,9 +99,9 @@ struct uacce_queue { + * @dev_id: id of the uacce device + * @cdev: cdev of the uacce + * @dev: dev of the uacce ++ * @mutex: protects uacce operation + * @priv: private pointer of the uacce + * @queues: list of queues +- * @queues_lock: lock for queues list + * @inode: core vfs + */ + struct uacce_device { +@@ -113,9 +115,9 @@ struct uacce_device { + u32 dev_id; + struct cdev *cdev; + struct device dev; ++ struct mutex mutex; + void *priv; + struct list_head queues; +- struct mutex queues_lock; + struct inode *inode; + }; + +diff --git a/include/sound/control.h b/include/sound/control.h +index 77d9fa10812d0..41bd72ffd2322 100644 +--- a/include/sound/control.h ++++ b/include/sound/control.h +@@ -103,7 +103,7 @@ struct snd_ctl_file { + int preferred_subdevice[SND_CTL_SUBDEV_ITEMS]; + wait_queue_head_t change_sleep; + spinlock_t read_lock; +- struct fasync_struct *fasync; ++ struct snd_fasync *fasync; + int subscribed; /* read interface is activated */ + struct list_head events; /* waiting events for read */ + }; +diff --git a/include/sound/core.h b/include/sound/core.h +index 0462c577d7a3f..85610ede9ea01 100644 +--- a/include/sound/core.h ++++ b/include/sound/core.h +@@ -446,4 +446,12 @@ snd_pci_quirk_lookup_id(u16 vendor, u16 device, + } + #endif + ++/* async signal helpers */ ++struct snd_fasync; ++ ++int snd_fasync_helper(int fd, struct file *file, int on, ++ struct snd_fasync **fasyncp); ++void snd_kill_fasync(struct snd_fasync *fasync, int signal, int poll); ++void snd_fasync_free(struct snd_fasync *fasync); ++ + #endif /* __SOUND_CORE_H */ +diff --git a/kernel/bpf/arraymap.c b/kernel/bpf/arraymap.c +index 36c68dcea2369..f241bda2679d4 100644 +--- a/kernel/bpf/arraymap.c ++++ b/kernel/bpf/arraymap.c +@@ -616,6 +616,11 @@ static int bpf_iter_init_array_map(void *priv_data, + seq_info->percpu_value_buf = value_buf; + } + ++ /* bpf_iter_attach_map() acquires a map uref, and the uref may be ++ * released before or in the middle of iterating map elements, so ++ * acquire an extra map uref for iterator. ++ */ ++ bpf_map_inc_with_uref(map); + seq_info->map = map; + return 0; + } +@@ -624,6 +629,7 @@ static void bpf_iter_fini_array_map(void *priv_data) + { + struct bpf_iter_seq_array_map_info *seq_info = priv_data; + ++ bpf_map_put_with_uref(seq_info->map); + kfree(seq_info->percpu_value_buf); + } + +diff --git a/kernel/bpf/cgroup.c b/kernel/bpf/cgroup.c +index 6aa9e10c6335a..d154e52dd7ae0 100644 +--- a/kernel/bpf/cgroup.c ++++ b/kernel/bpf/cgroup.c +@@ -653,6 +653,60 @@ static struct bpf_prog_list *find_detach_entry(struct list_head *progs, + return ERR_PTR(-ENOENT); + } + ++/** ++ * purge_effective_progs() - After compute_effective_progs fails to alloc new ++ * cgrp->bpf.inactive table we can recover by ++ * recomputing the array in place. ++ * ++ * @cgrp: The cgroup which descendants to travers ++ * @prog: A program to detach or NULL ++ * @link: A link to detach or NULL ++ * @type: Type of detach operation ++ */ ++static void purge_effective_progs(struct cgroup *cgrp, struct bpf_prog *prog, ++ struct bpf_cgroup_link *link, ++ enum bpf_attach_type type) ++{ ++ struct cgroup_subsys_state *css; ++ struct bpf_prog_array *progs; ++ struct bpf_prog_list *pl; ++ struct list_head *head; ++ struct cgroup *cg; ++ int pos; ++ ++ /* recompute effective prog array in place */ ++ css_for_each_descendant_pre(css, &cgrp->self) { ++ struct cgroup *desc = container_of(css, struct cgroup, self); ++ ++ if (percpu_ref_is_zero(&desc->bpf.refcnt)) ++ continue; ++ ++ /* find position of link or prog in effective progs array */ ++ for (pos = 0, cg = desc; cg; cg = cgroup_parent(cg)) { ++ if (pos && !(cg->bpf.flags[type] & BPF_F_ALLOW_MULTI)) ++ continue; ++ ++ head = &cg->bpf.progs[type]; ++ list_for_each_entry(pl, head, node) { ++ if (!prog_list_prog(pl)) ++ continue; ++ if (pl->prog == prog && pl->link == link) ++ goto found; ++ pos++; ++ } ++ } ++found: ++ BUG_ON(!cg); ++ progs = rcu_dereference_protected( ++ desc->bpf.effective[type], ++ lockdep_is_held(&cgroup_mutex)); ++ ++ /* Remove the program from the array */ ++ WARN_ONCE(bpf_prog_array_delete_safe_at(progs, pos), ++ "Failed to purge a prog from array at index %d", pos); ++ } ++} ++ + /** + * __cgroup_bpf_detach() - Detach the program or link from a cgroup, and + * propagate the change to descendants +@@ -671,7 +725,6 @@ int __cgroup_bpf_detach(struct cgroup *cgrp, struct bpf_prog *prog, + u32 flags = cgrp->bpf.flags[type]; + struct bpf_prog_list *pl; + struct bpf_prog *old_prog; +- int err; + + if (prog && link) + /* only one of prog or link can be specified */ +@@ -686,9 +739,12 @@ int __cgroup_bpf_detach(struct cgroup *cgrp, struct bpf_prog *prog, + pl->prog = NULL; + pl->link = NULL; + +- err = update_effective_progs(cgrp, type); +- if (err) +- goto cleanup; ++ if (update_effective_progs(cgrp, type)) { ++ /* if update effective array failed replace the prog with a dummy prog*/ ++ pl->prog = old_prog; ++ pl->link = link; ++ purge_effective_progs(cgrp, old_prog, link, type); ++ } + + /* now can actually delete it from this cgroup list */ + list_del(&pl->node); +@@ -700,12 +756,6 @@ int __cgroup_bpf_detach(struct cgroup *cgrp, struct bpf_prog *prog, + bpf_prog_put(old_prog); + static_branch_dec(&cgroup_bpf_enabled_key); + return 0; +- +-cleanup: +- /* restore back prog or link */ +- pl->prog = old_prog; +- pl->link = link; +- return err; + } + + /* Must be called with cgroup_mutex held to avoid races. */ +diff --git a/kernel/bpf/hashtab.c b/kernel/bpf/hashtab.c +index 6c444e815406b..0ce445aadfdfb 100644 +--- a/kernel/bpf/hashtab.c ++++ b/kernel/bpf/hashtab.c +@@ -1801,6 +1801,7 @@ static int bpf_iter_init_hash_map(void *priv_data, + seq_info->percpu_value_buf = value_buf; + } + ++ bpf_map_inc_with_uref(map); + seq_info->map = map; + seq_info->htab = container_of(map, struct bpf_htab, map); + return 0; +@@ -1810,6 +1811,7 @@ static void bpf_iter_fini_hash_map(void *priv_data) + { + struct bpf_iter_seq_hash_map_info *seq_info = priv_data; + ++ bpf_map_put_with_uref(seq_info->map); + kfree(seq_info->percpu_value_buf); + } + +diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c +index 7cc5f0a77c3cc..826ecf01e380c 100644 +--- a/kernel/trace/trace_events.c ++++ b/kernel/trace/trace_events.c +@@ -168,6 +168,7 @@ static int trace_define_generic_fields(void) + + __generic_field(int, CPU, FILTER_CPU); + __generic_field(int, cpu, FILTER_CPU); ++ __generic_field(int, common_cpu, FILTER_CPU); + __generic_field(char *, COMM, FILTER_COMM); + __generic_field(char *, comm, FILTER_COMM); + +diff --git a/kernel/trace/trace_probe.c b/kernel/trace/trace_probe.c +index 1d31bc4acf7a5..073abbe3866b4 100644 +--- a/kernel/trace/trace_probe.c ++++ b/kernel/trace/trace_probe.c +@@ -300,7 +300,7 @@ static int parse_probe_vars(char *arg, const struct fetch_type *t, + } + } else + goto inval_var; +- } else if (strcmp(arg, "comm") == 0) { ++ } else if (strcmp(arg, "comm") == 0 || strcmp(arg, "COMM") == 0) { + code->op = FETCH_OP_COMM; + #ifdef CONFIG_HAVE_FUNCTION_ARG_ACCESS_API + } else if (((flags & TPARG_FL_MASK) == +@@ -595,7 +595,8 @@ static int traceprobe_parse_probe_arg_body(char *arg, ssize_t *size, + * Since $comm and immediate string can not be dereferred, + * we can find those by strcmp. + */ +- if (strcmp(arg, "$comm") == 0 || strncmp(arg, "\\\"", 2) == 0) { ++ if (strcmp(arg, "$comm") == 0 || strcmp(arg, "$COMM") == 0 || ++ strncmp(arg, "\\\"", 2) == 0) { + /* The type of $comm must be "string", and not an array. */ + if (parg->count || (t && strcmp(t, "string"))) + return -EINVAL; +diff --git a/kernel/watchdog.c b/kernel/watchdog.c +index 01bf977090dc2..ec34d9f2eab2d 100644 +--- a/kernel/watchdog.c ++++ b/kernel/watchdog.c +@@ -518,7 +518,7 @@ int lockup_detector_offline_cpu(unsigned int cpu) + return 0; + } + +-static void lockup_detector_reconfigure(void) ++static void __lockup_detector_reconfigure(void) + { + cpus_read_lock(); + watchdog_nmi_stop(); +@@ -538,6 +538,13 @@ static void lockup_detector_reconfigure(void) + __lockup_detector_cleanup(); + } + ++void lockup_detector_reconfigure(void) ++{ ++ mutex_lock(&watchdog_mutex); ++ __lockup_detector_reconfigure(); ++ mutex_unlock(&watchdog_mutex); ++} ++ + /* + * Create the watchdog thread infrastructure and configure the detector(s). + * +@@ -558,13 +565,13 @@ static __init void lockup_detector_setup(void) + return; + + mutex_lock(&watchdog_mutex); +- lockup_detector_reconfigure(); ++ __lockup_detector_reconfigure(); + softlockup_initialized = true; + mutex_unlock(&watchdog_mutex); + } + + #else /* CONFIG_SOFTLOCKUP_DETECTOR */ +-static void lockup_detector_reconfigure(void) ++static void __lockup_detector_reconfigure(void) + { + cpus_read_lock(); + watchdog_nmi_stop(); +@@ -572,9 +579,13 @@ static void lockup_detector_reconfigure(void) + watchdog_nmi_start(); + cpus_read_unlock(); + } ++void lockup_detector_reconfigure(void) ++{ ++ __lockup_detector_reconfigure(); ++} + static inline void lockup_detector_setup(void) + { +- lockup_detector_reconfigure(); ++ __lockup_detector_reconfigure(); + } + #endif /* !CONFIG_SOFTLOCKUP_DETECTOR */ + +@@ -614,7 +625,7 @@ static void proc_watchdog_update(void) + { + /* Remove impossible cpus to keep sysctl output clean. */ + cpumask_and(&watchdog_cpumask, &watchdog_cpumask, cpu_possible_mask); +- lockup_detector_reconfigure(); ++ __lockup_detector_reconfigure(); + } + + /* +diff --git a/lib/list_debug.c b/lib/list_debug.c +index 5d5424b51b746..413daa72a3d83 100644 +--- a/lib/list_debug.c ++++ b/lib/list_debug.c +@@ -20,7 +20,11 @@ + bool __list_add_valid(struct list_head *new, struct list_head *prev, + struct list_head *next) + { +- if (CHECK_DATA_CORRUPTION(next->prev != prev, ++ if (CHECK_DATA_CORRUPTION(prev == NULL, ++ "list_add corruption. prev is NULL.\n") || ++ CHECK_DATA_CORRUPTION(next == NULL, ++ "list_add corruption. next is NULL.\n") || ++ CHECK_DATA_CORRUPTION(next->prev != prev, + "list_add corruption. next->prev should be prev (%px), but was %px. (next=%px).\n", + prev, next->prev, next) || + CHECK_DATA_CORRUPTION(prev->next != next, +@@ -42,7 +46,11 @@ bool __list_del_entry_valid(struct list_head *entry) + prev = entry->prev; + next = entry->next; + +- if (CHECK_DATA_CORRUPTION(next == LIST_POISON1, ++ if (CHECK_DATA_CORRUPTION(next == NULL, ++ "list_del corruption, %px->next is NULL\n", entry) || ++ CHECK_DATA_CORRUPTION(prev == NULL, ++ "list_del corruption, %px->prev is NULL\n", entry) || ++ CHECK_DATA_CORRUPTION(next == LIST_POISON1, + "list_del corruption, %px->next is LIST_POISON1 (%px)\n", + entry, LIST_POISON1) || + CHECK_DATA_CORRUPTION(prev == LIST_POISON2, +diff --git a/net/can/j1939/socket.c b/net/can/j1939/socket.c +index e1a399821238f..709141abd1318 100644 +--- a/net/can/j1939/socket.c ++++ b/net/can/j1939/socket.c +@@ -178,7 +178,10 @@ activate_next: + if (!first) + return; + +- if (WARN_ON_ONCE(j1939_session_activate(first))) { ++ if (j1939_session_activate(first)) { ++ netdev_warn_once(first->priv->ndev, ++ "%s: 0x%p: Identical session is already activated.\n", ++ __func__, first); + first->err = -EBUSY; + goto activate_next; + } else { +diff --git a/net/can/j1939/transport.c b/net/can/j1939/transport.c +index 9c39b0f5d6e07..2830a12a4dd1b 100644 +--- a/net/can/j1939/transport.c ++++ b/net/can/j1939/transport.c +@@ -260,6 +260,8 @@ static void __j1939_session_drop(struct j1939_session *session) + + static void j1939_session_destroy(struct j1939_session *session) + { ++ struct sk_buff *skb; ++ + if (session->err) + j1939_sk_errqueue(session, J1939_ERRQUEUE_ABORT); + else +@@ -270,7 +272,11 @@ static void j1939_session_destroy(struct j1939_session *session) + WARN_ON_ONCE(!list_empty(&session->sk_session_queue_entry)); + WARN_ON_ONCE(!list_empty(&session->active_session_list_entry)); + +- skb_queue_purge(&session->skb_queue); ++ while ((skb = skb_dequeue(&session->skb_queue)) != NULL) { ++ /* drop ref taken in j1939_session_skb_queue() */ ++ skb_unref(skb); ++ kfree_skb(skb); ++ } + __j1939_session_drop(session); + j1939_priv_put(session->priv); + kfree(session); +diff --git a/net/core/bpf_sk_storage.c b/net/core/bpf_sk_storage.c +index c907f0dc7f87a..5f773624948ff 100644 +--- a/net/core/bpf_sk_storage.c ++++ b/net/core/bpf_sk_storage.c +@@ -794,10 +794,18 @@ static int bpf_iter_init_sk_storage_map(void *priv_data, + { + struct bpf_iter_seq_sk_storage_map_info *seq_info = priv_data; + ++ bpf_map_inc_with_uref(aux->map); + seq_info->map = aux->map; + return 0; + } + ++static void bpf_iter_fini_sk_storage_map(void *priv_data) ++{ ++ struct bpf_iter_seq_sk_storage_map_info *seq_info = priv_data; ++ ++ bpf_map_put_with_uref(seq_info->map); ++} ++ + static int bpf_iter_attach_map(struct bpf_prog *prog, + union bpf_iter_link_info *linfo, + struct bpf_iter_aux_info *aux) +@@ -815,7 +823,7 @@ static int bpf_iter_attach_map(struct bpf_prog *prog, + if (map->map_type != BPF_MAP_TYPE_SK_STORAGE) + goto put_map; + +- if (prog->aux->max_rdonly_access > map->value_size) { ++ if (prog->aux->max_rdwr_access > map->value_size) { + err = -EACCES; + goto put_map; + } +@@ -843,7 +851,7 @@ static const struct seq_operations bpf_sk_storage_map_seq_ops = { + static const struct bpf_iter_seq_info iter_seq_info = { + .seq_ops = &bpf_sk_storage_map_seq_ops, + .init_seq_private = bpf_iter_init_sk_storage_map, +- .fini_seq_private = NULL, ++ .fini_seq_private = bpf_iter_fini_sk_storage_map, + .seq_priv_size = sizeof(struct bpf_iter_seq_sk_storage_map_info), + }; + +diff --git a/net/core/devlink.c b/net/core/devlink.c +index 646d90f63dafc..72047750dcd96 100644 +--- a/net/core/devlink.c ++++ b/net/core/devlink.c +@@ -3620,7 +3620,7 @@ static int devlink_param_get(struct devlink *devlink, + const struct devlink_param *param, + struct devlink_param_gset_ctx *ctx) + { +- if (!param->get) ++ if (!param->get || devlink->reload_failed) + return -EOPNOTSUPP; + return param->get(devlink, param->id, ctx); + } +@@ -3629,7 +3629,7 @@ static int devlink_param_set(struct devlink *devlink, + const struct devlink_param *param, + struct devlink_param_gset_ctx *ctx) + { +- if (!param->set) ++ if (!param->set || devlink->reload_failed) + return -EOPNOTSUPP; + return param->set(devlink, param->id, ctx); + } +diff --git a/net/core/sock_map.c b/net/core/sock_map.c +index 4ea5bc65848f2..cbf4184fabc98 100644 +--- a/net/core/sock_map.c ++++ b/net/core/sock_map.c +@@ -815,13 +815,22 @@ static int sock_map_init_seq_private(void *priv_data, + { + struct sock_map_seq_info *info = priv_data; + ++ bpf_map_inc_with_uref(aux->map); + info->map = aux->map; + return 0; + } + ++static void sock_map_fini_seq_private(void *priv_data) ++{ ++ struct sock_map_seq_info *info = priv_data; ++ ++ bpf_map_put_with_uref(info->map); ++} ++ + static const struct bpf_iter_seq_info sock_map_iter_seq_info = { + .seq_ops = &sock_map_seq_ops, + .init_seq_private = sock_map_init_seq_private, ++ .fini_seq_private = sock_map_fini_seq_private, + .seq_priv_size = sizeof(struct sock_map_seq_info), + }; + +@@ -1422,18 +1431,27 @@ static const struct seq_operations sock_hash_seq_ops = { + }; + + static int sock_hash_init_seq_private(void *priv_data, +- struct bpf_iter_aux_info *aux) ++ struct bpf_iter_aux_info *aux) + { + struct sock_hash_seq_info *info = priv_data; + ++ bpf_map_inc_with_uref(aux->map); + info->map = aux->map; + info->htab = container_of(aux->map, struct bpf_shtab, map); + return 0; + } + ++static void sock_hash_fini_seq_private(void *priv_data) ++{ ++ struct sock_hash_seq_info *info = priv_data; ++ ++ bpf_map_put_with_uref(info->map); ++} ++ + static const struct bpf_iter_seq_info sock_hash_iter_seq_info = { + .seq_ops = &sock_hash_seq_ops, + .init_seq_private = sock_hash_init_seq_private, ++ .fini_seq_private = sock_hash_fini_seq_private, + .seq_priv_size = sizeof(struct sock_hash_seq_info), + }; + +diff --git a/net/ipv6/ip6_output.c b/net/ipv6/ip6_output.c +index 05e19e5d65140..fadad8e83521d 100644 +--- a/net/ipv6/ip6_output.c ++++ b/net/ipv6/ip6_output.c +@@ -1313,8 +1313,7 @@ struct dst_entry *ip6_dst_lookup_tunnel(struct sk_buff *skb, + fl6.daddr = info->key.u.ipv6.dst; + fl6.saddr = info->key.u.ipv6.src; + prio = info->key.tos; +- fl6.flowlabel = ip6_make_flowinfo(RT_TOS(prio), +- info->key.label); ++ fl6.flowlabel = ip6_make_flowinfo(prio, info->key.label); + + dst = ipv6_stub->ipv6_dst_lookup_flow(net, sock->sk, &fl6, + NULL); +diff --git a/net/netfilter/ipset/ip_set_core.c b/net/netfilter/ipset/ip_set_core.c +index 2b19189a930fd..c17a7dda0163f 100644 +--- a/net/netfilter/ipset/ip_set_core.c ++++ b/net/netfilter/ipset/ip_set_core.c +@@ -963,20 +963,9 @@ static struct nlmsghdr * + start_msg(struct sk_buff *skb, u32 portid, u32 seq, unsigned int flags, + enum ipset_cmd cmd) + { +- struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; +- +- nlh = nlmsg_put(skb, portid, seq, nfnl_msg_type(NFNL_SUBSYS_IPSET, cmd), +- sizeof(*nfmsg), flags); +- if (!nlh) +- return NULL; +- +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = NFPROTO_IPV4; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = 0; +- +- return nlh; ++ return nfnl_msg_put(skb, portid, seq, ++ nfnl_msg_type(NFNL_SUBSYS_IPSET, cmd), flags, ++ NFPROTO_IPV4, NFNETLINK_V0, 0); + } + + /* Create a set */ +diff --git a/net/netfilter/nf_conntrack_netlink.c b/net/netfilter/nf_conntrack_netlink.c +index eeeaa34b3e7b5..9e6898164199b 100644 +--- a/net/netfilter/nf_conntrack_netlink.c ++++ b/net/netfilter/nf_conntrack_netlink.c +@@ -553,22 +553,17 @@ ctnetlink_fill_info(struct sk_buff *skb, u32 portid, u32 seq, u32 type, + { + const struct nf_conntrack_zone *zone; + struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; + struct nlattr *nest_parms; + unsigned int event; + + if (portid) + flags |= NLM_F_MULTI; + event = nfnl_msg_type(NFNL_SUBSYS_CTNETLINK, IPCTNL_MSG_CT_NEW); +- nlh = nlmsg_put(skb, portid, seq, event, sizeof(*nfmsg), flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, event, flags, nf_ct_l3num(ct), ++ NFNETLINK_V0, 0); ++ if (!nlh) + goto nlmsg_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = nf_ct_l3num(ct); +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = 0; +- + zone = nf_ct_zone(ct); + + nest_parms = nla_nest_start(skb, CTA_TUPLE_ORIG); +@@ -711,7 +706,6 @@ ctnetlink_conntrack_event(unsigned int events, struct nf_ct_event *item) + const struct nf_conntrack_zone *zone; + struct net *net; + struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; + struct nlattr *nest_parms; + struct nf_conn *ct = item->ct; + struct sk_buff *skb; +@@ -741,15 +735,11 @@ ctnetlink_conntrack_event(unsigned int events, struct nf_ct_event *item) + goto errout; + + type = nfnl_msg_type(NFNL_SUBSYS_CTNETLINK, type); +- nlh = nlmsg_put(skb, item->portid, 0, type, sizeof(*nfmsg), flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, item->portid, 0, type, flags, nf_ct_l3num(ct), ++ NFNETLINK_V0, 0); ++ if (!nlh) + goto nlmsg_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = nf_ct_l3num(ct); +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = 0; +- + zone = nf_ct_zone(ct); + + nest_parms = nla_nest_start(skb, CTA_TUPLE_ORIG); +@@ -2483,20 +2473,15 @@ ctnetlink_ct_stat_cpu_fill_info(struct sk_buff *skb, u32 portid, u32 seq, + __u16 cpu, const struct ip_conntrack_stat *st) + { + struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; + unsigned int flags = portid ? NLM_F_MULTI : 0, event; + + event = nfnl_msg_type(NFNL_SUBSYS_CTNETLINK, + IPCTNL_MSG_CT_GET_STATS_CPU); +- nlh = nlmsg_put(skb, portid, seq, event, sizeof(*nfmsg), flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, event, flags, AF_UNSPEC, ++ NFNETLINK_V0, htons(cpu)); ++ if (!nlh) + goto nlmsg_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = AF_UNSPEC; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = htons(cpu); +- + if (nla_put_be32(skb, CTA_STATS_FOUND, htonl(st->found)) || + nla_put_be32(skb, CTA_STATS_INVALID, htonl(st->invalid)) || + nla_put_be32(skb, CTA_STATS_INSERT, htonl(st->insert)) || +@@ -2568,20 +2553,15 @@ ctnetlink_stat_ct_fill_info(struct sk_buff *skb, u32 portid, u32 seq, u32 type, + struct net *net) + { + struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; + unsigned int flags = portid ? NLM_F_MULTI : 0, event; + unsigned int nr_conntracks = atomic_read(&net->ct.count); + + event = nfnl_msg_type(NFNL_SUBSYS_CTNETLINK, IPCTNL_MSG_CT_GET_STATS); +- nlh = nlmsg_put(skb, portid, seq, event, sizeof(*nfmsg), flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, event, flags, AF_UNSPEC, ++ NFNETLINK_V0, 0); ++ if (!nlh) + goto nlmsg_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = AF_UNSPEC; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = 0; +- + if (nla_put_be32(skb, CTA_STATS_GLOBAL_ENTRIES, htonl(nr_conntracks))) + goto nla_put_failure; + +@@ -3085,19 +3065,14 @@ ctnetlink_exp_fill_info(struct sk_buff *skb, u32 portid, u32 seq, + int event, const struct nf_conntrack_expect *exp) + { + struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; + unsigned int flags = portid ? NLM_F_MULTI : 0; + + event = nfnl_msg_type(NFNL_SUBSYS_CTNETLINK_EXP, event); +- nlh = nlmsg_put(skb, portid, seq, event, sizeof(*nfmsg), flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, event, flags, ++ exp->tuple.src.l3num, NFNETLINK_V0, 0); ++ if (!nlh) + goto nlmsg_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = exp->tuple.src.l3num; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = 0; +- + if (ctnetlink_exp_dump_expect(skb, exp) < 0) + goto nla_put_failure; + +@@ -3117,7 +3092,6 @@ ctnetlink_expect_event(unsigned int events, struct nf_exp_event *item) + struct nf_conntrack_expect *exp = item->exp; + struct net *net = nf_ct_exp_net(exp); + struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; + struct sk_buff *skb; + unsigned int type, group; + int flags = 0; +@@ -3140,15 +3114,11 @@ ctnetlink_expect_event(unsigned int events, struct nf_exp_event *item) + goto errout; + + type = nfnl_msg_type(NFNL_SUBSYS_CTNETLINK_EXP, type); +- nlh = nlmsg_put(skb, item->portid, 0, type, sizeof(*nfmsg), flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, item->portid, 0, type, flags, ++ exp->tuple.src.l3num, NFNETLINK_V0, 0); ++ if (!nlh) + goto nlmsg_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = exp->tuple.src.l3num; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = 0; +- + if (ctnetlink_exp_dump_expect(skb, exp) < 0) + goto nla_put_failure; + +@@ -3716,20 +3686,15 @@ ctnetlink_exp_stat_fill_info(struct sk_buff *skb, u32 portid, u32 seq, int cpu, + const struct ip_conntrack_stat *st) + { + struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; + unsigned int flags = portid ? NLM_F_MULTI : 0, event; + + event = nfnl_msg_type(NFNL_SUBSYS_CTNETLINK, + IPCTNL_MSG_EXP_GET_STATS_CPU); +- nlh = nlmsg_put(skb, portid, seq, event, sizeof(*nfmsg), flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, event, flags, AF_UNSPEC, ++ NFNETLINK_V0, htons(cpu)); ++ if (!nlh) + goto nlmsg_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = AF_UNSPEC; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = htons(cpu); +- + if (nla_put_be32(skb, CTA_STATS_EXP_NEW, htonl(st->expect_new)) || + nla_put_be32(skb, CTA_STATS_EXP_CREATE, htonl(st->expect_create)) || + nla_put_be32(skb, CTA_STATS_EXP_DELETE, htonl(st->expect_delete))) +diff --git a/net/netfilter/nf_tables_api.c b/net/netfilter/nf_tables_api.c +index 2ba48f4e2d7da..30bd4b867912c 100644 +--- a/net/netfilter/nf_tables_api.c ++++ b/net/netfilter/nf_tables_api.c +@@ -66,6 +66,41 @@ static const struct rhashtable_params nft_objname_ht_params = { + .automatic_shrinking = true, + }; + ++struct nft_audit_data { ++ struct nft_table *table; ++ int entries; ++ int op; ++ struct list_head list; ++}; ++ ++static const u8 nft2audit_op[NFT_MSG_MAX] = { // enum nf_tables_msg_types ++ [NFT_MSG_NEWTABLE] = AUDIT_NFT_OP_TABLE_REGISTER, ++ [NFT_MSG_GETTABLE] = AUDIT_NFT_OP_INVALID, ++ [NFT_MSG_DELTABLE] = AUDIT_NFT_OP_TABLE_UNREGISTER, ++ [NFT_MSG_NEWCHAIN] = AUDIT_NFT_OP_CHAIN_REGISTER, ++ [NFT_MSG_GETCHAIN] = AUDIT_NFT_OP_INVALID, ++ [NFT_MSG_DELCHAIN] = AUDIT_NFT_OP_CHAIN_UNREGISTER, ++ [NFT_MSG_NEWRULE] = AUDIT_NFT_OP_RULE_REGISTER, ++ [NFT_MSG_GETRULE] = AUDIT_NFT_OP_INVALID, ++ [NFT_MSG_DELRULE] = AUDIT_NFT_OP_RULE_UNREGISTER, ++ [NFT_MSG_NEWSET] = AUDIT_NFT_OP_SET_REGISTER, ++ [NFT_MSG_GETSET] = AUDIT_NFT_OP_INVALID, ++ [NFT_MSG_DELSET] = AUDIT_NFT_OP_SET_UNREGISTER, ++ [NFT_MSG_NEWSETELEM] = AUDIT_NFT_OP_SETELEM_REGISTER, ++ [NFT_MSG_GETSETELEM] = AUDIT_NFT_OP_INVALID, ++ [NFT_MSG_DELSETELEM] = AUDIT_NFT_OP_SETELEM_UNREGISTER, ++ [NFT_MSG_NEWGEN] = AUDIT_NFT_OP_GEN_REGISTER, ++ [NFT_MSG_GETGEN] = AUDIT_NFT_OP_INVALID, ++ [NFT_MSG_TRACE] = AUDIT_NFT_OP_INVALID, ++ [NFT_MSG_NEWOBJ] = AUDIT_NFT_OP_OBJ_REGISTER, ++ [NFT_MSG_GETOBJ] = AUDIT_NFT_OP_INVALID, ++ [NFT_MSG_DELOBJ] = AUDIT_NFT_OP_OBJ_UNREGISTER, ++ [NFT_MSG_GETOBJ_RESET] = AUDIT_NFT_OP_OBJ_RESET, ++ [NFT_MSG_NEWFLOWTABLE] = AUDIT_NFT_OP_FLOWTABLE_REGISTER, ++ [NFT_MSG_GETFLOWTABLE] = AUDIT_NFT_OP_INVALID, ++ [NFT_MSG_DELFLOWTABLE] = AUDIT_NFT_OP_FLOWTABLE_UNREGISTER, ++}; ++ + static void nft_validate_state_update(struct net *net, u8 new_validate_state) + { + switch (net->nft.validate_state) { +@@ -648,6 +683,11 @@ nf_tables_chain_type_lookup(struct net *net, const struct nlattr *nla, + return ERR_PTR(-ENOENT); + } + ++static __be16 nft_base_seq(const struct net *net) ++{ ++ return htons(net->nft.base_seq & 0xffff); ++} ++ + static const struct nla_policy nft_table_policy[NFTA_TABLE_MAX + 1] = { + [NFTA_TABLE_NAME] = { .type = NLA_STRING, + .len = NFT_TABLE_MAXNAMELEN - 1 }, +@@ -662,18 +702,13 @@ static int nf_tables_fill_table_info(struct sk_buff *skb, struct net *net, + int family, const struct nft_table *table) + { + struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; + + event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event); +- nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg), flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, event, flags, family, ++ NFNETLINK_V0, nft_base_seq(net)); ++ if (!nlh) + goto nla_put_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = family; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = htons(net->nft.base_seq & 0xffff); +- + if (nla_put_string(skb, NFTA_TABLE_NAME, table->name) || + nla_put_be32(skb, NFTA_TABLE_FLAGS, htonl(table->flags)) || + nla_put_be32(skb, NFTA_TABLE_USE, htonl(table->use)) || +@@ -710,17 +745,6 @@ static void nf_tables_table_notify(const struct nft_ctx *ctx, int event) + { + struct sk_buff *skb; + int err; +- char *buf = kasprintf(GFP_KERNEL, "%s:%llu;?:0", +- ctx->table->name, ctx->table->handle); +- +- audit_log_nfcfg(buf, +- ctx->family, +- ctx->table->use, +- event == NFT_MSG_NEWTABLE ? +- AUDIT_NFT_OP_TABLE_REGISTER : +- AUDIT_NFT_OP_TABLE_UNREGISTER, +- GFP_KERNEL); +- kfree(buf); + + if (!ctx->report && + !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES)) +@@ -1414,18 +1438,13 @@ static int nf_tables_fill_chain_info(struct sk_buff *skb, struct net *net, + const struct nft_chain *chain) + { + struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; + + event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event); +- nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg), flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, event, flags, family, ++ NFNETLINK_V0, nft_base_seq(net)); ++ if (!nlh) + goto nla_put_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = family; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = htons(net->nft.base_seq & 0xffff); +- + if (nla_put_string(skb, NFTA_CHAIN_TABLE, table->name)) + goto nla_put_failure; + if (nla_put_be64(skb, NFTA_CHAIN_HANDLE, cpu_to_be64(chain->handle), +@@ -1477,18 +1496,6 @@ static void nf_tables_chain_notify(const struct nft_ctx *ctx, int event) + { + struct sk_buff *skb; + int err; +- char *buf = kasprintf(GFP_KERNEL, "%s:%llu;%s:%llu", +- ctx->table->name, ctx->table->handle, +- ctx->chain->name, ctx->chain->handle); +- +- audit_log_nfcfg(buf, +- ctx->family, +- ctx->chain->use, +- event == NFT_MSG_NEWCHAIN ? +- AUDIT_NFT_OP_CHAIN_REGISTER : +- AUDIT_NFT_OP_CHAIN_UNREGISTER, +- GFP_KERNEL); +- kfree(buf); + + if (!ctx->report && + !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES)) +@@ -2786,20 +2793,15 @@ static int nf_tables_fill_rule_info(struct sk_buff *skb, struct net *net, + const struct nft_rule *prule) + { + struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; + const struct nft_expr *expr, *next; + struct nlattr *list; + u16 type = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event); + +- nlh = nlmsg_put(skb, portid, seq, type, sizeof(struct nfgenmsg), flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, type, flags, family, NFNETLINK_V0, ++ nft_base_seq(net)); ++ if (!nlh) + goto nla_put_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = family; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = htons(net->nft.base_seq & 0xffff); +- + if (nla_put_string(skb, NFTA_RULE_TABLE, table->name)) + goto nla_put_failure; + if (nla_put_string(skb, NFTA_RULE_CHAIN, chain->name)) +@@ -2844,18 +2846,6 @@ static void nf_tables_rule_notify(const struct nft_ctx *ctx, + { + struct sk_buff *skb; + int err; +- char *buf = kasprintf(GFP_KERNEL, "%s:%llu;%s:%llu", +- ctx->table->name, ctx->table->handle, +- ctx->chain->name, ctx->chain->handle); +- +- audit_log_nfcfg(buf, +- ctx->family, +- rule->handle, +- event == NFT_MSG_NEWRULE ? +- AUDIT_NFT_OP_RULE_REGISTER : +- AUDIT_NFT_OP_RULE_UNREGISTER, +- GFP_KERNEL); +- kfree(buf); + + if (!ctx->report && + !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES)) +@@ -3702,7 +3692,7 @@ cont: + list_for_each_entry(i, &ctx->table->sets, list) { + int tmp; + +- if (!nft_is_active_next(ctx->net, set)) ++ if (!nft_is_active_next(ctx->net, i)) + continue; + if (!sscanf(i->name, name, &tmp)) + continue; +@@ -3786,23 +3776,17 @@ static int nf_tables_fill_set_concat(struct sk_buff *skb, + static int nf_tables_fill_set(struct sk_buff *skb, const struct nft_ctx *ctx, + const struct nft_set *set, u16 event, u16 flags) + { +- struct nfgenmsg *nfmsg; + struct nlmsghdr *nlh; + u32 portid = ctx->portid; + struct nlattr *nest; + u32 seq = ctx->seq; + + event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event); +- nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg), +- flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, event, flags, ctx->family, ++ NFNETLINK_V0, nft_base_seq(ctx->net)); ++ if (!nlh) + goto nla_put_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = ctx->family; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = htons(ctx->net->nft.base_seq & 0xffff); +- + if (nla_put_string(skb, NFTA_SET_TABLE, ctx->table->name)) + goto nla_put_failure; + if (nla_put_string(skb, NFTA_SET_NAME, set->name)) +@@ -3882,18 +3866,6 @@ static void nf_tables_set_notify(const struct nft_ctx *ctx, + struct sk_buff *skb; + u32 portid = ctx->portid; + int err; +- char *buf = kasprintf(gfp_flags, "%s:%llu;%s:%llu", +- ctx->table->name, ctx->table->handle, +- set->name, set->handle); +- +- audit_log_nfcfg(buf, +- ctx->family, +- set->field_count, +- event == NFT_MSG_NEWSET ? +- AUDIT_NFT_OP_SET_REGISTER : +- AUDIT_NFT_OP_SET_UNREGISTER, +- gfp_flags); +- kfree(buf); + + if (!ctx->report && + !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES)) +@@ -4241,6 +4213,11 @@ static int nf_tables_newset(struct net *net, struct sock *nlsk, + err = nf_tables_set_desc_parse(&desc, nla[NFTA_SET_DESC]); + if (err < 0) + return err; ++ ++ if (desc.field_count > 1 && !(flags & NFT_SET_CONCAT)) ++ return -EINVAL; ++ } else if (flags & NFT_SET_CONCAT) { ++ return -EINVAL; + } + + if (nla[NFTA_SET_EXPR]) +@@ -4717,7 +4694,6 @@ static int nf_tables_dump_set(struct sk_buff *skb, struct netlink_callback *cb) + struct nft_set *set; + struct nft_set_dump_args args; + bool set_found = false; +- struct nfgenmsg *nfmsg; + struct nlmsghdr *nlh; + struct nlattr *nest; + u32 portid, seq; +@@ -4750,16 +4726,11 @@ static int nf_tables_dump_set(struct sk_buff *skb, struct netlink_callback *cb) + portid = NETLINK_CB(cb->skb).portid; + seq = cb->nlh->nlmsg_seq; + +- nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg), +- NLM_F_MULTI); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, event, NLM_F_MULTI, ++ table->family, NFNETLINK_V0, nft_base_seq(net)); ++ if (!nlh) + goto nla_put_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = table->family; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = htons(net->nft.base_seq & 0xffff); +- + if (nla_put_string(skb, NFTA_SET_ELEM_LIST_TABLE, table->name)) + goto nla_put_failure; + if (nla_put_string(skb, NFTA_SET_ELEM_LIST_SET, set->name)) +@@ -4816,22 +4787,16 @@ static int nf_tables_fill_setelem_info(struct sk_buff *skb, + const struct nft_set *set, + const struct nft_set_elem *elem) + { +- struct nfgenmsg *nfmsg; + struct nlmsghdr *nlh; + struct nlattr *nest; + int err; + + event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event); +- nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg), +- flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, event, flags, ctx->family, ++ NFNETLINK_V0, nft_base_seq(ctx->net)); ++ if (!nlh) + goto nla_put_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = ctx->family; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = htons(ctx->net->nft.base_seq & 0xffff); +- + if (nla_put_string(skb, NFTA_SET_TABLE, ctx->table->name)) + goto nla_put_failure; + if (nla_put_string(skb, NFTA_SET_NAME, set->name)) +@@ -5030,18 +4995,6 @@ static void nf_tables_setelem_notify(const struct nft_ctx *ctx, + u32 portid = ctx->portid; + struct sk_buff *skb; + int err; +- char *buf = kasprintf(GFP_KERNEL, "%s:%llu;%s:%llu", +- ctx->table->name, ctx->table->handle, +- set->name, set->handle); +- +- audit_log_nfcfg(buf, +- ctx->family, +- set->handle, +- event == NFT_MSG_NEWSETELEM ? +- AUDIT_NFT_OP_SETELEM_REGISTER : +- AUDIT_NFT_OP_SETELEM_UNREGISTER, +- GFP_KERNEL); +- kfree(buf); + + if (!ctx->report && !nfnetlink_has_listeners(net, NFNLGRP_NFTABLES)) + return; +@@ -5245,6 +5198,15 @@ static int nft_add_set_elem(struct nft_ctx *ctx, struct nft_set *set, + return -EINVAL; + } + ++ if (set->flags & NFT_SET_OBJECT) { ++ if (!nla[NFTA_SET_ELEM_OBJREF] && ++ !(flags & NFT_SET_ELEM_INTERVAL_END)) ++ return -EINVAL; ++ } else { ++ if (nla[NFTA_SET_ELEM_OBJREF]) ++ return -EINVAL; ++ } ++ + if ((flags & NFT_SET_ELEM_INTERVAL_END) && + (nla[NFTA_SET_ELEM_DATA] || + nla[NFTA_SET_ELEM_OBJREF] || +@@ -5322,10 +5284,6 @@ static int nft_add_set_elem(struct nft_ctx *ctx, struct nft_set *set, + expr->ops->size); + + if (nla[NFTA_SET_ELEM_OBJREF] != NULL) { +- if (!(set->flags & NFT_SET_OBJECT)) { +- err = -EINVAL; +- goto err_parse_key_end; +- } + obj = nft_obj_lookup(ctx->net, ctx->table, + nla[NFTA_SET_ELEM_OBJREF], + set->objtype, genmask); +@@ -6095,19 +6053,14 @@ static int nf_tables_fill_obj_info(struct sk_buff *skb, struct net *net, + int family, const struct nft_table *table, + struct nft_object *obj, bool reset) + { +- struct nfgenmsg *nfmsg; + struct nlmsghdr *nlh; + + event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event); +- nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg), flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, event, flags, family, ++ NFNETLINK_V0, nft_base_seq(net)); ++ if (!nlh) + goto nla_put_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = family; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = htons(net->nft.base_seq & 0xffff); +- + if (nla_put_string(skb, NFTA_OBJ_TABLE, table->name) || + nla_put_string(skb, NFTA_OBJ_NAME, obj->key.name) || + nla_put_be32(skb, NFTA_OBJ_TYPE, htonl(obj->ops->type->type)) || +@@ -6170,12 +6123,11 @@ static int nf_tables_dump_obj(struct sk_buff *skb, struct netlink_callback *cb) + filter->type != NFT_OBJECT_UNSPEC && + obj->ops->type->type != filter->type) + goto cont; +- + if (reset) { + char *buf = kasprintf(GFP_ATOMIC, +- "%s:%llu;?:0", ++ "%s:%u", + table->name, +- table->handle); ++ net->nft.base_seq); + + audit_log_nfcfg(buf, + family, +@@ -6296,8 +6248,8 @@ static int nf_tables_getobj(struct net *net, struct sock *nlsk, + reset = true; + + if (reset) { +- char *buf = kasprintf(GFP_ATOMIC, "%s:%llu;?:0", +- table->name, table->handle); ++ char *buf = kasprintf(GFP_ATOMIC, "%s:%u", ++ table->name, net->nft.base_seq); + + audit_log_nfcfg(buf, + family, +@@ -6384,15 +6336,15 @@ void nft_obj_notify(struct net *net, const struct nft_table *table, + { + struct sk_buff *skb; + int err; +- char *buf = kasprintf(gfp, "%s:%llu;?:0", +- table->name, table->handle); ++ char *buf = kasprintf(gfp, "%s:%u", ++ table->name, net->nft.base_seq); + + audit_log_nfcfg(buf, + family, + obj->handle, + event == NFT_MSG_NEWOBJ ? +- AUDIT_NFT_OP_OBJ_REGISTER : +- AUDIT_NFT_OP_OBJ_UNREGISTER, ++ AUDIT_NFT_OP_OBJ_REGISTER : ++ AUDIT_NFT_OP_OBJ_UNREGISTER, + gfp); + kfree(buf); + +@@ -7007,20 +6959,15 @@ static int nf_tables_fill_flowtable_info(struct sk_buff *skb, struct net *net, + struct list_head *hook_list) + { + struct nlattr *nest, *nest_devs; +- struct nfgenmsg *nfmsg; + struct nft_hook *hook; + struct nlmsghdr *nlh; + + event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event); +- nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg), flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, event, flags, family, ++ NFNETLINK_V0, nft_base_seq(net)); ++ if (!nlh) + goto nla_put_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = family; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = htons(net->nft.base_seq & 0xffff); +- + if (nla_put_string(skb, NFTA_FLOWTABLE_TABLE, flowtable->table->name) || + nla_put_string(skb, NFTA_FLOWTABLE_NAME, flowtable->name) || + nla_put_be32(skb, NFTA_FLOWTABLE_USE, htonl(flowtable->use)) || +@@ -7210,18 +7157,6 @@ static void nf_tables_flowtable_notify(struct nft_ctx *ctx, + { + struct sk_buff *skb; + int err; +- char *buf = kasprintf(GFP_KERNEL, "%s:%llu;%s:%llu", +- flowtable->table->name, flowtable->table->handle, +- flowtable->name, flowtable->handle); +- +- audit_log_nfcfg(buf, +- ctx->family, +- flowtable->hooknum, +- event == NFT_MSG_NEWFLOWTABLE ? +- AUDIT_NFT_OP_FLOWTABLE_REGISTER : +- AUDIT_NFT_OP_FLOWTABLE_UNREGISTER, +- GFP_KERNEL); +- kfree(buf); + + if (!ctx->report && + !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES)) +@@ -7265,19 +7200,14 @@ static int nf_tables_fill_gen_info(struct sk_buff *skb, struct net *net, + u32 portid, u32 seq) + { + struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; + char buf[TASK_COMM_LEN]; + int event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, NFT_MSG_NEWGEN); + +- nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg), 0); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, event, 0, AF_UNSPEC, ++ NFNETLINK_V0, nft_base_seq(net)); ++ if (!nlh) + goto nla_put_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = AF_UNSPEC; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = htons(net->nft.base_seq & 0xffff); +- + if (nla_put_be32(skb, NFTA_GEN_ID, htonl(net->nft.base_seq)) || + nla_put_be32(skb, NFTA_GEN_PROC_PID, htonl(task_pid_nr(current))) || + nla_put_string(skb, NFTA_GEN_PROC_NAME, get_task_comm(buf, current))) +@@ -7342,9 +7272,6 @@ static void nf_tables_gen_notify(struct net *net, struct sk_buff *skb, + struct sk_buff *skb2; + int err; + +- audit_log_nfcfg("?:0;?:0", 0, net->nft.base_seq, +- AUDIT_NFT_OP_GEN_REGISTER, GFP_KERNEL); +- + if (!nlmsg_report(nlh) && + !nfnetlink_has_listeners(net, NFNLGRP_NFTABLES)) + return; +@@ -7875,12 +7802,74 @@ new_batch: + WARN_ON_ONCE(!list_empty(&net->nft.notify_list)); + } + ++static int nf_tables_commit_audit_alloc(struct list_head *adl, ++ struct nft_table *table) ++{ ++ struct nft_audit_data *adp; ++ ++ list_for_each_entry(adp, adl, list) { ++ if (adp->table == table) ++ return 0; ++ } ++ adp = kzalloc(sizeof(*adp), GFP_KERNEL); ++ if (!adp) ++ return -ENOMEM; ++ adp->table = table; ++ list_add(&adp->list, adl); ++ return 0; ++} ++ ++static void nf_tables_commit_audit_free(struct list_head *adl) ++{ ++ struct nft_audit_data *adp, *adn; ++ ++ list_for_each_entry_safe(adp, adn, adl, list) { ++ list_del(&adp->list); ++ kfree(adp); ++ } ++} ++ ++static void nf_tables_commit_audit_collect(struct list_head *adl, ++ struct nft_table *table, u32 op) ++{ ++ struct nft_audit_data *adp; ++ ++ list_for_each_entry(adp, adl, list) { ++ if (adp->table == table) ++ goto found; ++ } ++ WARN_ONCE(1, "table=%s not expected in commit list", table->name); ++ return; ++found: ++ adp->entries++; ++ if (!adp->op || adp->op > op) ++ adp->op = op; ++} ++ ++#define AUNFTABLENAMELEN (NFT_TABLE_MAXNAMELEN + 22) ++ ++static void nf_tables_commit_audit_log(struct list_head *adl, u32 generation) ++{ ++ struct nft_audit_data *adp, *adn; ++ char aubuf[AUNFTABLENAMELEN]; ++ ++ list_for_each_entry_safe(adp, adn, adl, list) { ++ snprintf(aubuf, AUNFTABLENAMELEN, "%s:%u", adp->table->name, ++ generation); ++ audit_log_nfcfg(aubuf, adp->table->family, adp->entries, ++ nft2audit_op[adp->op], GFP_KERNEL); ++ list_del(&adp->list); ++ kfree(adp); ++ } ++} ++ + static int nf_tables_commit(struct net *net, struct sk_buff *skb) + { + struct nft_trans *trans, *next; + struct nft_trans_elem *te; + struct nft_chain *chain; + struct nft_table *table; ++ LIST_HEAD(adl); + int err; + + if (list_empty(&net->nft.commit_list)) { +@@ -7900,6 +7889,12 @@ static int nf_tables_commit(struct net *net, struct sk_buff *skb) + list_for_each_entry_safe(trans, next, &net->nft.commit_list, list) { + int ret; + ++ ret = nf_tables_commit_audit_alloc(&adl, trans->ctx.table); ++ if (ret) { ++ nf_tables_commit_chain_prepare_cancel(net); ++ nf_tables_commit_audit_free(&adl); ++ return ret; ++ } + if (trans->msg_type == NFT_MSG_NEWRULE || + trans->msg_type == NFT_MSG_DELRULE) { + chain = trans->ctx.chain; +@@ -7907,6 +7902,7 @@ static int nf_tables_commit(struct net *net, struct sk_buff *skb) + ret = nf_tables_commit_chain_prepare(net, chain); + if (ret < 0) { + nf_tables_commit_chain_prepare_cancel(net); ++ nf_tables_commit_audit_free(&adl); + return ret; + } + } +@@ -7928,6 +7924,8 @@ static int nf_tables_commit(struct net *net, struct sk_buff *skb) + net->nft.gencursor = nft_gencursor_next(net); + + list_for_each_entry_safe(trans, next, &net->nft.commit_list, list) { ++ nf_tables_commit_audit_collect(&adl, trans->ctx.table, ++ trans->msg_type); + switch (trans->msg_type) { + case NFT_MSG_NEWTABLE: + if (nft_trans_table_update(trans)) { +@@ -8082,6 +8080,7 @@ static int nf_tables_commit(struct net *net, struct sk_buff *skb) + + nft_commit_notify(net, NETLINK_CB(skb).portid); + nf_tables_gen_notify(net, skb, NFT_MSG_NEWGEN); ++ nf_tables_commit_audit_log(&adl, net->nft.base_seq); + nf_tables_commit_release(net); + + return 0; +diff --git a/net/netfilter/nf_tables_trace.c b/net/netfilter/nf_tables_trace.c +index 87b36da5cd985..0cf3278007ba5 100644 +--- a/net/netfilter/nf_tables_trace.c ++++ b/net/netfilter/nf_tables_trace.c +@@ -183,7 +183,6 @@ static bool nft_trace_have_verdict_chain(struct nft_traceinfo *info) + void nft_trace_notify(struct nft_traceinfo *info) + { + const struct nft_pktinfo *pkt = info->pkt; +- struct nfgenmsg *nfmsg; + struct nlmsghdr *nlh; + struct sk_buff *skb; + unsigned int size; +@@ -219,15 +218,11 @@ void nft_trace_notify(struct nft_traceinfo *info) + return; + + event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, NFT_MSG_TRACE); +- nlh = nlmsg_put(skb, 0, 0, event, sizeof(struct nfgenmsg), 0); ++ nlh = nfnl_msg_put(skb, 0, 0, event, 0, info->basechain->type->family, ++ NFNETLINK_V0, 0); + if (!nlh) + goto nla_put_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = info->basechain->type->family; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = 0; +- + if (nla_put_be32(skb, NFTA_TRACE_NFPROTO, htonl(nft_pf(pkt)))) + goto nla_put_failure; + +diff --git a/net/netfilter/nfnetlink_acct.c b/net/netfilter/nfnetlink_acct.c +index 5bfec829c12f3..ec3e378da73d1 100644 +--- a/net/netfilter/nfnetlink_acct.c ++++ b/net/netfilter/nfnetlink_acct.c +@@ -132,21 +132,16 @@ nfnl_acct_fill_info(struct sk_buff *skb, u32 portid, u32 seq, u32 type, + int event, struct nf_acct *acct) + { + struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; + unsigned int flags = portid ? NLM_F_MULTI : 0; + u64 pkts, bytes; + u32 old_flags; + + event = nfnl_msg_type(NFNL_SUBSYS_ACCT, event); +- nlh = nlmsg_put(skb, portid, seq, event, sizeof(*nfmsg), flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, event, flags, AF_UNSPEC, ++ NFNETLINK_V0, 0); ++ if (!nlh) + goto nlmsg_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = AF_UNSPEC; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = 0; +- + if (nla_put_string(skb, NFACCT_NAME, acct->name)) + goto nla_put_failure; + +diff --git a/net/netfilter/nfnetlink_cthelper.c b/net/netfilter/nfnetlink_cthelper.c +index 91afbf8ac8cf0..52d5f24118342 100644 +--- a/net/netfilter/nfnetlink_cthelper.c ++++ b/net/netfilter/nfnetlink_cthelper.c +@@ -530,20 +530,15 @@ nfnl_cthelper_fill_info(struct sk_buff *skb, u32 portid, u32 seq, u32 type, + int event, struct nf_conntrack_helper *helper) + { + struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; + unsigned int flags = portid ? NLM_F_MULTI : 0; + int status; + + event = nfnl_msg_type(NFNL_SUBSYS_CTHELPER, event); +- nlh = nlmsg_put(skb, portid, seq, event, sizeof(*nfmsg), flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, event, flags, AF_UNSPEC, ++ NFNETLINK_V0, 0); ++ if (!nlh) + goto nlmsg_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = AF_UNSPEC; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = 0; +- + if (nla_put_string(skb, NFCTH_NAME, helper->name)) + goto nla_put_failure; + +diff --git a/net/netfilter/nfnetlink_cttimeout.c b/net/netfilter/nfnetlink_cttimeout.c +index 89a381f7f9459..de831a2575129 100644 +--- a/net/netfilter/nfnetlink_cttimeout.c ++++ b/net/netfilter/nfnetlink_cttimeout.c +@@ -160,22 +160,17 @@ ctnl_timeout_fill_info(struct sk_buff *skb, u32 portid, u32 seq, u32 type, + int event, struct ctnl_timeout *timeout) + { + struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; + unsigned int flags = portid ? NLM_F_MULTI : 0; + const struct nf_conntrack_l4proto *l4proto = timeout->timeout.l4proto; + struct nlattr *nest_parms; + int ret; + + event = nfnl_msg_type(NFNL_SUBSYS_CTNETLINK_TIMEOUT, event); +- nlh = nlmsg_put(skb, portid, seq, event, sizeof(*nfmsg), flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, event, flags, AF_UNSPEC, ++ NFNETLINK_V0, 0); ++ if (!nlh) + goto nlmsg_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = AF_UNSPEC; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = 0; +- + if (nla_put_string(skb, CTA_TIMEOUT_NAME, timeout->name) || + nla_put_be16(skb, CTA_TIMEOUT_L3PROTO, + htons(timeout->timeout.l3num)) || +@@ -382,21 +377,16 @@ cttimeout_default_fill_info(struct net *net, struct sk_buff *skb, u32 portid, + const unsigned int *timeouts) + { + struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; + unsigned int flags = portid ? NLM_F_MULTI : 0; + struct nlattr *nest_parms; + int ret; + + event = nfnl_msg_type(NFNL_SUBSYS_CTNETLINK_TIMEOUT, event); +- nlh = nlmsg_put(skb, portid, seq, event, sizeof(*nfmsg), flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, event, flags, AF_UNSPEC, ++ NFNETLINK_V0, 0); ++ if (!nlh) + goto nlmsg_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = AF_UNSPEC; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = 0; +- + if (nla_put_be16(skb, CTA_TIMEOUT_L3PROTO, htons(l3num)) || + nla_put_u8(skb, CTA_TIMEOUT_L4PROTO, l4proto->l4proto)) + goto nla_put_failure; +diff --git a/net/netfilter/nfnetlink_log.c b/net/netfilter/nfnetlink_log.c +index 33c13edbca4bb..f087baa95b07b 100644 +--- a/net/netfilter/nfnetlink_log.c ++++ b/net/netfilter/nfnetlink_log.c +@@ -452,20 +452,15 @@ __build_packet_message(struct nfnl_log_net *log, + { + struct nfulnl_msg_packet_hdr pmsg; + struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; + sk_buff_data_t old_tail = inst->skb->tail; + struct sock *sk; + const unsigned char *hwhdrp; + +- nlh = nlmsg_put(inst->skb, 0, 0, +- nfnl_msg_type(NFNL_SUBSYS_ULOG, NFULNL_MSG_PACKET), +- sizeof(struct nfgenmsg), 0); ++ nlh = nfnl_msg_put(inst->skb, 0, 0, ++ nfnl_msg_type(NFNL_SUBSYS_ULOG, NFULNL_MSG_PACKET), ++ 0, pf, NFNETLINK_V0, htons(inst->group_num)); + if (!nlh) + return -1; +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = pf; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = htons(inst->group_num); + + memset(&pmsg, 0, sizeof(pmsg)); + pmsg.hw_protocol = skb->protocol; +diff --git a/net/netfilter/nfnetlink_queue.c b/net/netfilter/nfnetlink_queue.c +index 72d30922ed290..9d87606c76ff4 100644 +--- a/net/netfilter/nfnetlink_queue.c ++++ b/net/netfilter/nfnetlink_queue.c +@@ -383,7 +383,6 @@ nfqnl_build_packet_message(struct net *net, struct nfqnl_instance *queue, + struct nlattr *nla; + struct nfqnl_msg_packet_hdr *pmsg; + struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; + struct sk_buff *entskb = entry->skb; + struct net_device *indev; + struct net_device *outdev; +@@ -469,18 +468,15 @@ nfqnl_build_packet_message(struct net *net, struct nfqnl_instance *queue, + goto nlmsg_failure; + } + +- nlh = nlmsg_put(skb, 0, 0, +- nfnl_msg_type(NFNL_SUBSYS_QUEUE, NFQNL_MSG_PACKET), +- sizeof(struct nfgenmsg), 0); ++ nlh = nfnl_msg_put(skb, 0, 0, ++ nfnl_msg_type(NFNL_SUBSYS_QUEUE, NFQNL_MSG_PACKET), ++ 0, entry->state.pf, NFNETLINK_V0, ++ htons(queue->queue_num)); + if (!nlh) { + skb_tx_error(entskb); + kfree_skb(skb); + goto nlmsg_failure; + } +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = entry->state.pf; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = htons(queue->queue_num); + + nla = __nla_reserve(skb, NFQA_PACKET_HDR, sizeof(*pmsg)); + pmsg = nla_data(nla); +diff --git a/net/netfilter/nft_compat.c b/net/netfilter/nft_compat.c +index 8e56f353ff351..b8dbd20a6a4c5 100644 +--- a/net/netfilter/nft_compat.c ++++ b/net/netfilter/nft_compat.c +@@ -591,19 +591,14 @@ nfnl_compat_fill_info(struct sk_buff *skb, u32 portid, u32 seq, u32 type, + int rev, int target) + { + struct nlmsghdr *nlh; +- struct nfgenmsg *nfmsg; + unsigned int flags = portid ? NLM_F_MULTI : 0; + + event = nfnl_msg_type(NFNL_SUBSYS_NFT_COMPAT, event); +- nlh = nlmsg_put(skb, portid, seq, event, sizeof(*nfmsg), flags); +- if (nlh == NULL) ++ nlh = nfnl_msg_put(skb, portid, seq, event, flags, family, ++ NFNETLINK_V0, 0); ++ if (!nlh) + goto nlmsg_failure; + +- nfmsg = nlmsg_data(nlh); +- nfmsg->nfgen_family = family; +- nfmsg->version = NFNETLINK_V0; +- nfmsg->res_id = 0; +- + if (nla_put_string(skb, NFTA_COMPAT_NAME, name) || + nla_put_be32(skb, NFTA_COMPAT_REV, htonl(rev)) || + nla_put_be32(skb, NFTA_COMPAT_TYPE, htonl(target))) +diff --git a/net/netlink/genetlink.c b/net/netlink/genetlink.c +index c992424e4d632..9fd7ba01b9f8b 100644 +--- a/net/netlink/genetlink.c ++++ b/net/netlink/genetlink.c +@@ -1182,13 +1182,17 @@ static int ctrl_dumppolicy_start(struct netlink_callback *cb) + op.policy, + op.maxattr); + if (err) +- return err; ++ goto err_free_state; + } + } + + if (!ctx->state) + return -ENODATA; + return 0; ++ ++err_free_state: ++ netlink_policy_dump_free(ctx->state); ++ return err; + } + + static void *ctrl_dumppolicy_prep(struct sk_buff *skb, +diff --git a/net/netlink/policy.c b/net/netlink/policy.c +index 8d7c900e27f4c..87e3de0fde896 100644 +--- a/net/netlink/policy.c ++++ b/net/netlink/policy.c +@@ -144,7 +144,7 @@ int netlink_policy_dump_add_policy(struct netlink_policy_dump_state **pstate, + + err = add_policy(&state, policy, maxtype); + if (err) +- return err; ++ goto err_try_undo; + + for (policy_idx = 0; + policy_idx < state->n_alloc && state->policies[policy_idx].policy; +@@ -164,7 +164,7 @@ int netlink_policy_dump_add_policy(struct netlink_policy_dump_state **pstate, + policy[type].nested_policy, + policy[type].len); + if (err) +- return err; ++ goto err_try_undo; + break; + default: + break; +@@ -174,6 +174,16 @@ int netlink_policy_dump_add_policy(struct netlink_policy_dump_state **pstate, + + *pstate = state; + return 0; ++ ++err_try_undo: ++ /* Try to preserve reasonable unwind semantics - if we're starting from ++ * scratch clean up fully, otherwise record what we got and caller will. ++ */ ++ if (!*pstate) ++ netlink_policy_dump_free(state); ++ else ++ *pstate = state; ++ return err; + } + + static bool +diff --git a/net/qrtr/qrtr.c b/net/qrtr/qrtr.c +index 56cffbfa000b7..13448ca5aeff2 100644 +--- a/net/qrtr/qrtr.c ++++ b/net/qrtr/qrtr.c +@@ -20,6 +20,8 @@ + /* auto-bind range */ + #define QRTR_MIN_EPH_SOCKET 0x4000 + #define QRTR_MAX_EPH_SOCKET 0x7fff ++#define QRTR_EPH_PORT_RANGE \ ++ XA_LIMIT(QRTR_MIN_EPH_SOCKET, QRTR_MAX_EPH_SOCKET) + + /** + * struct qrtr_hdr_v1 - (I|R)PCrouter packet header version 1 +@@ -106,8 +108,7 @@ static LIST_HEAD(qrtr_all_nodes); + static DEFINE_MUTEX(qrtr_node_lock); + + /* local port allocation management */ +-static DEFINE_IDR(qrtr_ports); +-static DEFINE_MUTEX(qrtr_port_lock); ++static DEFINE_XARRAY_ALLOC(qrtr_ports); + + /** + * struct qrtr_node - endpoint node +@@ -635,7 +636,7 @@ static struct qrtr_sock *qrtr_port_lookup(int port) + port = 0; + + rcu_read_lock(); +- ipc = idr_find(&qrtr_ports, port); ++ ipc = xa_load(&qrtr_ports, port); + if (ipc) + sock_hold(&ipc->sk); + rcu_read_unlock(); +@@ -677,9 +678,7 @@ static void qrtr_port_remove(struct qrtr_sock *ipc) + + __sock_put(&ipc->sk); + +- mutex_lock(&qrtr_port_lock); +- idr_remove(&qrtr_ports, port); +- mutex_unlock(&qrtr_port_lock); ++ xa_erase(&qrtr_ports, port); + + /* Ensure that if qrtr_port_lookup() did enter the RCU read section we + * wait for it to up increment the refcount */ +@@ -698,29 +697,20 @@ static void qrtr_port_remove(struct qrtr_sock *ipc) + */ + static int qrtr_port_assign(struct qrtr_sock *ipc, int *port) + { +- u32 min_port; + int rc; + +- mutex_lock(&qrtr_port_lock); + if (!*port) { +- min_port = QRTR_MIN_EPH_SOCKET; +- rc = idr_alloc_u32(&qrtr_ports, ipc, &min_port, QRTR_MAX_EPH_SOCKET, GFP_ATOMIC); +- if (!rc) +- *port = min_port; ++ rc = xa_alloc(&qrtr_ports, port, ipc, QRTR_EPH_PORT_RANGE, ++ GFP_KERNEL); + } else if (*port < QRTR_MIN_EPH_SOCKET && !capable(CAP_NET_ADMIN)) { + rc = -EACCES; + } else if (*port == QRTR_PORT_CTRL) { +- min_port = 0; +- rc = idr_alloc_u32(&qrtr_ports, ipc, &min_port, 0, GFP_ATOMIC); ++ rc = xa_insert(&qrtr_ports, 0, ipc, GFP_KERNEL); + } else { +- min_port = *port; +- rc = idr_alloc_u32(&qrtr_ports, ipc, &min_port, *port, GFP_ATOMIC); +- if (!rc) +- *port = min_port; ++ rc = xa_insert(&qrtr_ports, *port, ipc, GFP_KERNEL); + } +- mutex_unlock(&qrtr_port_lock); + +- if (rc == -ENOSPC) ++ if (rc == -EBUSY) + return -EADDRINUSE; + else if (rc < 0) + return rc; +@@ -734,20 +724,16 @@ static int qrtr_port_assign(struct qrtr_sock *ipc, int *port) + static void qrtr_reset_ports(void) + { + struct qrtr_sock *ipc; +- int id; +- +- mutex_lock(&qrtr_port_lock); +- idr_for_each_entry(&qrtr_ports, ipc, id) { +- /* Don't reset control port */ +- if (id == 0) +- continue; ++ unsigned long index; + ++ rcu_read_lock(); ++ xa_for_each_start(&qrtr_ports, index, ipc, 1) { + sock_hold(&ipc->sk); + ipc->sk.sk_err = ENETRESET; + ipc->sk.sk_error_report(&ipc->sk); + sock_put(&ipc->sk); + } +- mutex_unlock(&qrtr_port_lock); ++ rcu_read_unlock(); + } + + /* Bind socket to address. +diff --git a/net/rds/ib_recv.c b/net/rds/ib_recv.c +index 6fdedd9dbbc28..cfbf0e129cba5 100644 +--- a/net/rds/ib_recv.c ++++ b/net/rds/ib_recv.c +@@ -363,6 +363,7 @@ static int acquire_refill(struct rds_connection *conn) + static void release_refill(struct rds_connection *conn) + { + clear_bit(RDS_RECV_REFILL, &conn->c_flags); ++ smp_mb__after_atomic(); + + /* We don't use wait_on_bit()/wake_up_bit() because our waking is in a + * hot path and finding waiters is very rare. We don't want to walk +diff --git a/net/sunrpc/auth.c b/net/sunrpc/auth.c +index a9f0d17fdb0d6..1bae32c482846 100644 +--- a/net/sunrpc/auth.c ++++ b/net/sunrpc/auth.c +@@ -445,7 +445,7 @@ rpcauth_prune_expired(struct list_head *free, int nr_to_scan) + * Enforce a 60 second garbage collection moratorium + * Note that the cred_unused list must be time-ordered. + */ +- if (!time_in_range(cred->cr_expire, expired, jiffies)) ++ if (time_in_range(cred->cr_expire, expired, jiffies)) + continue; + if (!rpcauth_unhash_cred(cred)) + continue; +diff --git a/net/sunrpc/backchannel_rqst.c b/net/sunrpc/backchannel_rqst.c +index 22a2c235abf1b..77e347a45344c 100644 +--- a/net/sunrpc/backchannel_rqst.c ++++ b/net/sunrpc/backchannel_rqst.c +@@ -64,6 +64,17 @@ static void xprt_free_allocation(struct rpc_rqst *req) + kfree(req); + } + ++static void xprt_bc_reinit_xdr_buf(struct xdr_buf *buf) ++{ ++ buf->head[0].iov_len = PAGE_SIZE; ++ buf->tail[0].iov_len = 0; ++ buf->pages = NULL; ++ buf->page_len = 0; ++ buf->flags = 0; ++ buf->len = 0; ++ buf->buflen = PAGE_SIZE; ++} ++ + static int xprt_alloc_xdr_buf(struct xdr_buf *buf, gfp_t gfp_flags) + { + struct page *page; +@@ -292,6 +303,9 @@ void xprt_free_bc_rqst(struct rpc_rqst *req) + */ + spin_lock_bh(&xprt->bc_pa_lock); + if (xprt_need_to_requeue(xprt)) { ++ xprt_bc_reinit_xdr_buf(&req->rq_snd_buf); ++ xprt_bc_reinit_xdr_buf(&req->rq_rcv_buf); ++ req->rq_rcv_buf.len = PAGE_SIZE; + list_add_tail(&req->rq_bc_pa_list, &xprt->bc_pa_list); + xprt->bc_alloc_count++; + atomic_inc(&xprt->bc_slot_count); +diff --git a/net/vmw_vsock/af_vsock.c b/net/vmw_vsock/af_vsock.c +index c59806253a65a..7829a5018ef9f 100644 +--- a/net/vmw_vsock/af_vsock.c ++++ b/net/vmw_vsock/af_vsock.c +@@ -1242,6 +1242,7 @@ static void vsock_connect_timeout(struct work_struct *work) + if (sk->sk_state == TCP_SYN_SENT && + (sk->sk_shutdown != SHUTDOWN_MASK)) { + sk->sk_state = TCP_CLOSE; ++ sk->sk_socket->state = SS_UNCONNECTED; + sk->sk_err = ETIMEDOUT; + sk->sk_error_report(sk); + vsock_transport_cancel_pkt(vsk); +@@ -1347,7 +1348,14 @@ static int vsock_stream_connect(struct socket *sock, struct sockaddr *addr, + * timeout fires. + */ + sock_hold(sk); +- schedule_delayed_work(&vsk->connect_work, timeout); ++ ++ /* If the timeout function is already scheduled, ++ * reschedule it, then ungrab the socket refcount to ++ * keep it balanced. ++ */ ++ if (mod_delayed_work(system_wq, &vsk->connect_work, ++ timeout)) ++ sock_put(sk); + + /* Skip ahead to preserve error code set above. */ + goto out_wait; +diff --git a/scripts/Makefile.gcc-plugins b/scripts/Makefile.gcc-plugins +index 4aad284800355..36814be80264a 100644 +--- a/scripts/Makefile.gcc-plugins ++++ b/scripts/Makefile.gcc-plugins +@@ -6,7 +6,7 @@ gcc-plugin-$(CONFIG_GCC_PLUGIN_LATENT_ENTROPY) += latent_entropy_plugin.so + gcc-plugin-cflags-$(CONFIG_GCC_PLUGIN_LATENT_ENTROPY) \ + += -DLATENT_ENTROPY_PLUGIN + ifdef CONFIG_GCC_PLUGIN_LATENT_ENTROPY +- DISABLE_LATENT_ENTROPY_PLUGIN += -fplugin-arg-latent_entropy_plugin-disable ++ DISABLE_LATENT_ENTROPY_PLUGIN += -fplugin-arg-latent_entropy_plugin-disable -ULATENT_ENTROPY_PLUGIN + endif + export DISABLE_LATENT_ENTROPY_PLUGIN + +diff --git a/scripts/dummy-tools/gcc b/scripts/dummy-tools/gcc +index 0d0589cf8184e..346757a87dbc8 100755 +--- a/scripts/dummy-tools/gcc ++++ b/scripts/dummy-tools/gcc +@@ -77,12 +77,8 @@ fi + + # To set GCC_PLUGINS + if arg_contain -print-file-name=plugin "$@"; then +- plugin_dir=$(mktemp -d) +- +- mkdir -p $plugin_dir/include +- touch $plugin_dir/include/plugin-version.h +- +- echo $plugin_dir ++ # Use $0 to find the in-tree dummy directory ++ echo "$(dirname "$(readlink -f "$0")")/dummy-plugin-dir" + exit 0 + fi + +diff --git a/scripts/module.lds.S b/scripts/module.lds.S +index c5f12195817bb..2c510db6c2ed6 100644 +--- a/scripts/module.lds.S ++++ b/scripts/module.lds.S +@@ -22,6 +22,8 @@ SECTIONS { + + .init_array 0 : ALIGN(8) { *(SORT(.init_array.*)) *(.init_array) } + ++ .altinstructions 0 : ALIGN(8) { KEEP(*(.altinstructions)) } ++ __bug_table 0 : ALIGN(8) { KEEP(*(__bug_table)) } + __jump_table 0 : ALIGN(8) { KEEP(*(__jump_table)) } + + __patchable_function_entries : { *(__patchable_function_entries) } +diff --git a/security/apparmor/apparmorfs.c b/security/apparmor/apparmorfs.c +index 5fd4a64e431f6..c173f6fd7aeed 100644 +--- a/security/apparmor/apparmorfs.c ++++ b/security/apparmor/apparmorfs.c +@@ -401,7 +401,7 @@ static struct aa_loaddata *aa_simple_write_to_buffer(const char __user *userbuf, + + data->size = copy_size; + if (copy_from_user(data->data, userbuf, copy_size)) { +- kvfree(data); ++ aa_put_loaddata(data); + return ERR_PTR(-EFAULT); + } + +diff --git a/security/apparmor/audit.c b/security/apparmor/audit.c +index f7e97c7e80f3d..704b0c895605a 100644 +--- a/security/apparmor/audit.c ++++ b/security/apparmor/audit.c +@@ -137,7 +137,7 @@ int aa_audit(int type, struct aa_profile *profile, struct common_audit_data *sa, + } + if (AUDIT_MODE(profile) == AUDIT_QUIET || + (type == AUDIT_APPARMOR_DENIED && +- AUDIT_MODE(profile) == AUDIT_QUIET)) ++ AUDIT_MODE(profile) == AUDIT_QUIET_DENIED)) + return aad(sa)->error; + + if (KILL_MODE(profile) && type == AUDIT_APPARMOR_DENIED) +diff --git a/security/apparmor/domain.c b/security/apparmor/domain.c +index f919ebd042fd2..87a9e6fd7908d 100644 +--- a/security/apparmor/domain.c ++++ b/security/apparmor/domain.c +@@ -465,7 +465,7 @@ restart: + * xattrs, or a longer match + */ + candidate = profile; +- candidate_len = profile->xmatch_len; ++ candidate_len = max(count, profile->xmatch_len); + candidate_xattrs = ret; + conflict = false; + } +diff --git a/security/apparmor/include/lib.h b/security/apparmor/include/lib.h +index 7d27db740bc2f..ac5054899f6f4 100644 +--- a/security/apparmor/include/lib.h ++++ b/security/apparmor/include/lib.h +@@ -22,6 +22,11 @@ + */ + + #define DEBUG_ON (aa_g_debug) ++/* ++ * split individual debug cases out in preparation for finer grained ++ * debug controls in the future. ++ */ ++#define AA_DEBUG_LABEL DEBUG_ON + #define dbg_printk(__fmt, __args...) pr_debug(__fmt, ##__args) + #define AA_DEBUG(fmt, args...) \ + do { \ +diff --git a/security/apparmor/include/policy.h b/security/apparmor/include/policy.h +index b5b4b8190e654..b5aa4231af682 100644 +--- a/security/apparmor/include/policy.h ++++ b/security/apparmor/include/policy.h +@@ -135,7 +135,7 @@ struct aa_profile { + + const char *attach; + struct aa_dfa *xmatch; +- int xmatch_len; ++ unsigned int xmatch_len; + enum audit_mode audit; + long mode; + u32 path_flags; +diff --git a/security/apparmor/label.c b/security/apparmor/label.c +index 6222fdfebe4e5..66bc4704f8044 100644 +--- a/security/apparmor/label.c ++++ b/security/apparmor/label.c +@@ -1632,9 +1632,9 @@ int aa_label_snxprint(char *str, size_t size, struct aa_ns *ns, + AA_BUG(!str && size != 0); + AA_BUG(!label); + +- if (flags & FLAG_ABS_ROOT) { ++ if (AA_DEBUG_LABEL && (flags & FLAG_ABS_ROOT)) { + ns = root_ns; +- len = snprintf(str, size, "="); ++ len = snprintf(str, size, "_"); + update_for_len(total, len, size, str); + } else if (!ns) { + ns = labels_ns(label); +@@ -1745,7 +1745,7 @@ void aa_label_xaudit(struct audit_buffer *ab, struct aa_ns *ns, + if (!use_label_hname(ns, label, flags) || + display_mode(ns, label, flags)) { + len = aa_label_asxprint(&name, ns, label, flags, gfp); +- if (len == -1) { ++ if (len < 0) { + AA_DEBUG("label print error"); + return; + } +@@ -1773,7 +1773,7 @@ void aa_label_seq_xprint(struct seq_file *f, struct aa_ns *ns, + int len; + + len = aa_label_asxprint(&str, ns, label, flags, gfp); +- if (len == -1) { ++ if (len < 0) { + AA_DEBUG("label print error"); + return; + } +@@ -1796,7 +1796,7 @@ void aa_label_xprintk(struct aa_ns *ns, struct aa_label *label, int flags, + int len; + + len = aa_label_asxprint(&str, ns, label, flags, gfp); +- if (len == -1) { ++ if (len < 0) { + AA_DEBUG("label print error"); + return; + } +@@ -1896,7 +1896,8 @@ struct aa_label *aa_label_strn_parse(struct aa_label *base, const char *str, + AA_BUG(!str); + + str = skipn_spaces(str, n); +- if (str == NULL || (*str == '=' && base != &root_ns->unconfined->label)) ++ if (str == NULL || (AA_DEBUG_LABEL && *str == '_' && ++ base != &root_ns->unconfined->label)) + return ERR_PTR(-EINVAL); + + len = label_count_strn_entries(str, end - str); +diff --git a/security/apparmor/mount.c b/security/apparmor/mount.c +index e0828ee7a3457..e64f76d347d6e 100644 +--- a/security/apparmor/mount.c ++++ b/security/apparmor/mount.c +@@ -229,7 +229,8 @@ static const char * const mnt_info_table[] = { + "failed srcname match", + "failed type match", + "failed flags match", +- "failed data match" ++ "failed data match", ++ "failed perms check" + }; + + /* +@@ -284,8 +285,8 @@ static int do_match_mnt(struct aa_dfa *dfa, unsigned int start, + return 0; + } + +- /* failed at end of flags match */ +- return 4; ++ /* failed at perms check, don't confuse with flags match */ ++ return 6; + } + + +@@ -718,6 +719,7 @@ int aa_pivotroot(struct aa_label *label, const struct path *old_path, + aa_put_label(target); + goto out; + } ++ aa_put_label(target); + } else + /* already audited error */ + error = PTR_ERR(target); +diff --git a/security/apparmor/policy_unpack.c b/security/apparmor/policy_unpack.c +index dc345ac932053..556ef65ab6ee6 100644 +--- a/security/apparmor/policy_unpack.c ++++ b/security/apparmor/policy_unpack.c +@@ -746,16 +746,18 @@ static struct aa_profile *unpack_profile(struct aa_ext *e, char **ns_name) + profile->label.flags |= FLAG_HAT; + if (!unpack_u32(e, &tmp, NULL)) + goto fail; +- if (tmp == PACKED_MODE_COMPLAIN || (e->version & FORCE_COMPLAIN_FLAG)) ++ if (tmp == PACKED_MODE_COMPLAIN || (e->version & FORCE_COMPLAIN_FLAG)) { + profile->mode = APPARMOR_COMPLAIN; +- else if (tmp == PACKED_MODE_ENFORCE) ++ } else if (tmp == PACKED_MODE_ENFORCE) { + profile->mode = APPARMOR_ENFORCE; +- else if (tmp == PACKED_MODE_KILL) ++ } else if (tmp == PACKED_MODE_KILL) { + profile->mode = APPARMOR_KILL; +- else if (tmp == PACKED_MODE_UNCONFINED) ++ } else if (tmp == PACKED_MODE_UNCONFINED) { + profile->mode = APPARMOR_UNCONFINED; +- else ++ profile->label.flags |= FLAG_UNCONFINED; ++ } else { + goto fail; ++ } + if (!unpack_u32(e, &tmp, NULL)) + goto fail; + if (tmp) +diff --git a/sound/core/control.c b/sound/core/control.c +index 3b44378b9dec9..732eb515d2f59 100644 +--- a/sound/core/control.c ++++ b/sound/core/control.c +@@ -121,6 +121,7 @@ static int snd_ctl_release(struct inode *inode, struct file *file) + if (control->vd[idx].owner == ctl) + control->vd[idx].owner = NULL; + up_write(&card->controls_rwsem); ++ snd_fasync_free(ctl->fasync); + snd_ctl_empty_read_queue(ctl); + put_pid(ctl->pid); + kfree(ctl); +@@ -175,7 +176,7 @@ void snd_ctl_notify(struct snd_card *card, unsigned int mask, + _found: + wake_up(&ctl->change_sleep); + spin_unlock(&ctl->read_lock); +- kill_fasync(&ctl->fasync, SIGIO, POLL_IN); ++ snd_kill_fasync(ctl->fasync, SIGIO, POLL_IN); + } + read_unlock_irqrestore(&card->ctl_files_rwlock, flags); + } +@@ -1941,7 +1942,7 @@ static int snd_ctl_fasync(int fd, struct file * file, int on) + struct snd_ctl_file *ctl; + + ctl = file->private_data; +- return fasync_helper(fd, file, on, &ctl->fasync); ++ return snd_fasync_helper(fd, file, on, &ctl->fasync); + } + + /* return the preferred subdevice number if already assigned; +@@ -2015,7 +2016,7 @@ static int snd_ctl_dev_disconnect(struct snd_device *device) + read_lock_irqsave(&card->ctl_files_rwlock, flags); + list_for_each_entry(ctl, &card->ctl_files, list) { + wake_up(&ctl->change_sleep); +- kill_fasync(&ctl->fasync, SIGIO, POLL_ERR); ++ snd_kill_fasync(ctl->fasync, SIGIO, POLL_ERR); + } + read_unlock_irqrestore(&card->ctl_files_rwlock, flags); + +diff --git a/sound/core/info.c b/sound/core/info.c +index 9fec3070f8ba3..d6fb11c3250c4 100644 +--- a/sound/core/info.c ++++ b/sound/core/info.c +@@ -112,9 +112,9 @@ static loff_t snd_info_entry_llseek(struct file *file, loff_t offset, int orig) + entry = data->entry; + mutex_lock(&entry->access); + if (entry->c.ops->llseek) { +- offset = entry->c.ops->llseek(entry, +- data->file_private_data, +- file, offset, orig); ++ ret = entry->c.ops->llseek(entry, ++ data->file_private_data, ++ file, offset, orig); + goto out; + } + +diff --git a/sound/core/misc.c b/sound/core/misc.c +index 3579dd7a161f7..c3f3d94b51970 100644 +--- a/sound/core/misc.c ++++ b/sound/core/misc.c +@@ -10,6 +10,7 @@ + #include <linux/time.h> + #include <linux/slab.h> + #include <linux/ioport.h> ++#include <linux/fs.h> + #include <sound/core.h> + + #ifdef CONFIG_SND_DEBUG +@@ -145,3 +146,96 @@ snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list) + } + EXPORT_SYMBOL(snd_pci_quirk_lookup); + #endif ++ ++/* ++ * Deferred async signal helpers ++ * ++ * Below are a few helper functions to wrap the async signal handling ++ * in the deferred work. The main purpose is to avoid the messy deadlock ++ * around tasklist_lock and co at the kill_fasync() invocation. ++ * fasync_helper() and kill_fasync() are replaced with snd_fasync_helper() ++ * and snd_kill_fasync(), respectively. In addition, snd_fasync_free() has ++ * to be called at releasing the relevant file object. ++ */ ++struct snd_fasync { ++ struct fasync_struct *fasync; ++ int signal; ++ int poll; ++ int on; ++ struct list_head list; ++}; ++ ++static DEFINE_SPINLOCK(snd_fasync_lock); ++static LIST_HEAD(snd_fasync_list); ++ ++static void snd_fasync_work_fn(struct work_struct *work) ++{ ++ struct snd_fasync *fasync; ++ ++ spin_lock_irq(&snd_fasync_lock); ++ while (!list_empty(&snd_fasync_list)) { ++ fasync = list_first_entry(&snd_fasync_list, struct snd_fasync, list); ++ list_del_init(&fasync->list); ++ spin_unlock_irq(&snd_fasync_lock); ++ if (fasync->on) ++ kill_fasync(&fasync->fasync, fasync->signal, fasync->poll); ++ spin_lock_irq(&snd_fasync_lock); ++ } ++ spin_unlock_irq(&snd_fasync_lock); ++} ++ ++static DECLARE_WORK(snd_fasync_work, snd_fasync_work_fn); ++ ++int snd_fasync_helper(int fd, struct file *file, int on, ++ struct snd_fasync **fasyncp) ++{ ++ struct snd_fasync *fasync = NULL; ++ ++ if (on) { ++ fasync = kzalloc(sizeof(*fasync), GFP_KERNEL); ++ if (!fasync) ++ return -ENOMEM; ++ INIT_LIST_HEAD(&fasync->list); ++ } ++ ++ spin_lock_irq(&snd_fasync_lock); ++ if (*fasyncp) { ++ kfree(fasync); ++ fasync = *fasyncp; ++ } else { ++ if (!fasync) { ++ spin_unlock_irq(&snd_fasync_lock); ++ return 0; ++ } ++ *fasyncp = fasync; ++ } ++ fasync->on = on; ++ spin_unlock_irq(&snd_fasync_lock); ++ return fasync_helper(fd, file, on, &fasync->fasync); ++} ++EXPORT_SYMBOL_GPL(snd_fasync_helper); ++ ++void snd_kill_fasync(struct snd_fasync *fasync, int signal, int poll) ++{ ++ unsigned long flags; ++ ++ if (!fasync || !fasync->on) ++ return; ++ spin_lock_irqsave(&snd_fasync_lock, flags); ++ fasync->signal = signal; ++ fasync->poll = poll; ++ list_move(&fasync->list, &snd_fasync_list); ++ schedule_work(&snd_fasync_work); ++ spin_unlock_irqrestore(&snd_fasync_lock, flags); ++} ++EXPORT_SYMBOL_GPL(snd_kill_fasync); ++ ++void snd_fasync_free(struct snd_fasync *fasync) ++{ ++ if (!fasync) ++ return; ++ fasync->on = 0; ++ flush_work(&snd_fasync_work); ++ kfree(fasync); ++} ++EXPORT_SYMBOL_GPL(snd_fasync_free); +diff --git a/sound/core/timer.c b/sound/core/timer.c +index 04cd8953605ab..764d2b19344e3 100644 +--- a/sound/core/timer.c ++++ b/sound/core/timer.c +@@ -83,7 +83,7 @@ struct snd_timer_user { + unsigned int filter; + struct timespec64 tstamp; /* trigger tstamp */ + wait_queue_head_t qchange_sleep; +- struct fasync_struct *fasync; ++ struct snd_fasync *fasync; + struct mutex ioctl_lock; + }; + +@@ -1345,7 +1345,7 @@ static void snd_timer_user_interrupt(struct snd_timer_instance *timeri, + } + __wake: + spin_unlock(&tu->qlock); +- kill_fasync(&tu->fasync, SIGIO, POLL_IN); ++ snd_kill_fasync(tu->fasync, SIGIO, POLL_IN); + wake_up(&tu->qchange_sleep); + } + +@@ -1383,7 +1383,7 @@ static void snd_timer_user_ccallback(struct snd_timer_instance *timeri, + spin_lock_irqsave(&tu->qlock, flags); + snd_timer_user_append_to_tqueue(tu, &r1); + spin_unlock_irqrestore(&tu->qlock, flags); +- kill_fasync(&tu->fasync, SIGIO, POLL_IN); ++ snd_kill_fasync(tu->fasync, SIGIO, POLL_IN); + wake_up(&tu->qchange_sleep); + } + +@@ -1453,7 +1453,7 @@ static void snd_timer_user_tinterrupt(struct snd_timer_instance *timeri, + spin_unlock(&tu->qlock); + if (append == 0) + return; +- kill_fasync(&tu->fasync, SIGIO, POLL_IN); ++ snd_kill_fasync(tu->fasync, SIGIO, POLL_IN); + wake_up(&tu->qchange_sleep); + } + +@@ -1521,6 +1521,7 @@ static int snd_timer_user_release(struct inode *inode, struct file *file) + snd_timer_instance_free(tu->timeri); + } + mutex_unlock(&tu->ioctl_lock); ++ snd_fasync_free(tu->fasync); + kfree(tu->queue); + kfree(tu->tqueue); + kfree(tu); +@@ -2135,7 +2136,7 @@ static int snd_timer_user_fasync(int fd, struct file * file, int on) + struct snd_timer_user *tu; + + tu = file->private_data; +- return fasync_helper(fd, file, on, &tu->fasync); ++ return snd_fasync_helper(fd, file, on, &tu->fasync); + } + + static ssize_t snd_timer_user_read(struct file *file, char __user *buffer, +diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c +index b822248b666e6..6e679c86b6fa3 100644 +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -8963,6 +8963,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), ++ SND_PCI_QUIRK(0x1558, 0x7717, "Clevo NS70PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1558, 0x7718, "Clevo L140PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), +diff --git a/sound/soc/codecs/tas2770.c b/sound/soc/codecs/tas2770.c +index 315fd9d971c8c..024ec68e8d356 100644 +--- a/sound/soc/codecs/tas2770.c ++++ b/sound/soc/codecs/tas2770.c +@@ -46,34 +46,22 @@ static void tas2770_reset(struct tas2770_priv *tas2770) + usleep_range(1000, 2000); + } + +-static int tas2770_set_bias_level(struct snd_soc_component *component, +- enum snd_soc_bias_level level) ++static int tas2770_update_pwr_ctrl(struct tas2770_priv *tas2770) + { +- struct tas2770_priv *tas2770 = +- snd_soc_component_get_drvdata(component); ++ struct snd_soc_component *component = tas2770->component; ++ unsigned int val; ++ int ret; + +- switch (level) { +- case SND_SOC_BIAS_ON: +- snd_soc_component_update_bits(component, TAS2770_PWR_CTRL, +- TAS2770_PWR_CTRL_MASK, +- TAS2770_PWR_CTRL_ACTIVE); +- break; +- case SND_SOC_BIAS_STANDBY: +- case SND_SOC_BIAS_PREPARE: +- snd_soc_component_update_bits(component, TAS2770_PWR_CTRL, +- TAS2770_PWR_CTRL_MASK, +- TAS2770_PWR_CTRL_MUTE); +- break; +- case SND_SOC_BIAS_OFF: +- snd_soc_component_update_bits(component, TAS2770_PWR_CTRL, +- TAS2770_PWR_CTRL_MASK, +- TAS2770_PWR_CTRL_SHUTDOWN); +- break; ++ if (tas2770->dac_powered) ++ val = tas2770->unmuted ? ++ TAS2770_PWR_CTRL_ACTIVE : TAS2770_PWR_CTRL_MUTE; ++ else ++ val = TAS2770_PWR_CTRL_SHUTDOWN; + +- default: +- dev_err(tas2770->dev, "wrong power level setting %d\n", level); +- return -EINVAL; +- } ++ ret = snd_soc_component_update_bits(component, TAS2770_PWR_CTRL, ++ TAS2770_PWR_CTRL_MASK, val); ++ if (ret < 0) ++ return ret; + + return 0; + } +@@ -114,9 +102,7 @@ static int tas2770_codec_resume(struct snd_soc_component *component) + gpiod_set_value_cansleep(tas2770->sdz_gpio, 1); + usleep_range(1000, 2000); + } else { +- ret = snd_soc_component_update_bits(component, TAS2770_PWR_CTRL, +- TAS2770_PWR_CTRL_MASK, +- TAS2770_PWR_CTRL_ACTIVE); ++ ret = tas2770_update_pwr_ctrl(tas2770); + if (ret < 0) + return ret; + } +@@ -152,24 +138,19 @@ static int tas2770_dac_event(struct snd_soc_dapm_widget *w, + + switch (event) { + case SND_SOC_DAPM_POST_PMU: +- ret = snd_soc_component_update_bits(component, TAS2770_PWR_CTRL, +- TAS2770_PWR_CTRL_MASK, +- TAS2770_PWR_CTRL_MUTE); ++ tas2770->dac_powered = 1; ++ ret = tas2770_update_pwr_ctrl(tas2770); + break; + case SND_SOC_DAPM_PRE_PMD: +- ret = snd_soc_component_update_bits(component, TAS2770_PWR_CTRL, +- TAS2770_PWR_CTRL_MASK, +- TAS2770_PWR_CTRL_SHUTDOWN); ++ tas2770->dac_powered = 0; ++ ret = tas2770_update_pwr_ctrl(tas2770); + break; + default: + dev_err(tas2770->dev, "Not supported evevt\n"); + return -EINVAL; + } + +- if (ret < 0) +- return ret; +- +- return 0; ++ return ret; + } + + static const struct snd_kcontrol_new isense_switch = +@@ -203,21 +184,11 @@ static const struct snd_soc_dapm_route tas2770_audio_map[] = { + static int tas2770_mute(struct snd_soc_dai *dai, int mute, int direction) + { + struct snd_soc_component *component = dai->component; +- int ret; +- +- if (mute) +- ret = snd_soc_component_update_bits(component, TAS2770_PWR_CTRL, +- TAS2770_PWR_CTRL_MASK, +- TAS2770_PWR_CTRL_MUTE); +- else +- ret = snd_soc_component_update_bits(component, TAS2770_PWR_CTRL, +- TAS2770_PWR_CTRL_MASK, +- TAS2770_PWR_CTRL_ACTIVE); +- +- if (ret < 0) +- return ret; ++ struct tas2770_priv *tas2770 = ++ snd_soc_component_get_drvdata(component); + +- return 0; ++ tas2770->unmuted = !mute; ++ return tas2770_update_pwr_ctrl(tas2770); + } + + static int tas2770_set_bitwidth(struct tas2770_priv *tas2770, int bitwidth) +@@ -337,7 +308,7 @@ static int tas2770_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) + struct snd_soc_component *component = dai->component; + struct tas2770_priv *tas2770 = + snd_soc_component_get_drvdata(component); +- u8 tdm_rx_start_slot = 0, asi_cfg_1 = 0; ++ u8 tdm_rx_start_slot = 0, invert_fpol = 0, fpol_preinv = 0, asi_cfg_1 = 0; + int ret; + + switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { +@@ -349,9 +320,15 @@ static int tas2770_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) + } + + switch (fmt & SND_SOC_DAIFMT_INV_MASK) { ++ case SND_SOC_DAIFMT_NB_IF: ++ invert_fpol = 1; ++ fallthrough; + case SND_SOC_DAIFMT_NB_NF: + asi_cfg_1 |= TAS2770_TDM_CFG_REG1_RX_RSING; + break; ++ case SND_SOC_DAIFMT_IB_IF: ++ invert_fpol = 1; ++ fallthrough; + case SND_SOC_DAIFMT_IB_NF: + asi_cfg_1 |= TAS2770_TDM_CFG_REG1_RX_FALING; + break; +@@ -369,15 +346,19 @@ static int tas2770_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) + switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { + case SND_SOC_DAIFMT_I2S: + tdm_rx_start_slot = 1; ++ fpol_preinv = 0; + break; + case SND_SOC_DAIFMT_DSP_A: + tdm_rx_start_slot = 0; ++ fpol_preinv = 1; + break; + case SND_SOC_DAIFMT_DSP_B: + tdm_rx_start_slot = 1; ++ fpol_preinv = 1; + break; + case SND_SOC_DAIFMT_LEFT_J: + tdm_rx_start_slot = 0; ++ fpol_preinv = 1; + break; + default: + dev_err(tas2770->dev, +@@ -391,6 +372,14 @@ static int tas2770_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) + if (ret < 0) + return ret; + ++ ret = snd_soc_component_update_bits(component, TAS2770_TDM_CFG_REG0, ++ TAS2770_TDM_CFG_REG0_FPOL_MASK, ++ (fpol_preinv ^ invert_fpol) ++ ? TAS2770_TDM_CFG_REG0_FPOL_RSING ++ : TAS2770_TDM_CFG_REG0_FPOL_FALING); ++ if (ret < 0) ++ return ret; ++ + return 0; + } + +@@ -489,7 +478,7 @@ static struct snd_soc_dai_driver tas2770_dai_driver[] = { + .id = 0, + .playback = { + .stream_name = "ASI1 Playback", +- .channels_min = 2, ++ .channels_min = 1, + .channels_max = 2, + .rates = TAS2770_RATES, + .formats = TAS2770_FORMATS, +@@ -537,7 +526,6 @@ static const struct snd_soc_component_driver soc_component_driver_tas2770 = { + .probe = tas2770_codec_probe, + .suspend = tas2770_codec_suspend, + .resume = tas2770_codec_resume, +- .set_bias_level = tas2770_set_bias_level, + .controls = tas2770_snd_controls, + .num_controls = ARRAY_SIZE(tas2770_snd_controls), + .dapm_widgets = tas2770_dapm_widgets, +diff --git a/sound/soc/codecs/tas2770.h b/sound/soc/codecs/tas2770.h +index d156666bcc552..f75f40781ab13 100644 +--- a/sound/soc/codecs/tas2770.h ++++ b/sound/soc/codecs/tas2770.h +@@ -41,6 +41,9 @@ + #define TAS2770_TDM_CFG_REG0_31_44_1_48KHZ 0x6 + #define TAS2770_TDM_CFG_REG0_31_88_2_96KHZ 0x8 + #define TAS2770_TDM_CFG_REG0_31_176_4_192KHZ 0xa ++#define TAS2770_TDM_CFG_REG0_FPOL_MASK BIT(0) ++#define TAS2770_TDM_CFG_REG0_FPOL_RSING 0 ++#define TAS2770_TDM_CFG_REG0_FPOL_FALING 1 + /* TDM Configuration Reg1 */ + #define TAS2770_TDM_CFG_REG1 TAS2770_REG(0X0, 0x0B) + #define TAS2770_TDM_CFG_REG1_MASK GENMASK(5, 1) +@@ -135,6 +138,8 @@ struct tas2770_priv { + struct device *dev; + int v_sense_slot; + int i_sense_slot; ++ bool dac_powered; ++ bool unmuted; + }; + + #endif /* __TAS2770__ */ +diff --git a/sound/soc/sof/intel/hda.c b/sound/soc/sof/intel/hda.c +index b0faf050132d8..b4cc724831370 100644 +--- a/sound/soc/sof/intel/hda.c ++++ b/sound/soc/sof/intel/hda.c +@@ -39,6 +39,17 @@ + #define EXCEPT_MAX_HDR_SIZE 0x400 + #define HDA_EXT_ROM_STATUS_SIZE 8 + ++static const struct sof_intel_dsp_desc ++ *get_chip_info(struct snd_sof_pdata *pdata) ++{ ++ const struct sof_dev_desc *desc = pdata->desc; ++ const struct sof_intel_dsp_desc *chip_info; ++ ++ chip_info = desc->chip_info; ++ ++ return chip_info; ++} ++ + #if IS_ENABLED(CONFIG_SND_SOC_SOF_INTEL_SOUNDWIRE) + + /* +@@ -674,17 +685,6 @@ skip_soundwire: + return 0; + } + +-static const struct sof_intel_dsp_desc +- *get_chip_info(struct snd_sof_pdata *pdata) +-{ +- const struct sof_dev_desc *desc = pdata->desc; +- const struct sof_intel_dsp_desc *chip_info; +- +- chip_info = desc->chip_info; +- +- return chip_info; +-} +- + static irqreturn_t hda_dsp_interrupt_handler(int irq, void *context) + { + struct snd_sof_dev *sdev = context; +diff --git a/sound/usb/card.c b/sound/usb/card.c +index 45fc217e4e97b..a3e06a71cf356 100644 +--- a/sound/usb/card.c ++++ b/sound/usb/card.c +@@ -379,6 +379,14 @@ static const struct usb_audio_device_name usb_audio_names[] = { + + DEVICE_NAME(0x046d, 0x0990, "Logitech, Inc.", "QuickCam Pro 9000"), + ++ /* ASUS ROG Zenith II: this machine has also two devices, one for ++ * the front headphone and another for the rest ++ */ ++ PROFILE_NAME(0x0b05, 0x1915, "ASUS", "Zenith II Front Headphone", ++ "Zenith-II-Front-Headphone"), ++ PROFILE_NAME(0x0b05, 0x1916, "ASUS", "Zenith II Main Audio", ++ "Zenith-II-Main-Audio"), ++ + /* ASUS ROG Strix */ + PROFILE_NAME(0x0b05, 0x1917, + "Realtek", "ALC1220-VB-DT", "Realtek-ALC1220-VB-Desktop"), +diff --git a/sound/usb/mixer_maps.c b/sound/usb/mixer_maps.c +index 81ace832d7e42..b708a240a5f06 100644 +--- a/sound/usb/mixer_maps.c ++++ b/sound/usb/mixer_maps.c +@@ -367,13 +367,28 @@ static const struct usbmix_name_map corsair_virtuoso_map[] = { + { 0 } + }; + +-/* Some mobos shipped with a dummy HD-audio show the invalid GET_MIN/GET_MAX +- * response for Input Gain Pad (id=19, control=12) and the connector status +- * for SPDIF terminal (id=18). Skip them. +- */ +-static const struct usbmix_name_map asus_rog_map[] = { +- { 18, NULL }, /* OT, connector control */ +- { 19, NULL, 12 }, /* FU, Input Gain Pad */ ++/* ASUS ROG Zenith II with Realtek ALC1220-VB */ ++static const struct usbmix_name_map asus_zenith_ii_map[] = { ++ { 19, NULL, 12 }, /* FU, Input Gain Pad - broken response, disabled */ ++ { 16, "Speaker" }, /* OT */ ++ { 22, "Speaker Playback" }, /* FU */ ++ { 7, "Line" }, /* IT */ ++ { 19, "Line Capture" }, /* FU */ ++ { 8, "Mic" }, /* IT */ ++ { 20, "Mic Capture" }, /* FU */ ++ { 9, "Front Mic" }, /* IT */ ++ { 21, "Front Mic Capture" }, /* FU */ ++ { 17, "IEC958" }, /* OT */ ++ { 23, "IEC958 Playback" }, /* FU */ ++ {} ++}; ++ ++static const struct usbmix_connector_map asus_zenith_ii_connector_map[] = { ++ { 10, 16 }, /* (Back) Speaker */ ++ { 11, 17 }, /* SPDIF */ ++ { 13, 7 }, /* Line */ ++ { 14, 8 }, /* Mic */ ++ { 15, 9 }, /* Front Mic */ + {} + }; + +@@ -590,9 +605,10 @@ static const struct usbmix_ctl_map usbmix_ctl_maps[] = { + .map = trx40_mobo_map, + .connector_map = trx40_mobo_connector_map, + }, +- { /* ASUS ROG Zenith II */ ++ { /* ASUS ROG Zenith II (main audio) */ + .id = USB_ID(0x0b05, 0x1916), +- .map = asus_rog_map, ++ .map = asus_zenith_ii_map, ++ .connector_map = asus_zenith_ii_connector_map, + }, + { /* ASUS ROG Strix */ + .id = USB_ID(0x0b05, 0x1917), +diff --git a/tools/build/feature/test-libcrypto.c b/tools/build/feature/test-libcrypto.c +index a98174e0569c8..bc34a5bbb5049 100644 +--- a/tools/build/feature/test-libcrypto.c ++++ b/tools/build/feature/test-libcrypto.c +@@ -1,16 +1,23 @@ + // SPDX-License-Identifier: GPL-2.0 ++#include <openssl/evp.h> + #include <openssl/sha.h> + #include <openssl/md5.h> + + int main(void) + { +- MD5_CTX context; ++ EVP_MD_CTX *mdctx; + unsigned char md[MD5_DIGEST_LENGTH + SHA_DIGEST_LENGTH]; + unsigned char dat[] = "12345"; ++ unsigned int digest_len; + +- MD5_Init(&context); +- MD5_Update(&context, &dat[0], sizeof(dat)); +- MD5_Final(&md[0], &context); ++ mdctx = EVP_MD_CTX_new(); ++ if (!mdctx) ++ return 0; ++ ++ EVP_DigestInit_ex(mdctx, EVP_md5(), NULL); ++ EVP_DigestUpdate(mdctx, &dat[0], sizeof(dat)); ++ EVP_DigestFinal_ex(mdctx, &md[0], &digest_len); ++ EVP_MD_CTX_free(mdctx); + + SHA1(&dat[0], sizeof(dat), &md[0]); + +diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c +index d103084fcd56c..97e2a72bd6f5e 100644 +--- a/tools/perf/util/probe-event.c ++++ b/tools/perf/util/probe-event.c +@@ -1760,8 +1760,10 @@ int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev) + if (!pev->event && pev->point.function && pev->point.line + && !pev->point.lazy_line && !pev->point.offset) { + if (asprintf(&pev->event, "%s_L%d", pev->point.function, +- pev->point.line) < 0) +- return -ENOMEM; ++ pev->point.line) < 0) { ++ ret = -ENOMEM; ++ goto out; ++ } + } + + /* Copy arguments and ensure return probe has no C argument */ +diff --git a/tools/testing/selftests/ftrace/test.d/kprobe/kprobe_syntax_errors.tc b/tools/testing/selftests/ftrace/test.d/kprobe/kprobe_syntax_errors.tc +index fa928b431555c..7c02509c71d0a 100644 +--- a/tools/testing/selftests/ftrace/test.d/kprobe/kprobe_syntax_errors.tc ++++ b/tools/testing/selftests/ftrace/test.d/kprobe/kprobe_syntax_errors.tc +@@ -21,7 +21,6 @@ check_error 'p:^/bar vfs_read' # NO_GROUP_NAME + check_error 'p:^12345678901234567890123456789012345678901234567890123456789012345/bar vfs_read' # GROUP_TOO_LONG + + check_error 'p:^foo.1/bar vfs_read' # BAD_GROUP_NAME +-check_error 'p:foo/^ vfs_read' # NO_EVENT_NAME + check_error 'p:foo/^12345678901234567890123456789012345678901234567890123456789012345 vfs_read' # EVENT_TOO_LONG + check_error 'p:foo/^bar.1 vfs_read' # BAD_EVENT_NAME + +diff --git a/tools/vm/slabinfo.c b/tools/vm/slabinfo.c +index 9b68658b6bb85..3ae985dc24b6d 100644 +--- a/tools/vm/slabinfo.c ++++ b/tools/vm/slabinfo.c +@@ -125,7 +125,7 @@ static void usage(void) + "-n|--numa Show NUMA information\n" + "-N|--lines=K Show the first K slabs\n" + "-o|--ops Show kmem_cache_ops\n" +- "-P|--partial Sort by number of partial slabs\n" ++ "-P|--partial Sort by number of partial slabs\n" + "-r|--report Detailed report on single slabs\n" + "-s|--shrink Shrink slabs\n" + "-S|--Size Sort by size\n" +@@ -1045,15 +1045,27 @@ static void sort_slabs(void) + for (s2 = s1 + 1; s2 < slabinfo + slabs; s2++) { + int result; + +- if (sort_size) +- result = slab_size(s1) < slab_size(s2); +- else if (sort_active) +- result = slab_activity(s1) < slab_activity(s2); +- else if (sort_loss) +- result = slab_waste(s1) < slab_waste(s2); +- else if (sort_partial) +- result = s1->partial < s2->partial; +- else ++ if (sort_size) { ++ if (slab_size(s1) == slab_size(s2)) ++ result = strcasecmp(s1->name, s2->name); ++ else ++ result = slab_size(s1) < slab_size(s2); ++ } else if (sort_active) { ++ if (slab_activity(s1) == slab_activity(s2)) ++ result = strcasecmp(s1->name, s2->name); ++ else ++ result = slab_activity(s1) < slab_activity(s2); ++ } else if (sort_loss) { ++ if (slab_waste(s1) == slab_waste(s2)) ++ result = strcasecmp(s1->name, s2->name); ++ else ++ result = slab_waste(s1) < slab_waste(s2); ++ } else if (sort_partial) { ++ if (s1->partial == s2->partial) ++ result = strcasecmp(s1->name, s2->name); ++ else ++ result = s1->partial < s2->partial; ++ } else + result = strcasecmp(s1->name, s2->name); + + if (show_inverted) |