Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

Three trivial overlapping conflicts.

Signed-off-by: David S. Miller <davem@davemloft.net>

167 files changed, 1373 insertions, 725 deletions

diff --git a/Documentation/driver-api/usb/power-management.rst b/Documentation/driver-api/usb/power-management.rst
index 79beb807996b..4a74cf6f2797 100644
--- a/Documentation/driver-api/usb/power-management.rst
+++ b/Documentation/driver-api/usb/power-management.rst
@@ -370,11 +370,15 @@ autosuspend the interface's device.  When the usage counter is = 0
 then the interface is considered to be idle, and the kernel may
 autosuspend the device.
 
-Drivers need not be concerned about balancing changes to the usage
-counter; the USB core will undo any remaining "get"s when a driver
-is unbound from its interface.  As a corollary, drivers must not call
-any of the ``usb_autopm_*`` functions after their ``disconnect``
-routine has returned.
+Drivers must be careful to balance their overall changes to the usage
+counter.  Unbalanced "get"s will remain in effect when a driver is
+unbound from its interface, preventing the device from going into
+runtime suspend should the interface be bound to a driver again.  On
+the other hand, drivers are allowed to achieve this balance by calling
+the ``usb_autopm_*`` functions even after their ``disconnect`` routine
+has returned -- say from within a work-queue routine -- provided they
+retain an active reference to the interface (via ``usb_get_intf`` and
+``usb_put_intf``).
 
 Drivers using the async routines are responsible for their own
 synchronization and mutual exclusion.
diff --git a/Documentation/networking/ip-sysctl.txt b/Documentation/networking/ip-sysctl.txt
index c9538a30ef7e..725b8bea58a7 100644
--- a/Documentation/networking/ip-sysctl.txt
+++ b/Documentation/networking/ip-sysctl.txt
@@ -1342,6 +1342,7 @@ tag - INTEGER
         Default value is 0.
 
 xfrm4_gc_thresh - INTEGER
+        (Obsolete since linux-4.14)
         The threshold at which we will start garbage collecting for IPv4
         destination cache entries.  At twice this value the system will
         refuse new allocations.
@@ -1950,6 +1951,7 @@ echo_ignore_anycast - BOOLEAN
         Default: 0
 
 xfrm6_gc_thresh - INTEGER
+        (Obsolete since linux-4.14)
         The threshold at which we will start garbage collecting for IPv6
         destination cache entries.  At twice this value the system will
         refuse new allocations.
diff --git a/Documentation/networking/netdev-FAQ.rst b/Documentation/networking/netdev-FAQ.rst
index 8c7a713cf657..642fa963be3c 100644
--- a/Documentation/networking/netdev-FAQ.rst
+++ b/Documentation/networking/netdev-FAQ.rst
@@ -132,7 +132,7 @@ version that should be applied. If there is any doubt, the maintainer
 will reply and ask what should be done.
 
 Q: I made changes to only a few patches in a patch series should I resend only those changed?
---------------------------------------------------------------------------------------------
+---------------------------------------------------------------------------------------------
 A: No, please resend the entire patch series and make sure you do number your
 patches such that it is clear this is the latest and greatest set of patches
 that can be applied.
diff --git a/Documentation/sysctl/vm.txt b/Documentation/sysctl/vm.txt
index 6af24cdb25cc..3f13d8599337 100644
--- a/Documentation/sysctl/vm.txt
+++ b/Documentation/sysctl/vm.txt
@@ -866,14 +866,14 @@ The intent is that compaction has less work to do in the future and to
 increase the success rate of future high-order allocations such as SLUB
 allocations, THP and hugetlbfs pages.
 
-To make it sensible with respect to the watermark_scale_factor parameter,
-the unit is in fractions of 10,000. The default value of 15,000 means
-that up to 150% of the high watermark will be reclaimed in the event of
-a pageblock being mixed due to fragmentation. The level of reclaim is
-determined by the number of fragmentation events that occurred in the
-recent past. If this value is smaller than a pageblock then a pageblocks
-worth of pages will be reclaimed (e.g.  2MB on 64-bit x86). A boost factor
-of 0 will disable the feature.
+To make it sensible with respect to the watermark_scale_factor
+parameter, the unit is in fractions of 10,000. The default value of
+15,000 on !DISCONTIGMEM configurations means that up to 150% of the high
+watermark will be reclaimed in the event of a pageblock being mixed due
+to fragmentation. The level of reclaim is determined by the number of
+fragmentation events that occurred in the recent past. If this value is
+smaller than a pageblock then a pageblocks worth of pages will be reclaimed
+(e.g.  2MB on 64-bit x86). A boost factor of 0 will disable the feature.
 
 =============================================================
 
diff --git a/Makefile b/Makefile
index b6e7ee4f1fc4..e1bb7345cdd1 100644
--- a/Makefile
+++ b/Makefile
@@ -2,7 +2,7 @@
 VERSION = 5
 PATCHLEVEL = 1
 SUBLEVEL = 0
-EXTRAVERSION = -rc6
+EXTRAVERSION = -rc7
 NAME = Shy Crocodile
 
 # *DOCUMENTATION*
@@ -679,6 +679,7 @@ KBUILD_CFLAGS	+= $(call cc-disable-warning,frame-address,)
 KBUILD_CFLAGS   += $(call cc-disable-warning, format-truncation)
 KBUILD_CFLAGS   += $(call cc-disable-warning, format-overflow)
 KBUILD_CFLAGS   += $(call cc-disable-warning, int-in-bool-context)
+KBUILD_CFLAGS   += $(call cc-disable-warning, address-of-packed-member)
 
 ifdef CONFIG_CC_OPTIMIZE_FOR_SIZE
 KBUILD_CFLAGS   += -Os
@@ -720,7 +721,6 @@ ifdef CONFIG_CC_IS_CLANG
 KBUILD_CPPFLAGS += $(call cc-option,-Qunused-arguments,)
 KBUILD_CFLAGS += $(call cc-disable-warning, format-invalid-specifier)
 KBUILD_CFLAGS += $(call cc-disable-warning, gnu)
-KBUILD_CFLAGS += $(call cc-disable-warning, address-of-packed-member)
 # Quiet clang warning: comparison of unsigned expression < 0 is always false
 KBUILD_CFLAGS += $(call cc-disable-warning, tautological-compare)
 # CLANG uses a _MergedGlobals as optimization, but this breaks modpost, as the
diff --git a/arch/arc/boot/dts/hsdk.dts b/arch/arc/boot/dts/hsdk.dts
index 69bc1c9e8e50..7425bb0f2d1b 100644
--- a/arch/arc/boot/dts/hsdk.dts
+++ b/arch/arc/boot/dts/hsdk.dts
@@ -18,8 +18,8 @@
         model = "snps,hsdk";
         compatible = "snps,hsdk";
 
-        #address-cells = <1>;
-        #size-cells = <1>;
+        #address-cells = <2>;
+        #size-cells = <2>;
 
         chosen {
                 bootargs = "earlycon=uart8250,mmio32,0xf0005000,115200n8 console=ttyS0,115200n8 debug print-fatal-signals=1";
@@ -105,7 +105,7 @@
                 #size-cells = <1>;
                 interrupt-parent = <&idu_intc>;
 
-                ranges = <0x00000000 0xf0000000 0x10000000>;
+                ranges = <0x00000000 0x0 0xf0000000 0x10000000>;
 
                 cgu_rst: reset-controller@8a0 {
                         compatible = "snps,hsdk-reset";
@@ -269,9 +269,10 @@
         };
 
         memory@80000000 {
-                #address-cells = <1>;
-                #size-cells = <1>;
+                #address-cells = <2>;
+                #size-cells = <2>;
                 device_type = "memory";
-                reg = <0x80000000 0x40000000>;  /* 1 GiB */
+                reg = <0x0 0x80000000 0x0 0x40000000>;  /* 1 GB lowmem */
+                /*     0x1 0x00000000 0x0 0x40000000>;     1 GB highmem */
         };
 };
diff --git a/arch/arc/lib/memset-archs.S b/arch/arc/lib/memset-archs.S
index f230bb7092fd..b3373f5c88e0 100644
--- a/arch/arc/lib/memset-archs.S
+++ b/arch/arc/lib/memset-archs.S
@@ -30,10 +30,10 @@
 
 #else
 
-.macro PREALLOC_INSTR
+.macro PREALLOC_INSTR   reg, off
 .endm
 
-.macro PREFETCHW_INSTR
+.macro PREFETCHW_INSTR  reg, off
 .endm
 
 #endif
diff --git a/arch/arc/mm/cache.c b/arch/arc/mm/cache.c
index 4135abec3fb0..63e6e6504699 100644
--- a/arch/arc/mm/cache.c
+++ b/arch/arc/mm/cache.c
@@ -113,10 +113,24 @@ static void read_decode_cache_bcr_arcv2(int cpu)
         }
 
         READ_BCR(ARC_REG_CLUSTER_BCR, cbcr);
-        if (cbcr.c)
+        if (cbcr.c) {
                 ioc_exists = 1;
-        else
+
+                /*
+                 * As for today we don't support both IOC and ZONE_HIGHMEM enabled
+                 * simultaneously. This happens because as of today IOC aperture covers
+                 * only ZONE_NORMAL (low mem) and any dma transactions outside this
+                 * region won't be HW coherent.
+                 * If we want to use both IOC and ZONE_HIGHMEM we can use
+                 * bounce_buffer to handle dma transactions to HIGHMEM.
+                 * Also it is possible to modify dma_direct cache ops or increase IOC
+                 * aperture size if we are planning to use HIGHMEM without PAE.
+                 */
+                if (IS_ENABLED(CONFIG_HIGHMEM) || is_pae40_enabled())
+                        ioc_enable = 0;
+        } else {
                 ioc_enable = 0;
+        }
 
         /* HS 2.0 didn't have AUX_VOL */
         if (cpuinfo_arc700[cpu].core.family > 0x51) {
@@ -1158,19 +1172,6 @@ noinline void __init arc_ioc_setup(void)
         if (!ioc_enable)
                 return;
 
-        /*
-         * As for today we don't support both IOC and ZONE_HIGHMEM enabled
-         * simultaneously. This happens because as of today IOC aperture covers
-         * only ZONE_NORMAL (low mem) and any dma transactions outside this
-         * region won't be HW coherent.
-         * If we want to use both IOC and ZONE_HIGHMEM we can use
-         * bounce_buffer to handle dma transactions to HIGHMEM.
-         * Also it is possible to modify dma_direct cache ops or increase IOC
-         * aperture size if we are planning to use HIGHMEM without PAE.
-         */
-        if (IS_ENABLED(CONFIG_HIGHMEM))
-                panic("IOC and HIGHMEM can't be used simultaneously");
-
         /* Flush + invalidate + disable L1 dcache */
         __dc_disable();
 
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index 850b4805e2d1..9aed25a6019b 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -73,7 +73,7 @@ config ARM
         select HAVE_EFFICIENT_UNALIGNED_ACCESS if (CPU_V6 || CPU_V6K || CPU_V7) && MMU
         select HAVE_EXIT_THREAD
         select HAVE_FTRACE_MCOUNT_RECORD if !XIP_KERNEL
-        select HAVE_FUNCTION_GRAPH_TRACER if !THUMB2_KERNEL
+        select HAVE_FUNCTION_GRAPH_TRACER if !THUMB2_KERNEL && !CC_IS_CLANG
         select HAVE_FUNCTION_TRACER if !XIP_KERNEL
         select HAVE_GCC_PLUGINS
         select HAVE_HW_BREAKPOINT if PERF_EVENTS && (CPU_V6 || CPU_V6K || CPU_V7)
diff --git a/arch/arm/Kconfig.debug b/arch/arm/Kconfig.debug
index 6d6e0330930b..e388af4594a6 100644
--- a/arch/arm/Kconfig.debug
+++ b/arch/arm/Kconfig.debug
@@ -47,8 +47,8 @@ config DEBUG_WX
 
 choice
         prompt "Choose kernel unwinder"
-        default UNWINDER_ARM if AEABI && !FUNCTION_GRAPH_TRACER
-        default UNWINDER_FRAME_POINTER if !AEABI || FUNCTION_GRAPH_TRACER
+        default UNWINDER_ARM if AEABI
+        default UNWINDER_FRAME_POINTER if !AEABI
         help
           This determines which method will be used for unwinding kernel stack
           traces for panics, oopses, bugs, warnings, perf, /proc/<pid>/stack,
@@ -65,7 +65,7 @@ config UNWINDER_FRAME_POINTER
 
 config UNWINDER_ARM
         bool "ARM EABI stack unwinder"
-        depends on AEABI
+        depends on AEABI && !FUNCTION_GRAPH_TRACER
         select ARM_UNWIND
         help
           This option enables stack unwinding support in the kernel
diff --git a/arch/arm/boot/compressed/head.S b/arch/arm/boot/compressed/head.S
index 6c7ccb428c07..7135820f76d4 100644
--- a/arch/arm/boot/compressed/head.S
+++ b/arch/arm/boot/compressed/head.S
@@ -1438,7 +1438,21 @@ ENTRY(efi_stub_entry)
 
                 @ Preserve return value of efi_entry() in r4
                 mov     r4, r0
-                bl      cache_clean_flush
+
+                @ our cache maintenance code relies on CP15 barrier instructions
+                @ but since we arrived here with the MMU and caches configured
+                @ by UEFI, we must check that the CP15BEN bit is set in SCTLR.
+                @ Note that this bit is RAO/WI on v6 and earlier, so the ISB in
+                @ the enable path will be executed on v7+ only.
+                mrc     p15, 0, r1, c1, c0, 0   @ read SCTLR
+                tst     r1, #(1 << 5)           @ CP15BEN bit set?
+                bne     0f
+                orr     r1, r1, #(1 << 5)       @ CP15 barrier instructions
+                mcr     p15, 0, r1, c1, c0, 0   @ write SCTLR
+ ARM(           .inst   0xf57ff06f              @ v7+ isb       )
+ THUMB(         isb                                             )
+
+0:              bl      cache_clean_flush
                 bl      cache_off
 
                 @ Set parameters for booting zImage according to boot protocol
diff --git a/arch/arm/kernel/head-nommu.S b/arch/arm/kernel/head-nommu.S
index c08d2d890f7b..b38bbd011b35 100644
--- a/arch/arm/kernel/head-nommu.S
+++ b/arch/arm/kernel/head-nommu.S
@@ -133,9 +133,9 @@ __secondary_data:
  */
         .text
 __after_proc_init:
-#ifdef CONFIG_ARM_MPU
 M_CLASS(movw    r12, #:lower16:BASEADDR_V7M_SCB)
 M_CLASS(movt    r12, #:upper16:BASEADDR_V7M_SCB)
+#ifdef CONFIG_ARM_MPU
 M_CLASS(ldr     r3, [r12, 0x50])
 AR_CLASS(mrc    p15, 0, r3, c0, c1, 4)          @ Read ID_MMFR0
         and     r3, r3, #(MMFR0_PMSA)           @ PMSA field
diff --git a/arch/arm64/kernel/ftrace.c b/arch/arm64/kernel/ftrace.c
index 07b298120182..65a51331088e 100644
--- a/arch/arm64/kernel/ftrace.c
+++ b/arch/arm64/kernel/ftrace.c
@@ -103,10 +103,15 @@ int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
                  * to be revisited if support for multiple ftrace entry points
                  * is added in the future, but for now, the pr_err() below
                  * deals with a theoretical issue only.
+                 *
+                 * Note that PLTs are place relative, and plt_entries_equal()
+                 * checks whether they point to the same target. Here, we need
+                 * to check if the actual opcodes are in fact identical,
+                 * regardless of the offset in memory so use memcmp() instead.
                  */
                 trampoline = get_plt_entry(addr, mod->arch.ftrace_trampoline);
-                if (!plt_entries_equal(mod->arch.ftrace_trampoline,
-                                       &trampoline)) {
+                if (memcmp(mod->arch.ftrace_trampoline, &trampoline,
+                           sizeof(trampoline))) {
                         if (plt_entry_is_initialized(mod->arch.ftrace_trampoline)) {
                                 pr_err("ftrace: far branches to multiple entry points unsupported inside a single module\n");
                                 return -EINVAL;
diff --git a/arch/arm64/mm/init.c b/arch/arm64/mm/init.c
index 6bc135042f5e..7cae155e81a5 100644
--- a/arch/arm64/mm/init.c
+++ b/arch/arm64/mm/init.c
@@ -363,7 +363,7 @@ void __init arm64_memblock_init(void)
                  * Otherwise, this is a no-op
                  */
                 u64 base = phys_initrd_start & PAGE_MASK;
-                u64 size = PAGE_ALIGN(phys_initrd_size);
+                u64 size = PAGE_ALIGN(phys_initrd_start + phys_initrd_size) - base;
 
                 /*
                  * We can only add back the initrd memory if we don't end up
diff --git a/arch/mips/net/ebpf_jit.c b/arch/mips/net/ebpf_jit.c
index 0effd3cba9a7..98bf0c222b5f 100644
--- a/arch/mips/net/ebpf_jit.c
+++ b/arch/mips/net/ebpf_jit.c
@@ -186,8 +186,9 @@ enum which_ebpf_reg {
  * separate frame pointer, so BPF_REG_10 relative accesses are
  * adjusted to be $sp relative.
  */
-int ebpf_to_mips_reg(struct jit_ctx *ctx, const struct bpf_insn *insn,
-                     enum which_ebpf_reg w)
+static int ebpf_to_mips_reg(struct jit_ctx *ctx,
+                            const struct bpf_insn *insn,
+                            enum which_ebpf_reg w)
 {
         int ebpf_reg = (w == src_reg || w == src_reg_no_fp) ?
                 insn->src_reg : insn->dst_reg;
diff --git a/arch/powerpc/configs/skiroot_defconfig b/arch/powerpc/configs/skiroot_defconfig
index 5ba131c30f6b..1bcd468ab422 100644
--- a/arch/powerpc/configs/skiroot_defconfig
+++ b/arch/powerpc/configs/skiroot_defconfig
@@ -266,6 +266,7 @@ CONFIG_UDF_FS=m
 CONFIG_MSDOS_FS=m
 CONFIG_VFAT_FS=m
 CONFIG_PROC_KCORE=y
+CONFIG_HUGETLBFS=y
 # CONFIG_MISC_FILESYSTEMS is not set
 # CONFIG_NETWORK_FILESYSTEMS is not set
 CONFIG_NLS=y
diff --git a/arch/powerpc/mm/mmu_context_iommu.c b/arch/powerpc/mm/mmu_context_iommu.c
index e7a9c4f6bfca..8330f135294f 100644
--- a/arch/powerpc/mm/mmu_context_iommu.c
+++ b/arch/powerpc/mm/mmu_context_iommu.c
@@ -95,28 +95,15 @@ static long mm_iommu_do_alloc(struct mm_struct *mm, unsigned long ua,
                               unsigned long entries, unsigned long dev_hpa,
                               struct mm_iommu_table_group_mem_t **pmem)
 {
-        struct mm_iommu_table_group_mem_t *mem;
-        long i, ret, locked_entries = 0;
+        struct mm_iommu_table_group_mem_t *mem, *mem2;
+        long i, ret, locked_entries = 0, pinned = 0;
         unsigned int pageshift;
-
-        mutex_lock(&mem_list_mutex);
-
-        list_for_each_entry_rcu(mem, &mm->context.iommu_group_mem_list,
-                        next) {
-                /* Overlap? */
-                if ((mem->ua < (ua + (entries << PAGE_SHIFT))) &&
-                                (ua < (mem->ua +
-                                       (mem->entries << PAGE_SHIFT)))) {
-                        ret = -EINVAL;
-                        goto unlock_exit;
-                }
-
-        }
+        unsigned long entry, chunk;
 
         if (dev_hpa == MM_IOMMU_TABLE_INVALID_HPA) {
                 ret = mm_iommu_adjust_locked_vm(mm, entries, true);
                 if (ret)
-                        goto unlock_exit;
+                        return ret;
 
                 locked_entries = entries;
         }
@@ -148,17 +135,27 @@ static long mm_iommu_do_alloc(struct mm_struct *mm, unsigned long ua,
         }
 
         down_read(&mm->mmap_sem);
-        ret = get_user_pages_longterm(ua, entries, FOLL_WRITE, mem->hpages, NULL);
+        chunk = (1UL << (PAGE_SHIFT + MAX_ORDER - 1)) /
+                        sizeof(struct vm_area_struct *);
+        chunk = min(chunk, entries);
+        for (entry = 0; entry < entries; entry += chunk) {
+                unsigned long n = min(entries - entry, chunk);
+
+                ret = get_user_pages_longterm(ua + (entry << PAGE_SHIFT), n,
+                                FOLL_WRITE, mem->hpages + entry, NULL);
+                if (ret == n) {
+                        pinned += n;
+                        continue;
+                }
+                if (ret > 0)
+                        pinned += ret;
+                break;
+        }
         up_read(&mm->mmap_sem);
-        if (ret != entries) {
-                /* free the reference taken */
-                for (i = 0; i < ret; i++)
-                        put_page(mem->hpages[i]);
-
-                vfree(mem->hpas);
-                kfree(mem);
-                ret = -EFAULT;
-                goto unlock_exit;
+        if (pinned != entries) {
+                if (!ret)
+                        ret = -EFAULT;
+                goto free_exit;
         }
 
         pageshift = PAGE_SHIFT;
@@ -183,21 +180,43 @@ static long mm_iommu_do_alloc(struct mm_struct *mm, unsigned long ua,
         }
 
 good_exit:
-        ret = 0;
         atomic64_set(&mem->mapped, 1);
         mem->used = 1;
         mem->ua = ua;
         mem->entries = entries;
-        *pmem = mem;
 
-        list_add_rcu(&mem->next, &mm->context.iommu_group_mem_list);
+        mutex_lock(&mem_list_mutex);
 
-unlock_exit:
-        if (locked_entries && ret)
-                mm_iommu_adjust_locked_vm(mm, locked_entries, false);
+        list_for_each_entry_rcu(mem2, &mm->context.iommu_group_mem_list, next) {
+                /* Overlap? */
+                if ((mem2->ua < (ua + (entries << PAGE_SHIFT))) &&
+                                (ua < (mem2->ua +
+                                       (mem2->entries << PAGE_SHIFT)))) {
+                        ret = -EINVAL;
+                        mutex_unlock(&mem_list_mutex);
+                        goto free_exit;
+                }
+        }
+
+        list_add_rcu(&mem->next, &mm->context.iommu_group_mem_list);
 
         mutex_unlock(&mem_list_mutex);
 
+        *pmem = mem;
+
+        return 0;
+
+free_exit:
+        /* free the reference taken */
+        for (i = 0; i < pinned; i++)
+                put_page(mem->hpages[i]);
+
+        vfree(mem->hpas);
+        kfree(mem);
+
+unlock_exit:
+        mm_iommu_adjust_locked_vm(mm, locked_entries, false);
+
         return ret;
 }
 
@@ -266,7 +285,7 @@ static void mm_iommu_release(struct mm_iommu_table_group_mem_t *mem)
 long mm_iommu_put(struct mm_struct *mm, struct mm_iommu_table_group_mem_t *mem)
 {
         long ret = 0;
-        unsigned long entries, dev_hpa;
+        unsigned long unlock_entries = 0;
 
         mutex_lock(&mem_list_mutex);
 
@@ -287,17 +306,17 @@ long mm_iommu_put(struct mm_struct *mm, struct mm_iommu_table_group_mem_t *mem)
                 goto unlock_exit;
         }
 
+        if (mem->dev_hpa == MM_IOMMU_TABLE_INVALID_HPA)
+                unlock_entries = mem->entries;
+
         /* @mapped became 0 so now mappings are disabled, release the region */
-        entries = mem->entries;
-        dev_hpa = mem->dev_hpa;
         mm_iommu_release(mem);
 
-        if (dev_hpa == MM_IOMMU_TABLE_INVALID_HPA)
-                mm_iommu_adjust_locked_vm(mm, entries, false);
-
 unlock_exit:
         mutex_unlock(&mem_list_mutex);
 
+        mm_iommu_adjust_locked_vm(mm, unlock_entries, false);
+
         return ret;
 }
 EXPORT_SYMBOL_GPL(mm_iommu_put);
diff --git a/arch/powerpc/platforms/Kconfig.cputype b/arch/powerpc/platforms/Kconfig.cputype
index 842b2c7e156a..50cd09b4e05d 100644
--- a/arch/powerpc/platforms/Kconfig.cputype
+++ b/arch/powerpc/platforms/Kconfig.cputype
@@ -324,7 +324,7 @@ config ARCH_ENABLE_SPLIT_PMD_PTLOCK
 
 config PPC_RADIX_MMU
         bool "Radix MMU Support"
-        depends on PPC_BOOK3S_64
+        depends on PPC_BOOK3S_64 && HUGETLB_PAGE
         select ARCH_HAS_GIGANTIC_PAGE if (MEMORY_ISOLATION && COMPACTION) || CMA
         default y
         help
diff --git a/arch/x86/boot/compressed/misc.c b/arch/x86/boot/compressed/misc.c
index c0d6c560df69..5a237e8dbf8d 100644
--- a/arch/x86/boot/compressed/misc.c
+++ b/arch/x86/boot/compressed/misc.c
@@ -352,7 +352,7 @@ asmlinkage __visible void *extract_kernel(void *rmode, memptr heap,
         boot_params->hdr.loadflags &= ~KASLR_FLAG;
 
         /* Save RSDP address for later use. */
-        boot_params->acpi_rsdp_addr = get_rsdp_addr();
+        /* boot_params->acpi_rsdp_addr = get_rsdp_addr(); */
 
         sanitize_boot_params(boot_params);
 
diff --git a/arch/x86/entry/vdso/vclock_gettime.c b/arch/x86/entry/vdso/vclock_gettime.c
index 007b3fe9d727..98c7d12b945c 100644
--- a/arch/x86/entry/vdso/vclock_gettime.c
+++ b/arch/x86/entry/vdso/vclock_gettime.c
@@ -29,12 +29,12 @@ extern int __vdso_gettimeofday(struct timeval *tv, struct timezone *tz);
 extern time_t __vdso_time(time_t *t);
 
 #ifdef CONFIG_PARAVIRT_CLOCK
-extern u8 pvclock_page
+extern u8 pvclock_page[PAGE_SIZE]
         __attribute__((visibility("hidden")));
 #endif
 
 #ifdef CONFIG_HYPERV_TSCPAGE
-extern u8 hvclock_page
+extern u8 hvclock_page[PAGE_SIZE]
         __attribute__((visibility("hidden")));
 #endif
 
diff --git a/arch/x86/events/intel/cstate.c b/arch/x86/events/intel/cstate.c
index 94a4b7fc75d0..d41de9af7a39 100644
--- a/arch/x86/events/intel/cstate.c
+++ b/arch/x86/events/intel/cstate.c
@@ -76,15 +76,15 @@
  *                             Scope: Package (physical package)
  *      MSR_PKG_C8_RESIDENCY:  Package C8 Residency Counter.
  *                             perf code: 0x04
- *                             Available model: HSW ULT,CNL
+ *                             Available model: HSW ULT,KBL,CNL
  *                             Scope: Package (physical package)
  *      MSR_PKG_C9_RESIDENCY:  Package C9 Residency Counter.
  *                             perf code: 0x05
- *                             Available model: HSW ULT,CNL
+ *                             Available model: HSW ULT,KBL,CNL
  *                             Scope: Package (physical package)
  *      MSR_PKG_C10_RESIDENCY: Package C10 Residency Counter.
  *                             perf code: 0x06
- *                             Available model: HSW ULT,GLM,CNL
+ *                             Available model: HSW ULT,KBL,GLM,CNL
  *                             Scope: Package (physical package)
  *
  */
@@ -566,8 +566,8 @@ static const struct x86_cpu_id intel_cstates_match[] __initconst = {
         X86_CSTATES_MODEL(INTEL_FAM6_SKYLAKE_DESKTOP, snb_cstates),
         X86_CSTATES_MODEL(INTEL_FAM6_SKYLAKE_X, snb_cstates),
 
-        X86_CSTATES_MODEL(INTEL_FAM6_KABYLAKE_MOBILE,  snb_cstates),
-        X86_CSTATES_MODEL(INTEL_FAM6_KABYLAKE_DESKTOP, snb_cstates),
+        X86_CSTATES_MODEL(INTEL_FAM6_KABYLAKE_MOBILE,  hswult_cstates),
+        X86_CSTATES_MODEL(INTEL_FAM6_KABYLAKE_DESKTOP, hswult_cstates),
 
         X86_CSTATES_MODEL(INTEL_FAM6_CANNONLAKE_MOBILE, cnl_cstates),
 
diff --git a/arch/x86/include/asm/pgtable.h b/arch/x86/include/asm/pgtable.h
index 2779ace16d23..50b3e2d963c9 100644
--- a/arch/x86/include/asm/pgtable.h
+++ b/arch/x86/include/asm/pgtable.h
@@ -46,7 +46,7 @@ void ptdump_walk_user_pgd_level_checkwx(void);
  */
 extern unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)]
         __visible;
-#define ZERO_PAGE(vaddr) (virt_to_page(empty_zero_page))
+#define ZERO_PAGE(vaddr) ((void)(vaddr),virt_to_page(empty_zero_page))
 
 extern spinlock_t pgd_lock;
 extern struct list_head pgd_list;
diff --git a/arch/x86/mm/init.c b/arch/x86/mm/init.c
index f905a2371080..8dacdb96899e 100644
--- a/arch/x86/mm/init.c
+++ b/arch/x86/mm/init.c
@@ -5,6 +5,7 @@
 #include <linux/memblock.h>
 #include <linux/swapfile.h>
 #include <linux/swapops.h>
+#include <linux/kmemleak.h>
 
 #include <asm/set_memory.h>
 #include <asm/e820/api.h>
@@ -766,6 +767,11 @@ void free_init_pages(const char *what, unsigned long begin, unsigned long end)
         if (debug_pagealloc_enabled()) {
                 pr_info("debug: unmapping init [mem %#010lx-%#010lx]\n",
                         begin, end - 1);
+                /*
+                 * Inform kmemleak about the hole in the memory since the
+                 * corresponding pages will be unmapped.
+                 */
+                kmemleak_free_part((void *)begin, end - begin);
                 set_memory_np(begin, (end - begin) >> PAGE_SHIFT);
         } else {
                 /*
diff --git a/crypto/lrw.c b/crypto/lrw.c
index 0430ccd08728..08a0e458bc3e 100644
--- a/crypto/lrw.c
+++ b/crypto/lrw.c
@@ -212,8 +212,12 @@ static void crypt_done(struct crypto_async_request *areq, int err)
 {
         struct skcipher_request *req = areq->data;
 
-        if (!err)
+        if (!err) {
+                struct rctx *rctx = skcipher_request_ctx(req);
+
+                rctx->subreq.base.flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
                 err = xor_tweak_post(req);
+        }
 
         skcipher_request_complete(req, err);
 }
diff --git a/crypto/xts.c b/crypto/xts.c
index 847f54f76789..2f948328cabb 100644
--- a/crypto/xts.c
+++ b/crypto/xts.c
@@ -137,8 +137,12 @@ static void crypt_done(struct crypto_async_request *areq, int err)
 {
         struct skcipher_request *req = areq->data;
 
-        if (!err)
+        if (!err) {
+                struct rctx *rctx = skcipher_request_ctx(req);
+
+                rctx->subreq.base.flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
                 err = xor_tweak_post(req);
+        }
 
         skcipher_request_complete(req, err);
 }
diff --git a/drivers/acpi/acpica/evgpe.c b/drivers/acpi/acpica/evgpe.c
index 5e9d7348c16f..62d3aa74277b 100644
--- a/drivers/acpi/acpica/evgpe.c
+++ b/drivers/acpi/acpica/evgpe.c
@@ -81,12 +81,8 @@ acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
 
         ACPI_FUNCTION_TRACE(ev_enable_gpe);
 
-        /* Clear the GPE status */
-        status = acpi_hw_clear_gpe(gpe_event_info);
-        if (ACPI_FAILURE(status))
-                return_ACPI_STATUS(status);
-
         /* Enable the requested GPE */
+
         status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_ENABLE);
         return_ACPI_STATUS(status);
 }
diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c
index 399cad7daae7..d58a359a6622 100644
--- a/drivers/block/zram/zram_drv.c
+++ b/drivers/block/zram/zram_drv.c
@@ -774,18 +774,18 @@ struct zram_work {
         struct zram *zram;
         unsigned long entry;
         struct bio *bio;
+        struct bio_vec bvec;
 };
 
 #if PAGE_SIZE != 4096
 static void zram_sync_read(struct work_struct *work)
 {
-        struct bio_vec bvec;
         struct zram_work *zw = container_of(work, struct zram_work, work);
         struct zram *zram = zw->zram;
         unsigned long entry = zw->entry;
         struct bio *bio = zw->bio;
 
-        read_from_bdev_async(zram, &bvec, entry, bio);
+        read_from_bdev_async(zram, &zw->bvec, entry, bio);
 }
 
 /*
@@ -798,6 +798,7 @@ static int read_from_bdev_sync(struct zram *zram, struct bio_vec *bvec,
 {
         struct zram_work work;
 
+        work.bvec = *bvec;
         work.zram = zram;
         work.entry = entry;
         work.bio = bio;
diff --git a/drivers/dma/bcm2835-dma.c b/drivers/dma/bcm2835-dma.c
index ec8a291d62ba..54093ffd0aef 100644
--- a/drivers/dma/bcm2835-dma.c
+++ b/drivers/dma/bcm2835-dma.c
@@ -671,7 +671,7 @@ static struct dma_async_tx_descriptor *bcm2835_dma_prep_slave_sg(
         d = bcm2835_dma_create_cb_chain(chan, direction, false,
                                         info, extra,
                                         frames, src, dst, 0, 0,
-                                        GFP_KERNEL);
+                                        GFP_NOWAIT);
         if (!d)
                 return NULL;
 
diff --git a/drivers/dma/mediatek/mtk-cqdma.c b/drivers/dma/mediatek/mtk-cqdma.c
index 131f3974740d..814853842e29 100644
--- a/drivers/dma/mediatek/mtk-cqdma.c
+++ b/drivers/dma/mediatek/mtk-cqdma.c
@@ -253,7 +253,7 @@ static void mtk_cqdma_start(struct mtk_cqdma_pchan *pc,
 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
         mtk_dma_set(pc, MTK_CQDMA_DST2, cvd->dest >> MTK_CQDMA_ADDR2_SHFIT);
 #else
-        mtk_dma_set(pc, MTK_CQDMA_SRC2, 0);
+        mtk_dma_set(pc, MTK_CQDMA_DST2, 0);
 #endif
 
         /* setup the length */
diff --git a/drivers/dma/sh/rcar-dmac.c b/drivers/dma/sh/rcar-dmac.c
index 2b4f25698169..e2a5398f89b5 100644
--- a/drivers/dma/sh/rcar-dmac.c
+++ b/drivers/dma/sh/rcar-dmac.c
@@ -1282,6 +1282,9 @@ static unsigned int rcar_dmac_chan_get_residue(struct rcar_dmac_chan *chan,
         enum dma_status status;
         unsigned int residue = 0;
         unsigned int dptr = 0;
+        unsigned int chcrb;
+        unsigned int tcrb;
+        unsigned int i;
 
         if (!desc)
                 return 0;
@@ -1330,14 +1333,31 @@ static unsigned int rcar_dmac_chan_get_residue(struct rcar_dmac_chan *chan,
         }
 
         /*
+         * We need to read two registers.
+         * Make sure the control register does not skip to next chunk
+         * while reading the counter.
+         * Trying it 3 times should be enough: Initial read, retry, retry
+         * for the paranoid.
+         */
+        for (i = 0; i < 3; i++) {
+                chcrb = rcar_dmac_chan_read(chan, RCAR_DMACHCRB) &
+                                            RCAR_DMACHCRB_DPTR_MASK;
+                tcrb = rcar_dmac_chan_read(chan, RCAR_DMATCRB);
+                /* Still the same? */
+                if (chcrb == (rcar_dmac_chan_read(chan, RCAR_DMACHCRB) &
+                              RCAR_DMACHCRB_DPTR_MASK))
+                        break;
+        }
+        WARN_ONCE(i >= 3, "residue might be not continuous!");
+
+        /*
          * In descriptor mode the descriptor running pointer is not maintained
          * by the interrupt handler, find the running descriptor from the
          * descriptor pointer field in the CHCRB register. In non-descriptor
          * mode just use the running descriptor pointer.
          */
         if (desc->hwdescs.use) {
-                dptr = (rcar_dmac_chan_read(chan, RCAR_DMACHCRB) &
-                        RCAR_DMACHCRB_DPTR_MASK) >> RCAR_DMACHCRB_DPTR_SHIFT;
+                dptr = chcrb >> RCAR_DMACHCRB_DPTR_SHIFT;
                 if (dptr == 0)
                         dptr = desc->nchunks;
                 dptr--;
@@ -1355,7 +1375,7 @@ static unsigned int rcar_dmac_chan_get_residue(struct rcar_dmac_chan *chan,
         }
 
         /* Add the residue for the current chunk. */
-        residue += rcar_dmac_chan_read(chan, RCAR_DMATCRB) << desc->xfer_shift;
+        residue += tcrb << desc->xfer_shift;
 
         return residue;
 }
@@ -1368,6 +1388,7 @@ static enum dma_status rcar_dmac_tx_status(struct dma_chan *chan,
         enum dma_status status;
         unsigned long flags;
         unsigned int residue;
+        bool cyclic;
 
         status = dma_cookie_status(chan, cookie, txstate);
         if (status == DMA_COMPLETE || !txstate)
@@ -1375,10 +1396,11 @@ static enum dma_status rcar_dmac_tx_status(struct dma_chan *chan,
 
         spin_lock_irqsave(&rchan->lock, flags);
         residue = rcar_dmac_chan_get_residue(rchan, cookie);
+        cyclic = rchan->desc.running ? rchan->desc.running->cyclic : false;
         spin_unlock_irqrestore(&rchan->lock, flags);
 
         /* if there's no residue, the cookie is complete */
-        if (!residue)
+        if (!residue && !cyclic)
                 return DMA_COMPLETE;
 
         dma_set_residue(txstate, residue);
diff --git a/drivers/gpio/gpio-eic-sprd.c b/drivers/gpio/gpio-eic-sprd.c
index f0223cee9774..77092268ee95 100644
--- a/drivers/gpio/gpio-eic-sprd.c
+++ b/drivers/gpio/gpio-eic-sprd.c
@@ -414,6 +414,7 @@ static int sprd_eic_irq_set_type(struct irq_data *data, unsigned int flow_type)
                         irq_set_handler_locked(data, handle_edge_irq);
                         break;
                 case IRQ_TYPE_EDGE_BOTH:
+                        sprd_eic_update(chip, offset, SPRD_EIC_SYNC_INTMODE, 0);
                         sprd_eic_update(chip, offset, SPRD_EIC_SYNC_INTBOTH, 1);
                         irq_set_handler_locked(data, handle_edge_irq);
                         break;
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index 0495bf1d480a..bca3e7740ef6 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -1379,7 +1379,7 @@ int gpiochip_add_data_with_key(struct gpio_chip *chip, void *data,
 
         status = gpiochip_add_irqchip(chip, lock_key, request_key);
         if (status)
-                goto err_remove_chip;
+                goto err_free_gpiochip_mask;
 
         status = of_gpiochip_add(chip);
         if (status)
@@ -1387,7 +1387,7 @@ int gpiochip_add_data_with_key(struct gpio_chip *chip, void *data,
 
         status = gpiochip_init_valid_mask(chip);
         if (status)
-                goto err_remove_chip;
+                goto err_remove_of_chip;
 
         for (i = 0; i < chip->ngpio; i++) {
                 struct gpio_desc *desc = &gdev->descs[i];
@@ -1415,14 +1415,18 @@ int gpiochip_add_data_with_key(struct gpio_chip *chip, void *data,
         if (gpiolib_initialized) {
                 status = gpiochip_setup_dev(gdev);
                 if (status)
-                        goto err_remove_chip;
+                        goto err_remove_acpi_chip;
         }
         return 0;
 
-err_remove_chip:
+err_remove_acpi_chip:
         acpi_gpiochip_remove(chip);
+err_remove_of_chip:
         gpiochip_free_hogs(chip);
         of_gpiochip_remove(chip);
+err_remove_chip:
+        gpiochip_irqchip_remove(chip);
+err_free_gpiochip_mask:
         gpiochip_free_valid_mask(chip);
 err_remove_irqchip_mask:
         gpiochip_irqchip_free_valid_mask(chip);
diff --git a/drivers/gpu/drm/bridge/synopsys/dw-hdmi.c b/drivers/gpu/drm/bridge/synopsys/dw-hdmi.c
index db761329a1e3..ab7968c8f6a2 100644
--- a/drivers/gpu/drm/bridge/synopsys/dw-hdmi.c
+++ b/drivers/gpu/drm/bridge/synopsys/dw-hdmi.c
@@ -1046,6 +1046,10 @@ static bool dw_hdmi_support_scdc(struct dw_hdmi *hdmi)
         if (hdmi->version < 0x200a)
                 return false;
 
+        /* Disable if no DDC bus */
+        if (!hdmi->ddc)
+                return false;
+
         /* Disable if SCDC is not supported, or if an HF-VSDB block is absent */
         if (!display->hdmi.scdc.supported ||
             !display->hdmi.scdc.scrambling.supported)
@@ -1684,13 +1688,13 @@ static void hdmi_av_composer(struct dw_hdmi *hdmi,
                          * Source Devices compliant shall set the
                          * Source Version = 1.
                          */
-                        drm_scdc_readb(&hdmi->i2c->adap, SCDC_SINK_VERSION,
+                        drm_scdc_readb(hdmi->ddc, SCDC_SINK_VERSION,
                                        &bytes);
-                        drm_scdc_writeb(&hdmi->i2c->adap, SCDC_SOURCE_VERSION,
+                        drm_scdc_writeb(hdmi->ddc, SCDC_SOURCE_VERSION,
                                 min_t(u8, bytes, SCDC_MIN_SOURCE_VERSION));
 
                         /* Enabled Scrambling in the Sink */
-                        drm_scdc_set_scrambling(&hdmi->i2c->adap, 1);
+                        drm_scdc_set_scrambling(hdmi->ddc, 1);
 
                         /*
                          * To activate the scrambler feature, you must ensure
@@ -1706,7 +1710,7 @@ static void hdmi_av_composer(struct dw_hdmi *hdmi,
                         hdmi_writeb(hdmi, 0, HDMI_FC_SCRAMBLER_CTRL);
                         hdmi_writeb(hdmi, (u8)~HDMI_MC_SWRSTZ_TMDSSWRST_REQ,
                                     HDMI_MC_SWRSTZ);
-                        drm_scdc_set_scrambling(&hdmi->i2c->adap, 0);
+                        drm_scdc_set_scrambling(hdmi->ddc, 0);
                 }
         }
 
@@ -1800,6 +1804,8 @@ static void dw_hdmi_clear_overflow(struct dw_hdmi *hdmi)
          * iteration for others.
          * The Amlogic Meson GX SoCs (v2.01a) have been identified as needing
          * the workaround with a single iteration.
+         * The Rockchip RK3288 SoC (v2.00a) and RK3328/RK3399 SoCs (v2.11a) have
+         * been identified as needing the workaround with a single iteration.
          */
 
         switch (hdmi->version) {
@@ -1808,7 +1814,9 @@ static void dw_hdmi_clear_overflow(struct dw_hdmi *hdmi)
                 break;
         case 0x131a:
         case 0x132a:
+        case 0x200a:
         case 0x201a:
+        case 0x211a:
         case 0x212a:
                 count = 1;
                 break;
diff --git a/drivers/gpu/drm/i915/intel_ddi.c b/drivers/gpu/drm/i915/intel_ddi.c
index ab4e60dfd6a3..98cea1f4b3bf 100644
--- a/drivers/gpu/drm/i915/intel_ddi.c
+++ b/drivers/gpu/drm/i915/intel_ddi.c
@@ -3862,14 +3862,16 @@ static int intel_ddi_compute_config(struct intel_encoder *encoder,
                 ret = intel_hdmi_compute_config(encoder, pipe_config, conn_state);
         else
                 ret = intel_dp_compute_config(encoder, pipe_config, conn_state);
+        if (ret)
+                return ret;
 
-        if (IS_GEN9_LP(dev_priv) && ret)
+        if (IS_GEN9_LP(dev_priv))
                 pipe_config->lane_lat_optim_mask =
                         bxt_ddi_phy_calc_lane_lat_optim_mask(pipe_config->lane_count);
 
         intel_ddi_compute_min_voltage_level(dev_priv, pipe_config);
 
-        return ret;
+        return 0;
 
 }
 
diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c
index 8891f29a8c7f..48da4a969a0a 100644
--- a/drivers/gpu/drm/i915/intel_dp.c
+++ b/drivers/gpu/drm/i915/intel_dp.c
@@ -1886,6 +1886,9 @@ static int intel_dp_dsc_compute_config(struct intel_dp *intel_dp,
         int pipe_bpp;
         int ret;
 
+        pipe_config->fec_enable = !intel_dp_is_edp(intel_dp) &&
+                intel_dp_supports_fec(intel_dp, pipe_config);
+
         if (!intel_dp_supports_dsc(intel_dp, pipe_config))
                 return -EINVAL;
 
@@ -2116,9 +2119,6 @@ intel_dp_compute_config(struct intel_encoder *encoder,
         if (adjusted_mode->flags & DRM_MODE_FLAG_DBLCLK)
                 return -EINVAL;
 
-        pipe_config->fec_enable = !intel_dp_is_edp(intel_dp) &&
-                                  intel_dp_supports_fec(intel_dp, pipe_config);
-
         ret = intel_dp_compute_link_config(encoder, pipe_config, conn_state);
         if (ret < 0)
                 return ret;
diff --git a/drivers/gpu/drm/imx/ipuv3-crtc.c b/drivers/gpu/drm/imx/ipuv3-crtc.c
index ec3602ebbc1c..54011df8c2e8 100644
--- a/drivers/gpu/drm/imx/ipuv3-crtc.c
+++ b/drivers/gpu/drm/imx/ipuv3-crtc.c
@@ -71,7 +71,7 @@ static void ipu_crtc_disable_planes(struct ipu_crtc *ipu_crtc,
         if (disable_partial)
                 ipu_plane_disable(ipu_crtc->plane[1], true);
         if (disable_full)
-                ipu_plane_disable(ipu_crtc->plane[0], false);
+                ipu_plane_disable(ipu_crtc->plane[0], true);
 }
 
 static void ipu_crtc_atomic_disable(struct drm_crtc *crtc,
diff --git a/drivers/gpu/drm/scheduler/sched_main.c b/drivers/gpu/drm/scheduler/sched_main.c
index 19fc601c9eeb..a1bec2779e76 100644
--- a/drivers/gpu/drm/scheduler/sched_main.c
+++ b/drivers/gpu/drm/scheduler/sched_main.c
@@ -366,10 +366,9 @@ void drm_sched_increase_karma(struct drm_sched_job *bad)
 EXPORT_SYMBOL(drm_sched_increase_karma);
 
 /**
- * drm_sched_hw_job_reset - stop the scheduler if it contains the bad job
+ * drm_sched_stop - stop the scheduler
  *
  * @sched: scheduler instance
- * @bad: bad scheduler job
  *
  */
 void drm_sched_stop(struct drm_gpu_scheduler *sched)
diff --git a/drivers/gpu/drm/sun4i/sun4i_drv.c b/drivers/gpu/drm/sun4i/sun4i_drv.c
index 3ebd9f5e2719..29258b404e54 100644
--- a/drivers/gpu/drm/sun4i/sun4i_drv.c
+++ b/drivers/gpu/drm/sun4i/sun4i_drv.c
@@ -16,6 +16,7 @@
 #include <linux/of_reserved_mem.h>
 
 #include <drm/drmP.h>
+#include <drm/drm_atomic_helper.h>
 #include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_fb_helper.h>
 #include <drm/drm_gem_cma_helper.h>
@@ -85,6 +86,8 @@ static int sun4i_drv_bind(struct device *dev)
                 ret = -ENOMEM;
                 goto free_drm;
         }
+
+        dev_set_drvdata(dev, drm);
         drm->dev_private = drv;
         INIT_LIST_HEAD(&drv->frontend_list);
         INIT_LIST_HEAD(&drv->engine_list);
@@ -144,8 +147,12 @@ static void sun4i_drv_unbind(struct device *dev)
 
         drm_dev_unregister(drm);
         drm_kms_helper_poll_fini(drm);
+        drm_atomic_helper_shutdown(drm);
         drm_mode_config_cleanup(drm);
+
+        component_unbind_all(dev, NULL);
         of_reserved_mem_device_release(dev);
+
         drm_dev_put(drm);
 }
 
@@ -395,6 +402,8 @@ static int sun4i_drv_probe(struct platform_device *pdev)
 
 static int sun4i_drv_remove(struct platform_device *pdev)
 {
+        component_master_del(&pdev->dev, &sun4i_drv_master_ops);
+
         return 0;
 }
 
diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c
index 0fa5034b9f9e..1a01669b159a 100644
--- a/drivers/gpu/drm/ttm/ttm_bo.c
+++ b/drivers/gpu/drm/ttm/ttm_bo.c
@@ -49,9 +49,8 @@ static void ttm_bo_global_kobj_release(struct kobject *kobj);
  * ttm_global_mutex - protecting the global BO state
  */
 DEFINE_MUTEX(ttm_global_mutex);
-struct ttm_bo_global ttm_bo_glob = {
-        .use_count = 0
-};
+unsigned ttm_bo_glob_use_count;
+struct ttm_bo_global ttm_bo_glob;
 
 static struct attribute ttm_bo_count = {
         .name = "bo_count",
@@ -1531,12 +1530,13 @@ static void ttm_bo_global_release(void)
         struct ttm_bo_global *glob = &ttm_bo_glob;
 
         mutex_lock(&ttm_global_mutex);
-        if (--glob->use_count > 0)
+        if (--ttm_bo_glob_use_count > 0)
                 goto out;
 
         kobject_del(&glob->kobj);
         kobject_put(&glob->kobj);
         ttm_mem_global_release(&ttm_mem_glob);
+        memset(glob, 0, sizeof(*glob));
 out:
         mutex_unlock(&ttm_global_mutex);
 }
@@ -1548,7 +1548,7 @@ static int ttm_bo_global_init(void)
         unsigned i;
 
         mutex_lock(&ttm_global_mutex);
-        if (++glob->use_count > 1)
+        if (++ttm_bo_glob_use_count > 1)
                 goto out;
 
         ret = ttm_mem_global_init(&ttm_mem_glob);
diff --git a/drivers/gpu/drm/ttm/ttm_memory.c b/drivers/gpu/drm/ttm/ttm_memory.c
index f1567c353b54..9a0909decb36 100644
--- a/drivers/gpu/drm/ttm/ttm_memory.c
+++ b/drivers/gpu/drm/ttm/ttm_memory.c
@@ -461,8 +461,8 @@ out_no_zone:
 
 void ttm_mem_global_release(struct ttm_mem_global *glob)
 {
-        unsigned int i;
         struct ttm_mem_zone *zone;
+        unsigned int i;
 
         /* let the page allocator first stop the shrink work. */
         ttm_page_alloc_fini();
@@ -475,9 +475,10 @@ void ttm_mem_global_release(struct ttm_mem_global *glob)
                 zone = glob->zones[i];
                 kobject_del(&zone->kobj);
                 kobject_put(&zone->kobj);
-                        }
+        }
         kobject_del(&glob->kobj);
         kobject_put(&glob->kobj);
+        memset(glob, 0, sizeof(*glob));
 }
 
 static void ttm_check_swapping(struct ttm_mem_global *glob)
diff --git a/drivers/gpu/drm/vc4/vc4_crtc.c b/drivers/gpu/drm/vc4/vc4_crtc.c
index 730008d3da76..1baa10e94484 100644
--- a/drivers/gpu/drm/vc4/vc4_crtc.c
+++ b/drivers/gpu/drm/vc4/vc4_crtc.c
@@ -1042,7 +1042,7 @@ static void
 vc4_crtc_reset(struct drm_crtc *crtc)
 {
         if (crtc->state)
-                __drm_atomic_helper_crtc_destroy_state(crtc->state);
+                vc4_crtc_destroy_state(crtc, crtc->state);
 
         crtc->state = kzalloc(sizeof(struct vc4_crtc_state), GFP_KERNEL);
         if (crtc->state)
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
index 6165fe2c4504..1bfa353d995c 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
@@ -546,29 +546,13 @@ static void vmw_get_initial_size(struct vmw_private *dev_priv)
 }
 
 /**
- * vmw_assume_iommu - Figure out whether coherent dma-remapping might be
- * taking place.
- * @dev: Pointer to the struct drm_device.
- *
- * Return: true if iommu present, false otherwise.
- */
-static bool vmw_assume_iommu(struct drm_device *dev)
-{
-        const struct dma_map_ops *ops = get_dma_ops(dev->dev);
-
-        return !dma_is_direct(ops) && ops &&
-                ops->map_page != dma_direct_map_page;
-}
-
-/**
  * vmw_dma_select_mode - Determine how DMA mappings should be set up for this
  * system.
  *
  * @dev_priv: Pointer to a struct vmw_private
  *
- * This functions tries to determine the IOMMU setup and what actions
- * need to be taken by the driver to make system pages visible to the
- * device.
+ * This functions tries to determine what actions need to be taken by the
+ * driver to make system pages visible to the device.
  * If this function decides that DMA is not possible, it returns -EINVAL.
  * The driver may then try to disable features of the device that require
  * DMA.
@@ -578,23 +562,16 @@ static int vmw_dma_select_mode(struct vmw_private *dev_priv)
         static const char *names[vmw_dma_map_max] = {
                 [vmw_dma_phys] = "Using physical TTM page addresses.",
                 [vmw_dma_alloc_coherent] = "Using coherent TTM pages.",
-                [vmw_dma_map_populate] = "Keeping DMA mappings.",
+                [vmw_dma_map_populate] = "Caching DMA mappings.",
                 [vmw_dma_map_bind] = "Giving up DMA mappings early."};
 
         if (vmw_force_coherent)
                 dev_priv->map_mode = vmw_dma_alloc_coherent;
-        else if (vmw_assume_iommu(dev_priv->dev))
-                dev_priv->map_mode = vmw_dma_map_populate;
-        else if (!vmw_force_iommu)
-                dev_priv->map_mode = vmw_dma_phys;
-        else if (IS_ENABLED(CONFIG_SWIOTLB) && swiotlb_nr_tbl())
-                dev_priv->map_mode = vmw_dma_alloc_coherent;
+        else if (vmw_restrict_iommu)
+                dev_priv->map_mode = vmw_dma_map_bind;
         else
                 dev_priv->map_mode = vmw_dma_map_populate;
 
-        if (dev_priv->map_mode == vmw_dma_map_populate && vmw_restrict_iommu)
-                dev_priv->map_mode = vmw_dma_map_bind;
-
         /* No TTM coherent page pool? FIXME: Ask TTM instead! */
         if (!(IS_ENABLED(CONFIG_SWIOTLB) || IS_ENABLED(CONFIG_INTEL_IOMMU)) &&
             (dev_priv->map_mode == vmw_dma_alloc_coherent))
diff --git a/drivers/gpu/ipu-v3/ipu-dp.c b/drivers/gpu/ipu-v3/ipu-dp.c
index 9b2b3fa479c4..5e44ff1f2085 100644
--- a/drivers/gpu/ipu-v3/ipu-dp.c
+++ b/drivers/gpu/ipu-v3/ipu-dp.c
@@ -195,7 +195,8 @@ int ipu_dp_setup_channel(struct ipu_dp *dp,
                 ipu_dp_csc_init(flow, flow->foreground.in_cs, flow->out_cs,
                                 DP_COM_CONF_CSC_DEF_BOTH);
         } else {
-                if (flow->foreground.in_cs == flow->out_cs)
+                if (flow->foreground.in_cs == IPUV3_COLORSPACE_UNKNOWN ||
+                    flow->foreground.in_cs == flow->out_cs)
                         /*
                          * foreground identical to output, apply color
                          * conversion on background
@@ -261,6 +262,8 @@ void ipu_dp_disable_channel(struct ipu_dp *dp, bool sync)
         struct ipu_dp_priv *priv = flow->priv;
         u32 reg, csc;
 
+        dp->in_cs = IPUV3_COLORSPACE_UNKNOWN;
+
         if (!dp->foreground)
                 return;
 
@@ -268,8 +271,9 @@ void ipu_dp_disable_channel(struct ipu_dp *dp, bool sync)
 
         reg = readl(flow->base + DP_COM_CONF);
         csc = reg & DP_COM_CONF_CSC_DEF_MASK;
-        if (csc == DP_COM_CONF_CSC_DEF_FG)
-                reg &= ~DP_COM_CONF_CSC_DEF_MASK;
+        reg &= ~DP_COM_CONF_CSC_DEF_MASK;
+        if (csc == DP_COM_CONF_CSC_DEF_BOTH || csc == DP_COM_CONF_CSC_DEF_BG)
+                reg |= DP_COM_CONF_CSC_DEF_BG;
 
         reg &= ~DP_COM_CONF_FG_EN;
         writel(reg, flow->base + DP_COM_CONF);
@@ -347,6 +351,8 @@ int ipu_dp_init(struct ipu_soc *ipu, struct device *dev, unsigned long base)
         mutex_init(&priv->mutex);
 
         for (i = 0; i < IPUV3_NUM_FLOWS; i++) {
+                priv->flow[i].background.in_cs = IPUV3_COLORSPACE_UNKNOWN;
+                priv->flow[i].foreground.in_cs = IPUV3_COLORSPACE_UNKNOWN;
                 priv->flow[i].foreground.foreground = true;
                 priv->flow[i].base = priv->base + ipu_dp_flow_base[i];
                 priv->flow[i].priv = priv;
diff --git a/drivers/i2c/i2c-core-base.c b/drivers/i2c/i2c-core-base.c
index 38af18645133..c480ca385ffb 100644
--- a/drivers/i2c/i2c-core-base.c
+++ b/drivers/i2c/i2c-core-base.c
@@ -185,7 +185,7 @@ static int i2c_generic_bus_free(struct i2c_adapter *adap)
 int i2c_generic_scl_recovery(struct i2c_adapter *adap)
 {
         struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
-        int i = 0, scl = 1, ret;
+        int i = 0, scl = 1, ret = 0;
 
         if (bri->prepare_recovery)
                 bri->prepare_recovery(adap);
diff --git a/drivers/infiniband/core/uverbs.h b/drivers/infiniband/core/uverbs.h
index ea0bc6885517..32cc8fe7902f 100644
--- a/drivers/infiniband/core/uverbs.h
+++ b/drivers/infiniband/core/uverbs.h
@@ -160,6 +160,7 @@ struct ib_uverbs_file {
 
         struct mutex umap_lock;
         struct list_head umaps;
+        struct page *disassociate_page;
 
         struct idr              idr;
         /* spinlock protects write access to idr */
diff --git a/drivers/infiniband/core/uverbs_main.c b/drivers/infiniband/core/uverbs_main.c
index f2e7ffe6fc54..c489f545baae 100644
--- a/drivers/infiniband/core/uverbs_main.c
+++ b/drivers/infiniband/core/uverbs_main.c
@@ -208,6 +208,9 @@ void ib_uverbs_release_file(struct kref *ref)
                 kref_put(&file->async_file->ref,
                          ib_uverbs_release_async_event_file);
         put_device(&file->device->dev);
+
+        if (file->disassociate_page)
+                __free_pages(file->disassociate_page, 0);
         kfree(file);
 }
 
@@ -877,9 +880,50 @@ static void rdma_umap_close(struct vm_area_struct *vma)
         kfree(priv);
 }
 
+/*
+ * Once the zap_vma_ptes has been called touches to the VMA will come here and
+ * we return a dummy writable zero page for all the pfns.
+ */
+static vm_fault_t rdma_umap_fault(struct vm_fault *vmf)
+{
+        struct ib_uverbs_file *ufile = vmf->vma->vm_file->private_data;
+        struct rdma_umap_priv *priv = vmf->vma->vm_private_data;
+        vm_fault_t ret = 0;
+
+        if (!priv)
+                return VM_FAULT_SIGBUS;
+
+        /* Read only pages can just use the system zero page. */
+        if (!(vmf->vma->vm_flags & (VM_WRITE | VM_MAYWRITE))) {
+                vmf->page = ZERO_PAGE(vmf->address);
+                get_page(vmf->page);
+                return 0;
+        }
+
+        mutex_lock(&ufile->umap_lock);
+        if (!ufile->disassociate_page)
+                ufile->disassociate_page =
+                        alloc_pages(vmf->gfp_mask | __GFP_ZERO, 0);
+
+        if (ufile->disassociate_page) {
+                /*
+                 * This VMA is forced to always be shared so this doesn't have
+                 * to worry about COW.
+                 */
+                vmf->page = ufile->disassociate_page;
+                get_page(vmf->page);
+        } else {
+                ret = VM_FAULT_SIGBUS;
+        }
+        mutex_unlock(&ufile->umap_lock);
+
+        return ret;
+}
+
 static const struct vm_operations_struct rdma_umap_ops = {
         .open = rdma_umap_open,
         .close = rdma_umap_close,
+        .fault = rdma_umap_fault,
 };
 
 static struct rdma_umap_priv *rdma_user_mmap_pre(struct ib_ucontext *ucontext,
@@ -889,6 +933,9 @@ static struct rdma_umap_priv *rdma_user_mmap_pre(struct ib_ucontext *ucontext,
         struct ib_uverbs_file *ufile = ucontext->ufile;
         struct rdma_umap_priv *priv;
 
+        if (!(vma->vm_flags & VM_SHARED))
+                return ERR_PTR(-EINVAL);
+
         if (vma->vm_end - vma->vm_start != size)
                 return ERR_PTR(-EINVAL);
 
@@ -992,7 +1039,7 @@ void uverbs_user_mmap_disassociate(struct ib_uverbs_file *ufile)
                  * at a time to get the lock ordering right. Typically there
                  * will only be one mm, so no big deal.
                  */
-                down_write(&mm->mmap_sem);
+                down_read(&mm->mmap_sem);
                 if (!mmget_still_valid(mm))
                         goto skip_mm;
                 mutex_lock(&ufile->umap_lock);
@@ -1006,11 +1053,10 @@ void uverbs_user_mmap_disassociate(struct ib_uverbs_file *ufile)
 
                         zap_vma_ptes(vma, vma->vm_start,
                                      vma->vm_end - vma->vm_start);
-                        vma->vm_flags &= ~(VM_SHARED | VM_MAYSHARE);
                 }
                 mutex_unlock(&ufile->umap_lock);
         skip_mm:
-                up_write(&mm->mmap_sem);
+                up_read(&mm->mmap_sem);
                 mmput(mm);
         }
 }
diff --git a/drivers/infiniband/hw/hns/hns_roce_qp.c b/drivers/infiniband/hw/hns/hns_roce_qp.c
index 66cdf625534f..60cf9f03e941 100644
--- a/drivers/infiniband/hw/hns/hns_roce_qp.c
+++ b/drivers/infiniband/hw/hns/hns_roce_qp.c
@@ -533,7 +533,7 @@ static int hns_roce_set_kernel_sq_size(struct hns_roce_dev *hr_dev,
 
 static int hns_roce_qp_has_sq(struct ib_qp_init_attr *attr)
 {
-        if (attr->qp_type == IB_QPT_XRC_TGT)
+        if (attr->qp_type == IB_QPT_XRC_TGT || !attr->cap.max_send_wr)
                 return 0;
 
         return 1;
diff --git a/drivers/infiniband/hw/mlx5/main.c b/drivers/infiniband/hw/mlx5/main.c
index 0845e95d2d11..347e3cac254e 100644
--- a/drivers/infiniband/hw/mlx5/main.c
+++ b/drivers/infiniband/hw/mlx5/main.c
@@ -1119,6 +1119,8 @@ static int mlx5_ib_query_device(struct ib_device *ibdev,
                 if (MLX5_CAP_GEN(mdev, qp_packet_based))
                         resp.flags |=
                                 MLX5_IB_QUERY_DEV_RESP_PACKET_BASED_CREDIT_MODE;
+
+                resp.flags |= MLX5_IB_QUERY_DEV_RESP_FLAGS_SCAT2CQE_DCT;
         }
 
         if (field_avail(typeof(resp), sw_parsing_caps,
@@ -2066,6 +2068,7 @@ static int mlx5_ib_mmap_clock_info_page(struct mlx5_ib_dev *dev,
 
         if (vma->vm_flags & VM_WRITE)
                 return -EPERM;
+        vma->vm_flags &= ~VM_MAYWRITE;
 
         if (!dev->mdev->clock_info_page)
                 return -EOPNOTSUPP;
@@ -2231,19 +2234,18 @@ static int mlx5_ib_mmap(struct ib_ucontext *ibcontext, struct vm_area_struct *vm
 
                 if (vma->vm_flags & VM_WRITE)
                         return -EPERM;
+                vma->vm_flags &= ~VM_MAYWRITE;
 
                 /* Don't expose to user-space information it shouldn't have */
                 if (PAGE_SIZE > 4096)
                         return -EOPNOTSUPP;
 
-                vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
                 pfn = (dev->mdev->iseg_base +
                        offsetof(struct mlx5_init_seg, internal_timer_h)) >>
                         PAGE_SHIFT;
-                if (io_remap_pfn_range(vma, vma->vm_start, pfn,
-                                       PAGE_SIZE, vma->vm_page_prot))
-                        return -EAGAIN;
-                break;
+                return rdma_user_mmap_io(&context->ibucontext, vma, pfn,
+                                         PAGE_SIZE,
+                                         pgprot_noncached(vma->vm_page_prot));
         case MLX5_IB_MMAP_CLOCK_INFO:
                 return mlx5_ib_mmap_clock_info_page(dev, vma, context);
 
diff --git a/drivers/infiniband/hw/mlx5/qp.c b/drivers/infiniband/hw/mlx5/qp.c
index ef7d69269a88..fc67d78ca959 100644
--- a/drivers/infiniband/hw/mlx5/qp.c
+++ b/drivers/infiniband/hw/mlx5/qp.c
@@ -1818,13 +1818,16 @@ static void configure_responder_scat_cqe(struct ib_qp_init_attr *init_attr,
 
         rcqe_sz = mlx5_ib_get_cqe_size(init_attr->recv_cq);
 
-        if (rcqe_sz == 128) {
-                MLX5_SET(qpc, qpc, cs_res, MLX5_RES_SCAT_DATA64_CQE);
+        if (init_attr->qp_type == MLX5_IB_QPT_DCT) {
+                if (rcqe_sz == 128)
+                        MLX5_SET(dctc, qpc, cs_res, MLX5_RES_SCAT_DATA64_CQE);
+
                 return;
         }
 
-        if (init_attr->qp_type != MLX5_IB_QPT_DCT)
-                MLX5_SET(qpc, qpc, cs_res, MLX5_RES_SCAT_DATA32_CQE);
+        MLX5_SET(qpc, qpc, cs_res,
+                 rcqe_sz == 128 ? MLX5_RES_SCAT_DATA64_CQE :
+                                  MLX5_RES_SCAT_DATA32_CQE);
 }
 
 static void configure_requester_scat_cqe(struct mlx5_ib_dev *dev,
diff --git a/drivers/infiniband/sw/rdmavt/mr.c b/drivers/infiniband/sw/rdmavt/mr.c
index 728795043496..0bb6e39dd03a 100644
--- a/drivers/infiniband/sw/rdmavt/mr.c
+++ b/drivers/infiniband/sw/rdmavt/mr.c
@@ -608,11 +608,6 @@ static int rvt_set_page(struct ib_mr *ibmr, u64 addr)
         if (unlikely(mapped_segs == mr->mr.max_segs))
                 return -ENOMEM;
 
-        if (mr->mr.length == 0) {
-                mr->mr.user_base = addr;
-                mr->mr.iova = addr;
-        }
-
         m = mapped_segs / RVT_SEGSZ;
         n = mapped_segs % RVT_SEGSZ;
         mr->mr.map[m]->segs[n].vaddr = (void *)addr;
@@ -630,17 +625,24 @@ static int rvt_set_page(struct ib_mr *ibmr, u64 addr)
  * @sg_nents: number of entries in sg
  * @sg_offset: offset in bytes into sg
  *
+ * Overwrite rvt_mr length with mr length calculated by ib_sg_to_pages.
+ *
  * Return: number of sg elements mapped to the memory region
  */
 int rvt_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg,
                   int sg_nents, unsigned int *sg_offset)
 {
         struct rvt_mr *mr = to_imr(ibmr);
+        int ret;
 
         mr->mr.length = 0;
         mr->mr.page_shift = PAGE_SHIFT;
-        return ib_sg_to_pages(ibmr, sg, sg_nents, sg_offset,
-                              rvt_set_page);
+        ret = ib_sg_to_pages(ibmr, sg, sg_nents, sg_offset, rvt_set_page);
+        mr->mr.user_base = ibmr->iova;
+        mr->mr.iova = ibmr->iova;
+        mr->mr.offset = ibmr->iova - (u64)mr->mr.map[0]->segs[0].vaddr;
+        mr->mr.length = (size_t)ibmr->length;
+        return ret;
 }
 
 /**
@@ -671,6 +673,7 @@ int rvt_fast_reg_mr(struct rvt_qp *qp, struct ib_mr *ibmr, u32 key,
         ibmr->rkey = key;
         mr->mr.lkey = key;
         mr->mr.access_flags = access;
+        mr->mr.iova = ibmr->iova;
         atomic_set(&mr->mr.lkey_invalid, 0);
 
         return 0;
diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index a878351f1643..52d7f55fca32 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -420,7 +420,7 @@ config KEYBOARD_MPR121
 
 config KEYBOARD_SNVS_PWRKEY
         tristate "IMX SNVS Power Key Driver"
-        depends on SOC_IMX6SX || SOC_IMX7D
+        depends on ARCH_MXC || COMPILE_TEST
         depends on OF
         help
           This is the snvs powerkey driver for the Freescale i.MX application
diff --git a/drivers/input/rmi4/rmi_driver.c b/drivers/input/rmi4/rmi_driver.c
index fc3ab93b7aea..7fb358f96195 100644
--- a/drivers/input/rmi4/rmi_driver.c
+++ b/drivers/input/rmi4/rmi_driver.c
@@ -860,7 +860,7 @@ static int rmi_create_function(struct rmi_device *rmi_dev,
 
         error = rmi_register_function(fn);
         if (error)
-                goto err_put_fn;
+                return error;
 
         if (pdt->function_number == 0x01)
                 data->f01_container = fn;
@@ -870,10 +870,6 @@ static int rmi_create_function(struct rmi_device *rmi_dev,
         list_add_tail(&fn->node, &data->function_list);
 
         return RMI_SCAN_CONTINUE;
-
-err_put_fn:
-        put_device(&fn->dev);
-        return error;
 }
 
 void rmi_enable_irq(struct rmi_device *rmi_dev, bool clear_wake)
diff --git a/drivers/input/rmi4/rmi_f11.c b/drivers/input/rmi4/rmi_f11.c
index df64d6aed4f7..93901ebd122a 100644
--- a/drivers/input/rmi4/rmi_f11.c
+++ b/drivers/input/rmi4/rmi_f11.c
@@ -1230,7 +1230,7 @@ static int rmi_f11_initialize(struct rmi_function *fn)
         }
 
         rc = f11_write_control_regs(fn, &f11->sens_query,
-                           &f11->dev_controls, fn->fd.query_base_addr);
+                           &f11->dev_controls, fn->fd.control_base_addr);
         if (rc)
                 dev_warn(&fn->dev, "Failed to write control registers\n");
 
diff --git a/drivers/mtd/nand/raw/marvell_nand.c b/drivers/mtd/nand/raw/marvell_nand.c
index f38e5c1b87e4..d984538980e2 100644
--- a/drivers/mtd/nand/raw/marvell_nand.c
+++ b/drivers/mtd/nand/raw/marvell_nand.c
@@ -722,12 +722,6 @@ static void marvell_nfc_select_target(struct nand_chip *chip,
         struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
         u32 ndcr_generic;
 
-        if (chip == nfc->selected_chip && die_nr == marvell_nand->selected_die)
-                return;
-
-        writel_relaxed(marvell_nand->ndtr0, nfc->regs + NDTR0);
-        writel_relaxed(marvell_nand->ndtr1, nfc->regs + NDTR1);
-
         /*
          * Reset the NDCR register to a clean state for this particular chip,
          * also clear ND_RUN bit.
@@ -739,6 +733,12 @@ static void marvell_nfc_select_target(struct nand_chip *chip,
         /* Also reset the interrupt status register */
         marvell_nfc_clear_int(nfc, NDCR_ALL_INT);
 
+        if (chip == nfc->selected_chip && die_nr == marvell_nand->selected_die)
+                return;
+
+        writel_relaxed(marvell_nand->ndtr0, nfc->regs + NDTR0);
+        writel_relaxed(marvell_nand->ndtr1, nfc->regs + NDTR1);
+
         nfc->selected_chip = chip;
         marvell_nand->selected_die = die_nr;
 }
diff --git a/drivers/net/dsa/bcm_sf2_cfp.c b/drivers/net/dsa/bcm_sf2_cfp.c
index e6234d209787..4212bc4a5f31 100644
--- a/drivers/net/dsa/bcm_sf2_cfp.c
+++ b/drivers/net/dsa/bcm_sf2_cfp.c
@@ -886,6 +886,9 @@ static int bcm_sf2_cfp_rule_set(struct dsa_switch *ds, int port,
              fs->m_ext.data[1]))
                 return -EINVAL;
 
+        if (fs->location != RX_CLS_LOC_ANY && fs->location >= CFP_NUM_RULES)
+                return -EINVAL;
+
         if (fs->location != RX_CLS_LOC_ANY &&
             test_bit(fs->location, priv->cfp.used))
                 return -EBUSY;
@@ -974,6 +977,9 @@ static int bcm_sf2_cfp_rule_del(struct bcm_sf2_priv *priv, int port, u32 loc)
         struct cfp_rule *rule;
         int ret;
 
+        if (loc >= CFP_NUM_RULES)
+                return -EINVAL;
+
         /* Refuse deleting unused rules, and those that are not unique since
          * that could leave IPv6 rules with one of the chained rule in the
          * table.
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.c b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
index 526f36dcb204..a0de3c368f4a 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
@@ -1625,7 +1625,7 @@ static int bnxt_rx_pkt(struct bnxt *bp, struct bnxt_cp_ring_info *cpr,
                         netdev_warn(bp->dev, "RX buffer error %x\n", rx_err);
                         bnxt_sched_reset(bp, rxr);
                 }
-                goto next_rx;
+                goto next_rx_no_len;
         }
 
         len = le32_to_cpu(rxcmp->rx_cmp_len_flags_type) >> RX_CMP_LEN_SHIFT;
@@ -1706,12 +1706,13 @@ static int bnxt_rx_pkt(struct bnxt *bp, struct bnxt_cp_ring_info *cpr,
         rc = 1;
 
 next_rx:
-        rxr->rx_prod = NEXT_RX(prod);
-        rxr->rx_next_cons = NEXT_RX(cons);
-
         cpr->rx_packets += 1;
         cpr->rx_bytes += len;
 
+next_rx_no_len:
+        rxr->rx_prod = NEXT_RX(prod);
+        rxr->rx_next_cons = NEXT_RX(cons);
+
 next_rx_no_prod_no_len:
         *raw_cons = tmp_raw_cons;
 
@@ -5135,10 +5136,10 @@ static void bnxt_hwrm_ring_free(struct bnxt *bp, bool close_path)
         for (i = 0; i < bp->tx_nr_rings; i++) {
                 struct bnxt_tx_ring_info *txr = &bp->tx_ring[i];
                 struct bnxt_ring_struct *ring = &txr->tx_ring_struct;
-                u32 cmpl_ring_id;
 
-                cmpl_ring_id = bnxt_cp_ring_for_tx(bp, txr);
                 if (ring->fw_ring_id != INVALID_HW_RING_ID) {
+                        u32 cmpl_ring_id = bnxt_cp_ring_for_tx(bp, txr);
+
                         hwrm_ring_free_send_msg(bp, ring,
                                                 RING_FREE_REQ_RING_TYPE_TX,
                                                 close_path ? cmpl_ring_id :
@@ -5151,10 +5152,10 @@ static void bnxt_hwrm_ring_free(struct bnxt *bp, bool close_path)
                 struct bnxt_rx_ring_info *rxr = &bp->rx_ring[i];
                 struct bnxt_ring_struct *ring = &rxr->rx_ring_struct;
                 u32 grp_idx = rxr->bnapi->index;
-                u32 cmpl_ring_id;
 
-                cmpl_ring_id = bnxt_cp_ring_for_rx(bp, rxr);
                 if (ring->fw_ring_id != INVALID_HW_RING_ID) {
+                        u32 cmpl_ring_id = bnxt_cp_ring_for_rx(bp, rxr);
+
                         hwrm_ring_free_send_msg(bp, ring,
                                                 RING_FREE_REQ_RING_TYPE_RX,
                                                 close_path ? cmpl_ring_id :
@@ -5173,10 +5174,10 @@ static void bnxt_hwrm_ring_free(struct bnxt *bp, bool close_path)
                 struct bnxt_rx_ring_info *rxr = &bp->rx_ring[i];
                 struct bnxt_ring_struct *ring = &rxr->rx_agg_ring_struct;
                 u32 grp_idx = rxr->bnapi->index;
-                u32 cmpl_ring_id;
 
-                cmpl_ring_id = bnxt_cp_ring_for_rx(bp, rxr);
                 if (ring->fw_ring_id != INVALID_HW_RING_ID) {
+                        u32 cmpl_ring_id = bnxt_cp_ring_for_rx(bp, rxr);
+
                         hwrm_ring_free_send_msg(bp, ring, type,
                                                 close_path ? cmpl_ring_id :
                                                 INVALID_HW_RING_ID);
@@ -5315,17 +5316,16 @@ __bnxt_hwrm_reserve_pf_rings(struct bnxt *bp, struct hwrm_func_cfg_input *req,
         req->num_tx_rings = cpu_to_le16(tx_rings);
         if (BNXT_NEW_RM(bp)) {
                 enables |= rx_rings ? FUNC_CFG_REQ_ENABLES_NUM_RX_RINGS : 0;
+                enables |= stats ? FUNC_CFG_REQ_ENABLES_NUM_STAT_CTXS : 0;
                 if (bp->flags & BNXT_FLAG_CHIP_P5) {
                         enables |= cp_rings ? FUNC_CFG_REQ_ENABLES_NUM_MSIX : 0;
                         enables |= tx_rings + ring_grps ?
-                                   FUNC_CFG_REQ_ENABLES_NUM_CMPL_RINGS |
-                                   FUNC_CFG_REQ_ENABLES_NUM_STAT_CTXS : 0;
+                                   FUNC_CFG_REQ_ENABLES_NUM_CMPL_RINGS : 0;
                         enables |= rx_rings ?
                                 FUNC_CFG_REQ_ENABLES_NUM_RSSCOS_CTXS : 0;
                 } else {
                         enables |= cp_rings ?
-                                   FUNC_CFG_REQ_ENABLES_NUM_CMPL_RINGS |
-                                   FUNC_CFG_REQ_ENABLES_NUM_STAT_CTXS : 0;
+                                   FUNC_CFG_REQ_ENABLES_NUM_CMPL_RINGS : 0;
                         enables |= ring_grps ?
                                    FUNC_CFG_REQ_ENABLES_NUM_HW_RING_GRPS |
                                    FUNC_CFG_REQ_ENABLES_NUM_RSSCOS_CTXS : 0;
@@ -5365,14 +5365,13 @@ __bnxt_hwrm_reserve_vf_rings(struct bnxt *bp,
         enables |= tx_rings ? FUNC_VF_CFG_REQ_ENABLES_NUM_TX_RINGS : 0;
         enables |= rx_rings ? FUNC_VF_CFG_REQ_ENABLES_NUM_RX_RINGS |
                               FUNC_VF_CFG_REQ_ENABLES_NUM_RSSCOS_CTXS : 0;
+        enables |= stats ? FUNC_VF_CFG_REQ_ENABLES_NUM_STAT_CTXS : 0;
         if (bp->flags & BNXT_FLAG_CHIP_P5) {
                 enables |= tx_rings + ring_grps ?
-                           FUNC_VF_CFG_REQ_ENABLES_NUM_CMPL_RINGS |
-                           FUNC_VF_CFG_REQ_ENABLES_NUM_STAT_CTXS : 0;
+                           FUNC_VF_CFG_REQ_ENABLES_NUM_CMPL_RINGS : 0;
         } else {
                 enables |= cp_rings ?
-                           FUNC_VF_CFG_REQ_ENABLES_NUM_CMPL_RINGS |
-                           FUNC_VF_CFG_REQ_ENABLES_NUM_STAT_CTXS : 0;
+                           FUNC_VF_CFG_REQ_ENABLES_NUM_CMPL_RINGS : 0;
                 enables |= ring_grps ?
                            FUNC_VF_CFG_REQ_ENABLES_NUM_HW_RING_GRPS : 0;
         }
@@ -6753,6 +6752,7 @@ static int bnxt_hwrm_port_qstats_ext(struct bnxt *bp)
         struct hwrm_queue_pri2cos_qcfg_input req2 = {0};
         struct hwrm_port_qstats_ext_input req = {0};
         struct bnxt_pf_info *pf = &bp->pf;
+        u32 tx_stat_size;
         int rc;
 
         if (!(bp->flags & BNXT_FLAG_PORT_STATS_EXT))
@@ -6762,13 +6762,16 @@ static int bnxt_hwrm_port_qstats_ext(struct bnxt *bp)
         req.port_id = cpu_to_le16(pf->port_id);
         req.rx_stat_size = cpu_to_le16(sizeof(struct rx_port_stats_ext));
         req.rx_stat_host_addr = cpu_to_le64(bp->hw_rx_port_stats_ext_map);
-        req.tx_stat_size = cpu_to_le16(sizeof(struct tx_port_stats_ext));
+        tx_stat_size = bp->hw_tx_port_stats_ext ?
+                       sizeof(*bp->hw_tx_port_stats_ext) : 0;
+        req.tx_stat_size = cpu_to_le16(tx_stat_size);
         req.tx_stat_host_addr = cpu_to_le64(bp->hw_tx_port_stats_ext_map);
         mutex_lock(&bp->hwrm_cmd_lock);
         rc = _hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
         if (!rc) {
                 bp->fw_rx_stats_ext_size = le16_to_cpu(resp->rx_stat_size) / 8;
-                bp->fw_tx_stats_ext_size = le16_to_cpu(resp->tx_stat_size) / 8;
+                bp->fw_tx_stats_ext_size = tx_stat_size ?
+                        le16_to_cpu(resp->tx_stat_size) / 8 : 0;
         } else {
                 bp->fw_rx_stats_ext_size = 0;
                 bp->fw_tx_stats_ext_size = 0;
@@ -8961,8 +8964,15 @@ static int bnxt_cfg_rx_mode(struct bnxt *bp)
 
 skip_uc:
         rc = bnxt_hwrm_cfa_l2_set_rx_mask(bp, 0);
+        if (rc && vnic->mc_list_count) {
+                netdev_info(bp->dev, "Failed setting MC filters rc: %d, turning on ALL_MCAST mode\n",
+                            rc);
+                vnic->rx_mask |= CFA_L2_SET_RX_MASK_REQ_MASK_ALL_MCAST;
+                vnic->mc_list_count = 0;
+                rc = bnxt_hwrm_cfa_l2_set_rx_mask(bp, 0);
+        }
         if (rc)
-                netdev_err(bp->dev, "HWRM cfa l2 rx mask failure rc: %x\n",
+                netdev_err(bp->dev, "HWRM cfa l2 rx mask failure rc: %d\n",
                            rc);
 
         return rc;
@@ -10699,6 +10709,7 @@ init_err_cleanup_tc:
         bnxt_clear_int_mode(bp);
 
 init_err_pci_clean:
+        bnxt_free_hwrm_short_cmd_req(bp);
         bnxt_free_hwrm_resources(bp);
         bnxt_free_ctx_mem(bp);
         kfree(bp->ctx);
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-stm32.c b/drivers/net/ethernet/stmicro/stmmac/dwmac-stm32.c
index 062a600fa5a7..21428537e231 100644
--- a/drivers/net/ethernet/stmicro/stmmac/dwmac-stm32.c
+++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-stm32.c
@@ -333,6 +333,9 @@ static int stm32mp1_parse_data(struct stm32_dwmac *dwmac,
          */
         dwmac->irq_pwr_wakeup = platform_get_irq_byname(pdev,
                                                         "stm32_pwr_wakeup");
+        if (dwmac->irq_pwr_wakeup == -EPROBE_DEFER)
+                return -EPROBE_DEFER;
+
         if (!dwmac->clk_eth_ck && dwmac->irq_pwr_wakeup >= 0) {
                 err = device_init_wakeup(&pdev->dev, true);
                 if (err) {
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c
index cc1e887e47b5..26db6aa002d1 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c
@@ -160,7 +160,7 @@ static const struct dmi_system_id quark_pci_dmi[] = {
                 .driver_data = (void *)&galileo_stmmac_dmi_data,
         },
         /*
-         * There are 2 types of SIMATIC IOT2000: IOT20202 and IOT2040.
+         * There are 2 types of SIMATIC IOT2000: IOT2020 and IOT2040.
          * The asset tag "6ES7647-0AA00-0YA2" is only for IOT2020 which
          * has only one pci network device while other asset tags are
          * for IOT2040 which has two.
diff --git a/drivers/net/ieee802154/mcr20a.c b/drivers/net/ieee802154/mcr20a.c
index c589f5ae75bb..8bb53ec8d9cf 100644
--- a/drivers/net/ieee802154/mcr20a.c
+++ b/drivers/net/ieee802154/mcr20a.c
@@ -533,6 +533,8 @@ mcr20a_start(struct ieee802154_hw *hw)
         dev_dbg(printdev(lp), "no slotted operation\n");
         ret = regmap_update_bits(lp->regmap_dar, DAR_PHY_CTRL1,
                                  DAR_PHY_CTRL1_SLOTTED, 0x0);
+        if (ret < 0)
+                return ret;
 
         /* enable irq */
         enable_irq(lp->spi->irq);
@@ -540,11 +542,15 @@ mcr20a_start(struct ieee802154_hw *hw)
         /* Unmask SEQ interrupt */
         ret = regmap_update_bits(lp->regmap_dar, DAR_PHY_CTRL2,
                                  DAR_PHY_CTRL2_SEQMSK, 0x0);
+        if (ret < 0)
+                return ret;
 
         /* Start the RX sequence */
         dev_dbg(printdev(lp), "start the RX sequence\n");
         ret = regmap_update_bits(lp->regmap_dar, DAR_PHY_CTRL1,
                                  DAR_PHY_CTRL1_XCVSEQ_MASK, MCR20A_XCVSEQ_RX);
+        if (ret < 0)
+                return ret;
 
         return 0;
 }
diff --git a/drivers/net/phy/marvell.c b/drivers/net/phy/marvell.c
index a7e8c8113d97..a7796134e3be 100644
--- a/drivers/net/phy/marvell.c
+++ b/drivers/net/phy/marvell.c
@@ -1597,9 +1597,10 @@ static int marvell_get_sset_count(struct phy_device *phydev)
 
 static void marvell_get_strings(struct phy_device *phydev, u8 *data)
 {
+        int count = marvell_get_sset_count(phydev);
         int i;
 
-        for (i = 0; i < ARRAY_SIZE(marvell_hw_stats); i++) {
+        for (i = 0; i < count; i++) {
                 strlcpy(data + i * ETH_GSTRING_LEN,
                         marvell_hw_stats[i].string, ETH_GSTRING_LEN);
         }
@@ -1627,9 +1628,10 @@ static u64 marvell_get_stat(struct phy_device *phydev, int i)
 static void marvell_get_stats(struct phy_device *phydev,
                               struct ethtool_stats *stats, u64 *data)
 {
+        int count = marvell_get_sset_count(phydev);
         int i;
 
-        for (i = 0; i < ARRAY_SIZE(marvell_hw_stats); i++)
+        for (i = 0; i < count; i++)
                 data[i] = marvell_get_stat(phydev, i);
 }
 
diff --git a/drivers/net/slip/slhc.c b/drivers/net/slip/slhc.c
index f4e93f5fc204..ea90db3c7705 100644
--- a/drivers/net/slip/slhc.c
+++ b/drivers/net/slip/slhc.c
@@ -153,7 +153,7 @@ out_fail:
 void
 slhc_free(struct slcompress *comp)
 {
-        if ( comp == NULLSLCOMPR )
+        if ( IS_ERR_OR_NULL(comp) )
                 return;
 
         if ( comp->tstate != NULLSLSTATE )
diff --git a/drivers/net/usb/qmi_wwan.c b/drivers/net/usb/qmi_wwan.c
index 18c4e5d17b05..5c3ac97519b7 100644
--- a/drivers/net/usb/qmi_wwan.c
+++ b/drivers/net/usb/qmi_wwan.c
@@ -1131,9 +1131,16 @@ static const struct usb_device_id products[] = {
         {QMI_FIXED_INTF(0x0846, 0x68d3, 8)},    /* Netgear Aircard 779S */
         {QMI_FIXED_INTF(0x12d1, 0x140c, 1)},    /* Huawei E173 */
         {QMI_FIXED_INTF(0x12d1, 0x14ac, 1)},    /* Huawei E1820 */
+        {QMI_FIXED_INTF(0x1435, 0x0918, 3)},    /* Wistron NeWeb D16Q1 */
+        {QMI_FIXED_INTF(0x1435, 0x0918, 4)},    /* Wistron NeWeb D16Q1 */
+        {QMI_FIXED_INTF(0x1435, 0x0918, 5)},    /* Wistron NeWeb D16Q1 */
+        {QMI_FIXED_INTF(0x1435, 0x3185, 4)},    /* Wistron NeWeb M18Q5 */
+        {QMI_FIXED_INTF(0x1435, 0xd111, 4)},    /* M9615A DM11-1 D51QC */
         {QMI_FIXED_INTF(0x1435, 0xd181, 3)},    /* Wistron NeWeb D18Q1 */
         {QMI_FIXED_INTF(0x1435, 0xd181, 4)},    /* Wistron NeWeb D18Q1 */
         {QMI_FIXED_INTF(0x1435, 0xd181, 5)},    /* Wistron NeWeb D18Q1 */
+        {QMI_FIXED_INTF(0x1435, 0xd182, 4)},    /* Wistron NeWeb D18 */
+        {QMI_FIXED_INTF(0x1435, 0xd182, 5)},    /* Wistron NeWeb D18 */
         {QMI_FIXED_INTF(0x1435, 0xd191, 4)},    /* Wistron NeWeb D19Q1 */
         {QMI_QUIRK_SET_DTR(0x1508, 0x1001, 4)}, /* Fibocom NL668 series */
         {QMI_FIXED_INTF(0x16d8, 0x6003, 0)},    /* CMOTech 6003 */
@@ -1189,6 +1196,7 @@ static const struct usb_device_id products[] = {
         {QMI_FIXED_INTF(0x19d2, 0x0265, 4)},    /* ONDA MT8205 4G LTE */
         {QMI_FIXED_INTF(0x19d2, 0x0284, 4)},    /* ZTE MF880 */
         {QMI_FIXED_INTF(0x19d2, 0x0326, 4)},    /* ZTE MF821D */
+        {QMI_FIXED_INTF(0x19d2, 0x0396, 3)},    /* ZTE ZM8620 */
         {QMI_FIXED_INTF(0x19d2, 0x0412, 4)},    /* Telewell TW-LTE 4G */
         {QMI_FIXED_INTF(0x19d2, 0x1008, 4)},    /* ZTE (Vodafone) K3570-Z */
         {QMI_FIXED_INTF(0x19d2, 0x1010, 4)},    /* ZTE (Vodafone) K3571-Z */
@@ -1209,7 +1217,9 @@ static const struct usb_device_id products[] = {
         {QMI_FIXED_INTF(0x19d2, 0x1425, 2)},
         {QMI_FIXED_INTF(0x19d2, 0x1426, 2)},    /* ZTE MF91 */
         {QMI_FIXED_INTF(0x19d2, 0x1428, 2)},    /* Telewell TW-LTE 4G v2 */
+        {QMI_FIXED_INTF(0x19d2, 0x1432, 3)},    /* ZTE ME3620 */
         {QMI_FIXED_INTF(0x19d2, 0x2002, 4)},    /* ZTE (Vodafone) K3765-Z */
+        {QMI_FIXED_INTF(0x2001, 0x7e16, 3)},    /* D-Link DWM-221 */
         {QMI_FIXED_INTF(0x2001, 0x7e19, 4)},    /* D-Link DWM-221 B1 */
         {QMI_FIXED_INTF(0x2001, 0x7e35, 4)},    /* D-Link DWM-222 */
         {QMI_FIXED_INTF(0x2020, 0x2031, 4)},    /* Olicard 600 */
diff --git a/drivers/net/wireless/ath/ath10k/ce.c b/drivers/net/wireless/ath/ath10k/ce.c
index 24b983edb357..eca87f7c5b6c 100644
--- a/drivers/net/wireless/ath/ath10k/ce.c
+++ b/drivers/net/wireless/ath/ath10k/ce.c
@@ -1855,7 +1855,7 @@ void ath10k_ce_dump_registers(struct ath10k *ar,
         struct ath10k_ce_crash_data ce_data;
         u32 addr, id;
 
-        lockdep_assert_held(&ar->data_lock);
+        lockdep_assert_held(&ar->dump_mutex);
 
         ath10k_err(ar, "Copy Engine register dump:\n");
 
diff --git a/drivers/net/wireless/ath/ath10k/core.c b/drivers/net/wireless/ath/ath10k/core.c
index 835b8de92d55..aff585658fc0 100644
--- a/drivers/net/wireless/ath/ath10k/core.c
+++ b/drivers/net/wireless/ath/ath10k/core.c
@@ -3119,6 +3119,7 @@ struct ath10k *ath10k_core_create(size_t priv_size, struct device *dev,
                 goto err_free_wq;
 
         mutex_init(&ar->conf_mutex);
+        mutex_init(&ar->dump_mutex);
         spin_lock_init(&ar->data_lock);
 
         INIT_LIST_HEAD(&ar->peers);
diff --git a/drivers/net/wireless/ath/ath10k/core.h b/drivers/net/wireless/ath/ath10k/core.h
index e08a17b01e03..e35aae5146f1 100644
--- a/drivers/net/wireless/ath/ath10k/core.h
+++ b/drivers/net/wireless/ath/ath10k/core.h
@@ -1063,6 +1063,9 @@ struct ath10k {
         /* prevents concurrent FW reconfiguration */
         struct mutex conf_mutex;
 
+        /* protects coredump data */
+        struct mutex dump_mutex;
+
         /* protects shared structure data */
         spinlock_t data_lock;
 
diff --git a/drivers/net/wireless/ath/ath10k/coredump.c b/drivers/net/wireless/ath/ath10k/coredump.c
index 33838d9c1cb6..45a355fb62b9 100644
--- a/drivers/net/wireless/ath/ath10k/coredump.c
+++ b/drivers/net/wireless/ath/ath10k/coredump.c
@@ -1102,7 +1102,7 @@ struct ath10k_fw_crash_data *ath10k_coredump_new(struct ath10k *ar)
 {
         struct ath10k_fw_crash_data *crash_data = ar->coredump.fw_crash_data;
 
-        lockdep_assert_held(&ar->data_lock);
+        lockdep_assert_held(&ar->dump_mutex);
 
         if (ath10k_coredump_mask == 0)
                 /* coredump disabled */
@@ -1146,7 +1146,7 @@ static struct ath10k_dump_file_data *ath10k_coredump_build(struct ath10k *ar)
         if (!buf)
                 return NULL;
 
-        spin_lock_bh(&ar->data_lock);
+        mutex_lock(&ar->dump_mutex);
 
         dump_data = (struct ath10k_dump_file_data *)(buf);
         strlcpy(dump_data->df_magic, "ATH10K-FW-DUMP",
@@ -1213,7 +1213,7 @@ static struct ath10k_dump_file_data *ath10k_coredump_build(struct ath10k *ar)
                 sofar += sizeof(*dump_tlv) + crash_data->ramdump_buf_len;
         }
 
-        spin_unlock_bh(&ar->data_lock);
+        mutex_unlock(&ar->dump_mutex);
 
         return dump_data;
 }
diff --git a/drivers/net/wireless/ath/ath10k/mac.c b/drivers/net/wireless/ath/ath10k/mac.c
index 41e89db244d2..9c703d287333 100644
--- a/drivers/net/wireless/ath/ath10k/mac.c
+++ b/drivers/net/wireless/ath/ath10k/mac.c
@@ -5774,7 +5774,7 @@ static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
         }
 
         if (changed & BSS_CHANGED_MCAST_RATE &&
-            !WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def))) {
+            !ath10k_mac_vif_chan(arvif->vif, &def)) {
                 band = def.chan->band;
                 rateidx = vif->bss_conf.mcast_rate[band] - 1;
 
@@ -5812,7 +5812,7 @@ static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
         }
 
         if (changed & BSS_CHANGED_BASIC_RATES) {
-                if (WARN_ON(ath10k_mac_vif_chan(vif, &def))) {
+                if (ath10k_mac_vif_chan(vif, &def)) {
                         mutex_unlock(&ar->conf_mutex);
                         return;
                 }
diff --git a/drivers/net/wireless/ath/ath10k/pci.c b/drivers/net/wireless/ath/ath10k/pci.c
index 271f92c24d44..2c27f407a851 100644
--- a/drivers/net/wireless/ath/ath10k/pci.c
+++ b/drivers/net/wireless/ath/ath10k/pci.c
@@ -1441,7 +1441,7 @@ static void ath10k_pci_dump_registers(struct ath10k *ar,
         __le32 reg_dump_values[REG_DUMP_COUNT_QCA988X] = {};
         int i, ret;
 
-        lockdep_assert_held(&ar->data_lock);
+        lockdep_assert_held(&ar->dump_mutex);
 
         ret = ath10k_pci_diag_read_hi(ar, &reg_dump_values[0],
                                       hi_failure_state,
@@ -1656,7 +1656,7 @@ static void ath10k_pci_dump_memory(struct ath10k *ar,
         int ret, i;
         u8 *buf;
 
-        lockdep_assert_held(&ar->data_lock);
+        lockdep_assert_held(&ar->dump_mutex);
 
         if (!crash_data)
                 return;
@@ -1734,14 +1734,19 @@ static void ath10k_pci_dump_memory(struct ath10k *ar,
         }
 }
 
-static void ath10k_pci_fw_crashed_dump(struct ath10k *ar)
+static void ath10k_pci_fw_dump_work(struct work_struct *work)
 {
+        struct ath10k_pci *ar_pci = container_of(work, struct ath10k_pci,
+                                                 dump_work);
         struct ath10k_fw_crash_data *crash_data;
+        struct ath10k *ar = ar_pci->ar;
         char guid[UUID_STRING_LEN + 1];
 
-        spin_lock_bh(&ar->data_lock);
+        mutex_lock(&ar->dump_mutex);
 
+        spin_lock_bh(&ar->data_lock);
         ar->stats.fw_crash_counter++;
+        spin_unlock_bh(&ar->data_lock);
 
         crash_data = ath10k_coredump_new(ar);
 
@@ -1756,11 +1761,18 @@ static void ath10k_pci_fw_crashed_dump(struct ath10k *ar)
         ath10k_ce_dump_registers(ar, crash_data);
         ath10k_pci_dump_memory(ar, crash_data);
 
-        spin_unlock_bh(&ar->data_lock);
+        mutex_unlock(&ar->dump_mutex);
 
         queue_work(ar->workqueue, &ar->restart_work);
 }
 
+static void ath10k_pci_fw_crashed_dump(struct ath10k *ar)
+{
+        struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+
+        queue_work(ar->workqueue, &ar_pci->dump_work);
+}
+
 void ath10k_pci_hif_send_complete_check(struct ath10k *ar, u8 pipe,
                                         int force)
 {
@@ -3442,6 +3454,8 @@ int ath10k_pci_setup_resource(struct ath10k *ar)
         spin_lock_init(&ar_pci->ps_lock);
         mutex_init(&ar_pci->ce_diag_mutex);
 
+        INIT_WORK(&ar_pci->dump_work, ath10k_pci_fw_dump_work);
+
         timer_setup(&ar_pci->rx_post_retry, ath10k_pci_rx_replenish_retry, 0);
 
         if (QCA_REV_6174(ar) || QCA_REV_9377(ar))
diff --git a/drivers/net/wireless/ath/ath10k/pci.h b/drivers/net/wireless/ath/ath10k/pci.h
index 3773c79f322f..4455ed6c5275 100644
--- a/drivers/net/wireless/ath/ath10k/pci.h
+++ b/drivers/net/wireless/ath/ath10k/pci.h
@@ -121,6 +121,8 @@ struct ath10k_pci {
         /* For protecting ce_diag */
         struct mutex ce_diag_mutex;
 
+        struct work_struct dump_work;
+
         struct ath10k_ce ce;
         struct timer_list rx_post_retry;
 
diff --git a/drivers/net/wireless/intel/iwlwifi/cfg/22000.c b/drivers/net/wireless/intel/iwlwifi/cfg/22000.c
index fc915ecfb06e..17b34f6e4515 100644
--- a/drivers/net/wireless/intel/iwlwifi/cfg/22000.c
+++ b/drivers/net/wireless/intel/iwlwifi/cfg/22000.c
@@ -207,7 +207,7 @@ static const struct iwl_ht_params iwl_22000_ht_params = {
 #define IWL_DEVICE_AX210                                                \
         IWL_DEVICE_AX200_COMMON,                                        \
         .device_family = IWL_DEVICE_FAMILY_AX210,                       \
-        .base_params = &iwl_22000_base_params,                          \
+        .base_params = &iwl_22560_base_params,                          \
         .csr = &iwl_csr_v1,                                             \
         .min_txq_size = 128,                                            \
         .gp2_reg_addr = 0xd02c68,                                       \
diff --git a/drivers/net/wireless/intel/iwlwifi/cfg/5000.c b/drivers/net/wireless/intel/iwlwifi/cfg/5000.c
index 575a7022d045..3846064d51a5 100644
--- a/drivers/net/wireless/intel/iwlwifi/cfg/5000.c
+++ b/drivers/net/wireless/intel/iwlwifi/cfg/5000.c
@@ -1,7 +1,7 @@
 /******************************************************************************
  *
  * Copyright(c) 2007 - 2014 Intel Corporation. All rights reserved.
- * Copyright(c) 2018 Intel Corporation
+ * Copyright(c) 2018 - 2019 Intel Corporation
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License as
@@ -136,6 +136,7 @@ const struct iwl_cfg iwl5350_agn_cfg = {
         .ht_params = &iwl5000_ht_params,
         .led_mode = IWL_LED_BLINK,
         .internal_wimax_coex = true,
+        .csr = &iwl_csr_v1,
 };
 
 #define IWL_DEVICE_5150                                         \
diff --git a/drivers/net/wireless/intel/iwlwifi/fw/file.h b/drivers/net/wireless/intel/iwlwifi/fw/file.h
index abfdcabdcbf7..cd622af90077 100644
--- a/drivers/net/wireless/intel/iwlwifi/fw/file.h
+++ b/drivers/net/wireless/intel/iwlwifi/fw/file.h
@@ -93,7 +93,7 @@ struct iwl_ucode_header {
         } u;
 };
 
-#define IWL_UCODE_INI_TLV_GROUP BIT(24)
+#define IWL_UCODE_INI_TLV_GROUP 0x1000000
 
 /*
  * new TLV uCode file layout
@@ -148,11 +148,14 @@ enum iwl_ucode_tlv_type {
         IWL_UCODE_TLV_UMAC_DEBUG_ADDRS  = 54,
         IWL_UCODE_TLV_LMAC_DEBUG_ADDRS  = 55,
         IWL_UCODE_TLV_FW_RECOVERY_INFO  = 57,
-        IWL_UCODE_TLV_TYPE_BUFFER_ALLOCATION    = IWL_UCODE_INI_TLV_GROUP | 0x1,
-        IWL_UCODE_TLV_TYPE_HCMD                 = IWL_UCODE_INI_TLV_GROUP | 0x2,
-        IWL_UCODE_TLV_TYPE_REGIONS              = IWL_UCODE_INI_TLV_GROUP | 0x3,
-        IWL_UCODE_TLV_TYPE_TRIGGERS             = IWL_UCODE_INI_TLV_GROUP | 0x4,
-        IWL_UCODE_TLV_TYPE_DEBUG_FLOW           = IWL_UCODE_INI_TLV_GROUP | 0x5,
+
+        IWL_UCODE_TLV_TYPE_BUFFER_ALLOCATION    = IWL_UCODE_INI_TLV_GROUP + 0x1,
+        IWL_UCODE_TLV_DEBUG_BASE = IWL_UCODE_TLV_TYPE_BUFFER_ALLOCATION,
+        IWL_UCODE_TLV_TYPE_HCMD                 = IWL_UCODE_INI_TLV_GROUP + 0x2,
+        IWL_UCODE_TLV_TYPE_REGIONS              = IWL_UCODE_INI_TLV_GROUP + 0x3,
+        IWL_UCODE_TLV_TYPE_TRIGGERS             = IWL_UCODE_INI_TLV_GROUP + 0x4,
+        IWL_UCODE_TLV_TYPE_DEBUG_FLOW           = IWL_UCODE_INI_TLV_GROUP + 0x5,
+        IWL_UCODE_TLV_DEBUG_MAX = IWL_UCODE_TLV_TYPE_DEBUG_FLOW,
 
         /* TLVs 0x1000-0x2000 are for internal driver usage */
         IWL_UCODE_TLV_FW_DBG_DUMP_LST   = 0x1000,
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-dbg-tlv.c b/drivers/net/wireless/intel/iwlwifi/iwl-dbg-tlv.c
index 9107302cc444..0e8664375298 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-dbg-tlv.c
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-dbg-tlv.c
@@ -129,7 +129,8 @@ void iwl_alloc_dbg_tlv(struct iwl_trans *trans, size_t len, const u8 *data,
                 len -= ALIGN(tlv_len, 4);
                 data += sizeof(*tlv) + ALIGN(tlv_len, 4);
 
-                if (!(tlv_type & IWL_UCODE_INI_TLV_GROUP))
+                if (tlv_type < IWL_UCODE_TLV_DEBUG_BASE ||
+                    tlv_type > IWL_UCODE_TLV_DEBUG_MAX)
                         continue;
 
                 hdr = (void *)&tlv->data[0];
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/debugfs-vif.c b/drivers/net/wireless/intel/iwlwifi/mvm/debugfs-vif.c
index 9bf2407c9b4b..f043eefabb4e 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/debugfs-vif.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/debugfs-vif.c
@@ -773,6 +773,11 @@ void iwl_mvm_vif_dbgfs_register(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
                 return;
 
         mvmvif->dbgfs_dir = debugfs_create_dir("iwlmvm", dbgfs_dir);
+        if (IS_ERR_OR_NULL(mvmvif->dbgfs_dir)) {
+                IWL_ERR(mvm, "Failed to create debugfs directory under %pd\n",
+                        dbgfs_dir);
+                return;
+        }
 
         if (iwlmvm_mod_params.power_scheme != IWL_POWER_SCHEME_CAM &&
             ((vif->type == NL80211_IFTYPE_STATION && !vif->p2p) ||
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/fw.c b/drivers/net/wireless/intel/iwlwifi/mvm/fw.c
index 00a47f6f1d81..ab68b5d53ec9 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/fw.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/fw.c
@@ -1121,7 +1121,9 @@ int iwl_mvm_up(struct iwl_mvm *mvm)
         ret = iwl_mvm_load_rt_fw(mvm);
         if (ret) {
                 IWL_ERR(mvm, "Failed to start RT ucode: %d\n", ret);
-                iwl_fw_dbg_error_collect(&mvm->fwrt, FW_DBG_TRIGGER_DRIVER);
+                if (ret != -ERFKILL)
+                        iwl_fw_dbg_error_collect(&mvm->fwrt,
+                                                 FW_DBG_TRIGGER_DRIVER);
                 goto error;
         }
 
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/ops.c b/drivers/net/wireless/intel/iwlwifi/mvm/ops.c
index 55d399899d1c..8da9e5572fcf 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/ops.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/ops.c
@@ -834,7 +834,7 @@ iwl_op_mode_mvm_start(struct iwl_trans *trans, const struct iwl_cfg *cfg,
         mutex_lock(&mvm->mutex);
         iwl_mvm_ref(mvm, IWL_MVM_REF_INIT_UCODE);
         err = iwl_run_init_mvm_ucode(mvm, true);
-        if (err)
+        if (err && err != -ERFKILL)
                 iwl_fw_dbg_error_collect(&mvm->fwrt, FW_DBG_TRIGGER_DRIVER);
         if (!iwlmvm_mod_params.init_dbg || !err)
                 iwl_mvm_stop_device(mvm);
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c b/drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c
index 0b1b208de767..1824566d08fc 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c
@@ -169,9 +169,9 @@ static inline int iwl_mvm_check_pn(struct iwl_mvm *mvm, struct sk_buff *skb,
 }
 
 /* iwl_mvm_create_skb Adds the rxb to a new skb */
-static void iwl_mvm_create_skb(struct sk_buff *skb, struct ieee80211_hdr *hdr,
-                               u16 len, u8 crypt_len,
-                               struct iwl_rx_cmd_buffer *rxb)
+static int iwl_mvm_create_skb(struct iwl_mvm *mvm, struct sk_buff *skb,
+                              struct ieee80211_hdr *hdr, u16 len, u8 crypt_len,
+                              struct iwl_rx_cmd_buffer *rxb)
 {
         struct iwl_rx_packet *pkt = rxb_addr(rxb);
         struct iwl_rx_mpdu_desc *desc = (void *)pkt->data;
@@ -204,6 +204,20 @@ static void iwl_mvm_create_skb(struct sk_buff *skb, struct ieee80211_hdr *hdr,
          * present before copying packet data.
          */
         hdrlen += crypt_len;
+
+        if (WARN_ONCE(headlen < hdrlen,
+                      "invalid packet lengths (hdrlen=%d, len=%d, crypt_len=%d)\n",
+                      hdrlen, len, crypt_len)) {
+                /*
+                 * We warn and trace because we want to be able to see
+                 * it in trace-cmd as well.
+                 */
+                IWL_DEBUG_RX(mvm,
+                             "invalid packet lengths (hdrlen=%d, len=%d, crypt_len=%d)\n",
+                             hdrlen, len, crypt_len);
+                return -EINVAL;
+        }
+
         skb_put_data(skb, hdr, hdrlen);
         skb_put_data(skb, (u8 *)hdr + hdrlen + pad_len, headlen - hdrlen);
 
@@ -216,6 +230,8 @@ static void iwl_mvm_create_skb(struct sk_buff *skb, struct ieee80211_hdr *hdr,
                 skb_add_rx_frag(skb, 0, rxb_steal_page(rxb), offset,
                                 fraglen, rxb->truesize);
         }
+
+        return 0;
 }
 
 static void iwl_mvm_add_rtap_sniffer_config(struct iwl_mvm *mvm,
@@ -1671,7 +1687,11 @@ void iwl_mvm_rx_mpdu_mq(struct iwl_mvm *mvm, struct napi_struct *napi,
                         rx_status->boottime_ns = ktime_get_boot_ns();
         }
 
-        iwl_mvm_create_skb(skb, hdr, len, crypt_len, rxb);
+        if (iwl_mvm_create_skb(mvm, skb, hdr, len, crypt_len, rxb)) {
+                kfree_skb(skb);
+                goto out;
+        }
+
         if (!iwl_mvm_reorder(mvm, napi, queue, sta, skb, desc))
                 iwl_mvm_pass_packet_to_mac80211(mvm, napi, skb, queue,
                                                 sta, csi);
diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/trans.c b/drivers/net/wireless/intel/iwlwifi/pcie/trans.c
index c5baaae8d38e..cccb8bbd7ea7 100644
--- a/drivers/net/wireless/intel/iwlwifi/pcie/trans.c
+++ b/drivers/net/wireless/intel/iwlwifi/pcie/trans.c
@@ -3654,20 +3654,27 @@ out_no_pci:
 
 void iwl_trans_pcie_sync_nmi(struct iwl_trans *trans)
 {
+        struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
         unsigned long timeout = jiffies + IWL_TRANS_NMI_TIMEOUT;
+        u32 inta_addr, sw_err_bit;
+
+        if (trans_pcie->msix_enabled) {
+                inta_addr = CSR_MSIX_HW_INT_CAUSES_AD;
+                sw_err_bit = MSIX_HW_INT_CAUSES_REG_SW_ERR;
+        } else {
+                inta_addr = CSR_INT;
+                sw_err_bit = CSR_INT_BIT_SW_ERR;
+        }
 
         iwl_disable_interrupts(trans);
         iwl_force_nmi(trans);
         while (time_after(timeout, jiffies)) {
-                u32 inta_hw = iwl_read32(trans,
-                                         CSR_MSIX_HW_INT_CAUSES_AD);
+                u32 inta_hw = iwl_read32(trans, inta_addr);
 
                 /* Error detected by uCode */
-                if (inta_hw & MSIX_HW_INT_CAUSES_REG_SW_ERR) {
+                if (inta_hw & sw_err_bit) {
                         /* Clear causes register */
-                        iwl_write32(trans, CSR_MSIX_HW_INT_CAUSES_AD,
-                                    inta_hw &
-                                    MSIX_HW_INT_CAUSES_REG_SW_ERR);
+                        iwl_write32(trans, inta_addr, inta_hw & sw_err_bit);
                         break;
                 }
 
diff --git a/drivers/net/wireless/marvell/mwifiex/sdio.c b/drivers/net/wireless/marvell/mwifiex/sdio.c
index a85648342d15..d5a70340a945 100644
--- a/drivers/net/wireless/marvell/mwifiex/sdio.c
+++ b/drivers/net/wireless/marvell/mwifiex/sdio.c
@@ -181,7 +181,7 @@ static int mwifiex_sdio_resume(struct device *dev)
 
         adapter = card->adapter;
 
-        if (test_bit(MWIFIEX_IS_SUSPENDED, &adapter->work_flags)) {
+        if (!test_bit(MWIFIEX_IS_SUSPENDED, &adapter->work_flags)) {
                 mwifiex_dbg(adapter, WARN,
                             "device already resumed\n");
                 return 0;
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 7c1b362f599a..766f5779db92 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -6262,8 +6262,7 @@ static int __init pci_setup(char *str)
                         } else if (!strncmp(str, "pcie_scan_all", 13)) {
                                 pci_add_flags(PCI_SCAN_ALL_PCIE_DEVS);
                         } else if (!strncmp(str, "disable_acs_redir=", 18)) {
-                                disable_acs_redir_param =
-                                        kstrdup(str + 18, GFP_KERNEL);
+                                disable_acs_redir_param = str + 18;
                         } else {
                                 printk(KERN_ERR "PCI: Unknown option `%s'\n",
                                                 str);
@@ -6274,3 +6273,19 @@ static int __init pci_setup(char *str)
         return 0;
 }
 early_param("pci", pci_setup);
+
+/*
+ * 'disable_acs_redir_param' is initialized in pci_setup(), above, to point
+ * to data in the __initdata section which will be freed after the init
+ * sequence is complete. We can't allocate memory in pci_setup() because some
+ * architectures do not have any memory allocation service available during
+ * an early_param() call. So we allocate memory and copy the variable here
+ * before the init section is freed.
+ */
+static int __init pci_realloc_setup_params(void)
+{
+        disable_acs_redir_param = kstrdup(disable_acs_redir_param, GFP_KERNEL);
+
+        return 0;
+}
+pure_initcall(pci_realloc_setup_params);
diff --git a/drivers/pci/pcie/Kconfig b/drivers/pci/pcie/Kconfig
index 5cbdbca904ac..362eb8cfa53b 100644
--- a/drivers/pci/pcie/Kconfig
+++ b/drivers/pci/pcie/Kconfig
@@ -142,3 +142,11 @@ config PCIE_PTM
 
           This is only useful if you have devices that support PTM, but it
           is safe to enable even if you don't.
+
+config PCIE_BW
+        bool "PCI Express Bandwidth Change Notification"
+        depends on PCIEPORTBUS
+        help
+          This enables PCI Express Bandwidth Change Notification.  If
+          you know link width or rate changes occur only to correct
+          unreliable links, you may answer Y.
diff --git a/drivers/pci/pcie/Makefile b/drivers/pci/pcie/Makefile
index f1d7bc1e5efa..efb9d2e71e9e 100644
--- a/drivers/pci/pcie/Makefile
+++ b/drivers/pci/pcie/Makefile
@@ -3,7 +3,6 @@
 # Makefile for PCI Express features and port driver
 
 pcieportdrv-y                   := portdrv_core.o portdrv_pci.o err.o
-pcieportdrv-y                   += bw_notification.o
 
 obj-$(CONFIG_PCIEPORTBUS)       += pcieportdrv.o
 
@@ -13,3 +12,4 @@ obj-$(CONFIG_PCIEAER_INJECT)	+= aer_inject.o
 obj-$(CONFIG_PCIE_PME)          += pme.o
 obj-$(CONFIG_PCIE_DPC)          += dpc.o
 obj-$(CONFIG_PCIE_PTM)          += ptm.o
+obj-$(CONFIG_PCIE_BW)           += bw_notification.o
diff --git a/drivers/pci/pcie/portdrv.h b/drivers/pci/pcie/portdrv.h
index 1d50dc58ac40..944827a8c7d3 100644
--- a/drivers/pci/pcie/portdrv.h
+++ b/drivers/pci/pcie/portdrv.h
@@ -49,7 +49,11 @@ int pcie_dpc_init(void);
 static inline int pcie_dpc_init(void) { return 0; }
 #endif
 
+#ifdef CONFIG_PCIE_BW
 int pcie_bandwidth_notification_init(void);
+#else
+static inline int pcie_bandwidth_notification_init(void) { return 0; }
+#endif
 
 /* Port Type */
 #define PCIE_ANY_PORT                   (~0)
diff --git a/drivers/pci/pcie/portdrv_core.c b/drivers/pci/pcie/portdrv_core.c
index 7d04f9d087a6..1b330129089f 100644
--- a/drivers/pci/pcie/portdrv_core.c
+++ b/drivers/pci/pcie/portdrv_core.c
@@ -55,7 +55,8 @@ static int pcie_message_numbers(struct pci_dev *dev, int mask,
          * 7.8.2, 7.10.10, 7.31.2.
          */
 
-        if (mask & (PCIE_PORT_SERVICE_PME | PCIE_PORT_SERVICE_HP)) {
+        if (mask & (PCIE_PORT_SERVICE_PME | PCIE_PORT_SERVICE_HP |
+                    PCIE_PORT_SERVICE_BWNOTIF)) {
                 pcie_capability_read_word(dev, PCI_EXP_FLAGS, &reg16);
                 *pme = (reg16 & PCI_EXP_FLAGS_IRQ) >> 9;
                 nvec = *pme + 1;
diff --git a/drivers/power/supply/cpcap-battery.c b/drivers/power/supply/cpcap-battery.c
index 08d5037fd052..6887870ba32c 100644
--- a/drivers/power/supply/cpcap-battery.c
+++ b/drivers/power/supply/cpcap-battery.c
@@ -221,6 +221,9 @@ static int cpcap_battery_cc_raw_div(struct cpcap_battery_ddata *ddata,
         int avg_current;
         u32 cc_lsb;
 
+        if (!divider)
+                return 0;
+
         sample &= 0xffffff;             /* 24-bits, unsigned */
         offset &= 0x7ff;                /* 10-bits, signed */
 
diff --git a/drivers/power/supply/power_supply_sysfs.c b/drivers/power/supply/power_supply_sysfs.c
index dce24f596160..5358a80d854f 100644
--- a/drivers/power/supply/power_supply_sysfs.c
+++ b/drivers/power/supply/power_supply_sysfs.c
@@ -383,15 +383,11 @@ int power_supply_uevent(struct device *dev, struct kobj_uevent_env *env)
         char *prop_buf;
         char *attrname;
 
-        dev_dbg(dev, "uevent\n");
-
         if (!psy || !psy->desc) {
                 dev_dbg(dev, "No power supply yet\n");
                 return ret;
         }
 
-        dev_dbg(dev, "POWER_SUPPLY_NAME=%s\n", psy->desc->name);
-
         ret = add_uevent_var(env, "POWER_SUPPLY_NAME=%s", psy->desc->name);
         if (ret)
                 return ret;
@@ -427,8 +423,6 @@ int power_supply_uevent(struct device *dev, struct kobj_uevent_env *env)
                         goto out;
                 }
 
-                dev_dbg(dev, "prop %s=%s\n", attrname, prop_buf);
-
                 ret = add_uevent_var(env, "POWER_SUPPLY_%s=%s", attrname, prop_buf);
                 kfree(attrname);
                 if (ret)
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index 8987cec9549d..ebcadaad89d1 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -473,11 +473,6 @@ static int usb_unbind_interface(struct device *dev)
                 pm_runtime_disable(dev);
         pm_runtime_set_suspended(dev);
 
-        /* Undo any residual pm_autopm_get_interface_* calls */
-        for (r = atomic_read(&intf->pm_usage_cnt); r > 0; --r)
-                usb_autopm_put_interface_no_suspend(intf);
-        atomic_set(&intf->pm_usage_cnt, 0);
-
         if (!error)
                 usb_autosuspend_device(udev);
 
@@ -1633,7 +1628,6 @@ void usb_autopm_put_interface(struct usb_interface *intf)
         int                     status;
 
         usb_mark_last_busy(udev);
-        atomic_dec(&intf->pm_usage_cnt);
         status = pm_runtime_put_sync(&intf->dev);
         dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
                         __func__, atomic_read(&intf->dev.power.usage_count),
@@ -1662,7 +1656,6 @@ void usb_autopm_put_interface_async(struct usb_interface *intf)
         int                     status;
 
         usb_mark_last_busy(udev);
-        atomic_dec(&intf->pm_usage_cnt);
         status = pm_runtime_put(&intf->dev);
         dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
                         __func__, atomic_read(&intf->dev.power.usage_count),
@@ -1684,7 +1677,6 @@ void usb_autopm_put_interface_no_suspend(struct usb_interface *intf)
         struct usb_device       *udev = interface_to_usbdev(intf);
 
         usb_mark_last_busy(udev);
-        atomic_dec(&intf->pm_usage_cnt);
         pm_runtime_put_noidle(&intf->dev);
 }
 EXPORT_SYMBOL_GPL(usb_autopm_put_interface_no_suspend);
@@ -1715,8 +1707,6 @@ int usb_autopm_get_interface(struct usb_interface *intf)
         status = pm_runtime_get_sync(&intf->dev);
         if (status < 0)
                 pm_runtime_put_sync(&intf->dev);
-        else
-                atomic_inc(&intf->pm_usage_cnt);
         dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
                         __func__, atomic_read(&intf->dev.power.usage_count),
                         status);
@@ -1750,8 +1740,6 @@ int usb_autopm_get_interface_async(struct usb_interface *intf)
         status = pm_runtime_get(&intf->dev);
         if (status < 0 && status != -EINPROGRESS)
                 pm_runtime_put_noidle(&intf->dev);
-        else
-                atomic_inc(&intf->pm_usage_cnt);
         dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
                         __func__, atomic_read(&intf->dev.power.usage_count),
                         status);
@@ -1775,7 +1763,6 @@ void usb_autopm_get_interface_no_resume(struct usb_interface *intf)
         struct usb_device       *udev = interface_to_usbdev(intf);
 
         usb_mark_last_busy(udev);
-        atomic_inc(&intf->pm_usage_cnt);
         pm_runtime_get_noresume(&intf->dev);
 }
 EXPORT_SYMBOL_GPL(usb_autopm_get_interface_no_resume);
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index 82239f27c4cc..e844bb7b5676 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -820,9 +820,11 @@ int usb_string(struct usb_device *dev, int index, char *buf, size_t size)
 
         if (dev->state == USB_STATE_SUSPENDED)
                 return -EHOSTUNREACH;
-        if (size <= 0 || !buf || !index)
+        if (size <= 0 || !buf)
                 return -EINVAL;
         buf[0] = 0;
+        if (index <= 0 || index >= 256)
+                return -EINVAL;
         tbuf = kmalloc(256, GFP_NOIO);
         if (!tbuf)
                 return -ENOMEM;
diff --git a/drivers/usb/gadget/udc/dummy_hcd.c b/drivers/usb/gadget/udc/dummy_hcd.c
index baf72f95f0f1..213b52508621 100644
--- a/drivers/usb/gadget/udc/dummy_hcd.c
+++ b/drivers/usb/gadget/udc/dummy_hcd.c
@@ -979,8 +979,18 @@ static int dummy_udc_start(struct usb_gadget *g,
         struct dummy_hcd        *dum_hcd = gadget_to_dummy_hcd(g);
         struct dummy            *dum = dum_hcd->dum;
 
-        if (driver->max_speed == USB_SPEED_UNKNOWN)
+        switch (g->speed) {
+        /* All the speeds we support */
+        case USB_SPEED_LOW:
+        case USB_SPEED_FULL:
+        case USB_SPEED_HIGH:
+        case USB_SPEED_SUPER:
+                break;
+        default:
+                dev_err(dummy_dev(dum_hcd), "Unsupported driver max speed %d\n",
+                                driver->max_speed);
                 return -EINVAL;
+        }
 
         /*
          * SLAVE side init ... the layer above hardware, which
@@ -1784,9 +1794,10 @@ static void dummy_timer(struct timer_list *t)
                 /* Bus speed is 500000 bytes/ms, so use a little less */
                 total = 490000;
                 break;
-        default:
+        default:        /* Can't happen */
                 dev_err(dummy_dev(dum_hcd), "bogus device speed\n");
-                return;
+                total = 0;
+                break;
         }
 
         /* FIXME if HZ != 1000 this will probably misbehave ... */
@@ -1828,7 +1839,7 @@ restart:
 
                 /* Used up this frame's bandwidth? */
                 if (total <= 0)
-                        break;
+                        continue;
 
                 /* find the gadget's ep for this request (if configured) */
                 address = usb_pipeendpoint (urb->pipe);
diff --git a/drivers/usb/misc/yurex.c b/drivers/usb/misc/yurex.c
index 6d9fd5f64903..7b306aa22d25 100644
--- a/drivers/usb/misc/yurex.c
+++ b/drivers/usb/misc/yurex.c
@@ -314,6 +314,7 @@ static void yurex_disconnect(struct usb_interface *interface)
         usb_deregister_dev(interface, &yurex_class);
 
         /* prevent more I/O from starting */
+        usb_poison_urb(dev->urb);
         mutex_lock(&dev->io_mutex);
         dev->interface = NULL;
         mutex_unlock(&dev->io_mutex);
diff --git a/drivers/usb/storage/realtek_cr.c b/drivers/usb/storage/realtek_cr.c
index 31b024441938..cc794e25a0b6 100644
--- a/drivers/usb/storage/realtek_cr.c
+++ b/drivers/usb/storage/realtek_cr.c
@@ -763,18 +763,16 @@ static void rts51x_suspend_timer_fn(struct timer_list *t)
                 break;
         case RTS51X_STAT_IDLE:
         case RTS51X_STAT_SS:
-                usb_stor_dbg(us, "RTS51X_STAT_SS, intf->pm_usage_cnt:%d, power.usage:%d\n",
-                             atomic_read(&us->pusb_intf->pm_usage_cnt),
+                usb_stor_dbg(us, "RTS51X_STAT_SS, power.usage:%d\n",
                              atomic_read(&us->pusb_intf->dev.power.usage_count));
 
-                if (atomic_read(&us->pusb_intf->pm_usage_cnt) > 0) {
+                if (atomic_read(&us->pusb_intf->dev.power.usage_count) > 0) {
                         usb_stor_dbg(us, "Ready to enter SS state\n");
                         rts51x_set_stat(chip, RTS51X_STAT_SS);
                         /* ignore mass storage interface's children */
                         pm_suspend_ignore_children(&us->pusb_intf->dev, true);
                         usb_autopm_put_interface_async(us->pusb_intf);
-                        usb_stor_dbg(us, "RTS51X_STAT_SS 01, intf->pm_usage_cnt:%d, power.usage:%d\n",
-                                     atomic_read(&us->pusb_intf->pm_usage_cnt),
+                        usb_stor_dbg(us, "RTS51X_STAT_SS 01, power.usage:%d\n",
                                      atomic_read(&us->pusb_intf->dev.power.usage_count));
                 }
                 break;
@@ -807,11 +805,10 @@ static void rts51x_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
         int ret;
 
         if (working_scsi(srb)) {
-                usb_stor_dbg(us, "working scsi, intf->pm_usage_cnt:%d, power.usage:%d\n",
-                             atomic_read(&us->pusb_intf->pm_usage_cnt),
+                usb_stor_dbg(us, "working scsi, power.usage:%d\n",
                              atomic_read(&us->pusb_intf->dev.power.usage_count));
 
-                if (atomic_read(&us->pusb_intf->pm_usage_cnt) <= 0) {
+                if (atomic_read(&us->pusb_intf->dev.power.usage_count) <= 0) {
                         ret = usb_autopm_get_interface(us->pusb_intf);
                         usb_stor_dbg(us, "working scsi, ret=%d\n", ret);
                 }
diff --git a/drivers/usb/usbip/stub_rx.c b/drivers/usb/usbip/stub_rx.c
index 97b09a42a10c..dbfb2f24d71e 100644
--- a/drivers/usb/usbip/stub_rx.c
+++ b/drivers/usb/usbip/stub_rx.c
@@ -361,16 +361,10 @@ static int get_pipe(struct stub_device *sdev, struct usbip_header *pdu)
         }
 
         if (usb_endpoint_xfer_isoc(epd)) {
-                /* validate packet size and number of packets */
-                unsigned int maxp, packets, bytes;
-
-                maxp = usb_endpoint_maxp(epd);
-                maxp *= usb_endpoint_maxp_mult(epd);
-                bytes = pdu->u.cmd_submit.transfer_buffer_length;
-                packets = DIV_ROUND_UP(bytes, maxp);
-
+                /* validate number of packets */
                 if (pdu->u.cmd_submit.number_of_packets < 0 ||
-                    pdu->u.cmd_submit.number_of_packets > packets) {
+                    pdu->u.cmd_submit.number_of_packets >
+                    USBIP_MAX_ISO_PACKETS) {
                         dev_err(&sdev->udev->dev,
                                 "CMD_SUBMIT: isoc invalid num packets %d\n",
                                 pdu->u.cmd_submit.number_of_packets);
diff --git a/drivers/usb/usbip/usbip_common.h b/drivers/usb/usbip/usbip_common.h
index bf8afe9b5883..8be857a4fa13 100644
--- a/drivers/usb/usbip/usbip_common.h
+++ b/drivers/usb/usbip/usbip_common.h
@@ -121,6 +121,13 @@ extern struct device_attribute dev_attr_usbip_debug;
 #define USBIP_DIR_OUT   0x00
 #define USBIP_DIR_IN    0x01
 
+/*
+ * Arbitrary limit for the maximum number of isochronous packets in an URB,
+ * compare for example the uhci_submit_isochronous function in
+ * drivers/usb/host/uhci-q.c
+ */
+#define USBIP_MAX_ISO_PACKETS 1024
+
 /**
  * struct usbip_header_basic - data pertinent to every request
  * @command: the usbip request type
diff --git a/drivers/w1/masters/ds2490.c b/drivers/w1/masters/ds2490.c
index 0f4ecfcdb549..a9fb77585272 100644
--- a/drivers/w1/masters/ds2490.c
+++ b/drivers/w1/masters/ds2490.c
@@ -1016,15 +1016,15 @@ static int ds_probe(struct usb_interface *intf,
         /* alternative 3, 1ms interrupt (greatly speeds search), 64 byte bulk */
         alt = 3;
         err = usb_set_interface(dev->udev,
-                intf->altsetting[alt].desc.bInterfaceNumber, alt);
+                intf->cur_altsetting->desc.bInterfaceNumber, alt);
         if (err) {
                 dev_err(&dev->udev->dev, "Failed to set alternative setting %d "
                         "for %d interface: err=%d.\n", alt,
-                        intf->altsetting[alt].desc.bInterfaceNumber, err);
+                        intf->cur_altsetting->desc.bInterfaceNumber, err);
                 goto err_out_clear;
         }
 
-        iface_desc = &intf->altsetting[alt];
+        iface_desc = intf->cur_altsetting;
         if (iface_desc->desc.bNumEndpoints != NUM_EP-1) {
                 pr_info("Num endpoints=%d. It is not DS9490R.\n",
                         iface_desc->desc.bNumEndpoints);
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 24615c76c1d0..bb28e2ead679 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -264,7 +264,8 @@ __blkdev_direct_IO_simple(struct kiocb *iocb, struct iov_iter *iter,
         bio_for_each_segment_all(bvec, &bio, i, iter_all) {
                 if (should_dirty && !PageCompound(bvec->bv_page))
                         set_page_dirty_lock(bvec->bv_page);
-                put_page(bvec->bv_page);
+                if (!bio_flagged(&bio, BIO_NO_PAGE_REF))
+                        put_page(bvec->bv_page);
         }
 
         if (unlikely(bio.bi_status))
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index 920bf3b4b0ef..cccc75d15970 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -7,6 +7,7 @@
 #include <linux/slab.h>
 #include <linux/pagemap.h>
 #include <linux/highmem.h>
+#include <linux/sched/mm.h>
 #include "ctree.h"
 #include "disk-io.h"
 #include "transaction.h"
@@ -427,9 +428,13 @@ blk_status_t btrfs_csum_one_bio(struct inode *inode, struct bio *bio,
         unsigned long this_sum_bytes = 0;
         int i;
         u64 offset;
+        unsigned nofs_flag;
+
+        nofs_flag = memalloc_nofs_save();
+        sums = kvzalloc(btrfs_ordered_sum_size(fs_info, bio->bi_iter.bi_size),
+                       GFP_KERNEL);
+        memalloc_nofs_restore(nofs_flag);
 
-        sums = kzalloc(btrfs_ordered_sum_size(fs_info, bio->bi_iter.bi_size),
-                       GFP_NOFS);
         if (!sums)
                 return BLK_STS_RESOURCE;
 
@@ -472,8 +477,10 @@ blk_status_t btrfs_csum_one_bio(struct inode *inode, struct bio *bio,
 
                                 bytes_left = bio->bi_iter.bi_size - total_bytes;
 
-                                sums = kzalloc(btrfs_ordered_sum_size(fs_info, bytes_left),
-                                               GFP_NOFS);
+                                nofs_flag = memalloc_nofs_save();
+                                sums = kvzalloc(btrfs_ordered_sum_size(fs_info,
+                                                      bytes_left), GFP_KERNEL);
+                                memalloc_nofs_restore(nofs_flag);
                                 BUG_ON(!sums); /* -ENOMEM */
                                 sums->len = bytes_left;
                                 ordered = btrfs_lookup_ordered_extent(inode,
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 82fdda8ff5ab..2973608824ec 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -6783,7 +6783,7 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,
         u64 extent_start = 0;
         u64 extent_end = 0;
         u64 objectid = btrfs_ino(inode);
-        u8 extent_type;
+        int extent_type = -1;
         struct btrfs_path *path = NULL;
         struct btrfs_root *root = inode->root;
         struct btrfs_file_extent_item *item;
diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index 6fde2b2741ef..45e3cfd1198b 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -6,6 +6,7 @@
 #include <linux/slab.h>
 #include <linux/blkdev.h>
 #include <linux/writeback.h>
+#include <linux/sched/mm.h>
 #include "ctree.h"
 #include "transaction.h"
 #include "btrfs_inode.h"
@@ -442,7 +443,7 @@ void btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry)
                         cur = entry->list.next;
                         sum = list_entry(cur, struct btrfs_ordered_sum, list);
                         list_del(&sum->list);
-                        kfree(sum);
+                        kvfree(sum);
                 }
                 kmem_cache_free(btrfs_ordered_extent_cache, entry);
         }
diff --git a/fs/ceph/dir.c b/fs/ceph/dir.c
index a8f429882249..0637149fb9f9 100644
--- a/fs/ceph/dir.c
+++ b/fs/ceph/dir.c
@@ -1766,6 +1766,7 @@ static ssize_t ceph_read_dir(struct file *file, char __user *buf, size_t size,
 unsigned ceph_dentry_hash(struct inode *dir, struct dentry *dn)
 {
         struct ceph_inode_info *dci = ceph_inode(dir);
+        unsigned hash;
 
         switch (dci->i_dir_layout.dl_dir_hash) {
         case 0: /* for backward compat */
@@ -1773,8 +1774,11 @@ unsigned ceph_dentry_hash(struct inode *dir, struct dentry *dn)
                 return dn->d_name.hash;
 
         default:
-                return ceph_str_hash(dci->i_dir_layout.dl_dir_hash,
+                spin_lock(&dn->d_lock);
+                hash = ceph_str_hash(dci->i_dir_layout.dl_dir_hash,
                                      dn->d_name.name, dn->d_name.len);
+                spin_unlock(&dn->d_lock);
+                return hash;
         }
 }
 
diff --git a/fs/ceph/inode.c b/fs/ceph/inode.c
index 2d61ddda9bf5..c2feb310ac1e 100644
--- a/fs/ceph/inode.c
+++ b/fs/ceph/inode.c
@@ -1163,6 +1163,19 @@ static int splice_dentry(struct dentry **pdn, struct inode *in)
         return 0;
 }
 
+static int d_name_cmp(struct dentry *dentry, const char *name, size_t len)
+{
+        int ret;
+
+        /* take d_lock to ensure dentry->d_name stability */
+        spin_lock(&dentry->d_lock);
+        ret = dentry->d_name.len - len;
+        if (!ret)
+                ret = memcmp(dentry->d_name.name, name, len);
+        spin_unlock(&dentry->d_lock);
+        return ret;
+}
+
 /*
  * Incorporate results into the local cache.  This is either just
  * one inode, or a directory, dentry, and possibly linked-to inode (e.g.,
@@ -1412,7 +1425,8 @@ retry_lookup:
                 err = splice_dentry(&req->r_dentry, in);
                 if (err < 0)
                         goto done;
-        } else if (rinfo->head->is_dentry) {
+        } else if (rinfo->head->is_dentry &&
+                   !d_name_cmp(req->r_dentry, rinfo->dname, rinfo->dname_len)) {
                 struct ceph_vino *ptvino = NULL;
 
                 if ((le32_to_cpu(rinfo->diri.in->cap.caps) & CEPH_CAP_FILE_SHARED) ||
diff --git a/fs/ceph/mds_client.c b/fs/ceph/mds_client.c
index 21c33ed048ed..9049c2a3e972 100644
--- a/fs/ceph/mds_client.c
+++ b/fs/ceph/mds_client.c
@@ -1414,6 +1414,15 @@ static int remove_session_caps_cb(struct inode *inode, struct ceph_cap *cap,
                         list_add(&ci->i_prealloc_cap_flush->i_list, &to_remove);
                         ci->i_prealloc_cap_flush = NULL;
                 }
+
+               if (drop &&
+                  ci->i_wrbuffer_ref_head == 0 &&
+                  ci->i_wr_ref == 0 &&
+                  ci->i_dirty_caps == 0 &&
+                  ci->i_flushing_caps == 0) {
+                      ceph_put_snap_context(ci->i_head_snapc);
+                      ci->i_head_snapc = NULL;
+               }
         }
         spin_unlock(&ci->i_ceph_lock);
         while (!list_empty(&to_remove)) {
@@ -2161,10 +2170,39 @@ retry:
         return path;
 }
 
+/* Duplicate the dentry->d_name.name safely */
+static int clone_dentry_name(struct dentry *dentry, const char **ppath,
+                             int *ppathlen)
+{
+        u32 len;
+        char *name;
+
+retry:
+        len = READ_ONCE(dentry->d_name.len);
+        name = kmalloc(len + 1, GFP_NOFS);
+        if (!name)
+                return -ENOMEM;
+
+        spin_lock(&dentry->d_lock);
+        if (dentry->d_name.len != len) {
+                spin_unlock(&dentry->d_lock);
+                kfree(name);
+                goto retry;
+        }
+        memcpy(name, dentry->d_name.name, len);
+        spin_unlock(&dentry->d_lock);
+
+        name[len] = '\0';
+        *ppath = name;
+        *ppathlen = len;
+        return 0;
+}
+
 static int build_dentry_path(struct dentry *dentry, struct inode *dir,
                              const char **ppath, int *ppathlen, u64 *pino,
-                             int *pfreepath)
+                             bool *pfreepath, bool parent_locked)
 {
+        int ret;
         char *path;
 
         rcu_read_lock();
@@ -2173,8 +2211,15 @@ static int build_dentry_path(struct dentry *dentry, struct inode *dir,
         if (dir && ceph_snap(dir) == CEPH_NOSNAP) {
                 *pino = ceph_ino(dir);
                 rcu_read_unlock();
-                *ppath = dentry->d_name.name;
-                *ppathlen = dentry->d_name.len;
+                if (parent_locked) {
+                        *ppath = dentry->d_name.name;
+                        *ppathlen = dentry->d_name.len;
+                } else {
+                        ret = clone_dentry_name(dentry, ppath, ppathlen);
+                        if (ret)
+                                return ret;
+                        *pfreepath = true;
+                }
                 return 0;
         }
         rcu_read_unlock();
@@ -2182,13 +2227,13 @@ static int build_dentry_path(struct dentry *dentry, struct inode *dir,
         if (IS_ERR(path))
                 return PTR_ERR(path);
         *ppath = path;
-        *pfreepath = 1;
+        *pfreepath = true;
         return 0;
 }
 
 static int build_inode_path(struct inode *inode,
                             const char **ppath, int *ppathlen, u64 *pino,
-                            int *pfreepath)
+                            bool *pfreepath)
 {
         struct dentry *dentry;
         char *path;
@@ -2204,7 +2249,7 @@ static int build_inode_path(struct inode *inode,
         if (IS_ERR(path))
                 return PTR_ERR(path);
         *ppath = path;
-        *pfreepath = 1;
+        *pfreepath = true;
         return 0;
 }
 
@@ -2215,7 +2260,7 @@ static int build_inode_path(struct inode *inode,
 static int set_request_path_attr(struct inode *rinode, struct dentry *rdentry,
                                   struct inode *rdiri, const char *rpath,
                                   u64 rino, const char **ppath, int *pathlen,
-                                  u64 *ino, int *freepath)
+                                  u64 *ino, bool *freepath, bool parent_locked)
 {
         int r = 0;
 
@@ -2225,7 +2270,7 @@ static int set_request_path_attr(struct inode *rinode, struct dentry *rdentry,
                      ceph_snap(rinode));
         } else if (rdentry) {
                 r = build_dentry_path(rdentry, rdiri, ppath, pathlen, ino,
-                                        freepath);
+                                        freepath, parent_locked);
                 dout(" dentry %p %llx/%.*s\n", rdentry, *ino, *pathlen,
                      *ppath);
         } else if (rpath || rino) {
@@ -2251,7 +2296,7 @@ static struct ceph_msg *create_request_message(struct ceph_mds_client *mdsc,
         const char *path2 = NULL;
         u64 ino1 = 0, ino2 = 0;
         int pathlen1 = 0, pathlen2 = 0;
-        int freepath1 = 0, freepath2 = 0;
+        bool freepath1 = false, freepath2 = false;
         int len;
         u16 releases;
         void *p, *end;
@@ -2259,16 +2304,19 @@ static struct ceph_msg *create_request_message(struct ceph_mds_client *mdsc,
 
         ret = set_request_path_attr(req->r_inode, req->r_dentry,
                               req->r_parent, req->r_path1, req->r_ino1.ino,
-                              &path1, &pathlen1, &ino1, &freepath1);
+                              &path1, &pathlen1, &ino1, &freepath1,
+                              test_bit(CEPH_MDS_R_PARENT_LOCKED,
+                                        &req->r_req_flags));
         if (ret < 0) {
                 msg = ERR_PTR(ret);
                 goto out;
         }
 
+        /* If r_old_dentry is set, then assume that its parent is locked */
         ret = set_request_path_attr(NULL, req->r_old_dentry,
                               req->r_old_dentry_dir,
                               req->r_path2, req->r_ino2.ino,
-                              &path2, &pathlen2, &ino2, &freepath2);
+                              &path2, &pathlen2, &ino2, &freepath2, true);
         if (ret < 0) {
                 msg = ERR_PTR(ret);
                 goto out_free1;
diff --git a/fs/ceph/snap.c b/fs/ceph/snap.c
index 89aa37fa0f84..b26e12cd8ec3 100644
--- a/fs/ceph/snap.c
+++ b/fs/ceph/snap.c
@@ -572,7 +572,12 @@ void ceph_queue_cap_snap(struct ceph_inode_info *ci)
         old_snapc = NULL;
 
 update_snapc:
-        if (ci->i_head_snapc) {
+       if (ci->i_wrbuffer_ref_head == 0 &&
+           ci->i_wr_ref == 0 &&
+           ci->i_dirty_caps == 0 &&
+           ci->i_flushing_caps == 0) {
+               ci->i_head_snapc = NULL;
+       } else {
                 ci->i_head_snapc = ceph_get_snap_context(new_snapc);
                 dout(" new snapc is %p\n", new_snapc);
         }
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 9c0ccc06d172..7037a137fa53 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -2877,7 +2877,6 @@ static void collect_uncached_write_data(struct cifs_aio_ctx *ctx)
         struct cifs_tcon *tcon;
         struct cifs_sb_info *cifs_sb;
         struct dentry *dentry = ctx->cfile->dentry;
-        unsigned int i;
         int rc;
 
         tcon = tlink_tcon(ctx->cfile->tlink);
@@ -2941,10 +2940,6 @@ restart_loop:
                 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
         }
 
-        if (!ctx->direct_io)
-                for (i = 0; i < ctx->npages; i++)
-                        put_page(ctx->bv[i].bv_page);
-
         cifs_stats_bytes_written(tcon, ctx->total_len);
         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(dentry->d_inode)->flags);
 
@@ -3582,7 +3577,6 @@ collect_uncached_read_data(struct cifs_aio_ctx *ctx)
         struct iov_iter *to = &ctx->iter;
         struct cifs_sb_info *cifs_sb;
         struct cifs_tcon *tcon;
-        unsigned int i;
         int rc;
 
         tcon = tlink_tcon(ctx->cfile->tlink);
@@ -3666,15 +3660,8 @@ again:
                 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
         }
 
-        if (!ctx->direct_io) {
-                for (i = 0; i < ctx->npages; i++) {
-                        if (ctx->should_dirty)
-                                set_page_dirty(ctx->bv[i].bv_page);
-                        put_page(ctx->bv[i].bv_page);
-                }
-
+        if (!ctx->direct_io)
                 ctx->total_len = ctx->len - iov_iter_count(to);
-        }
 
         /* mask nodata case */
         if (rc == -ENODATA)
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index 53fdb5df0d2e..538fd7d807e4 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -1735,6 +1735,10 @@ cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
         if (rc == 0 || rc != -EBUSY)
                 goto do_rename_exit;
 
+        /* Don't fall back to using SMB on SMB 2+ mount */
+        if (server->vals->protocol_id != 0)
+                goto do_rename_exit;
+
         /* open-file renames don't work across directories */
         if (to_dentry->d_parent != from_dentry->d_parent)
                 goto do_rename_exit;
diff --git a/fs/cifs/misc.c b/fs/cifs/misc.c
index 1e1626a2cfc3..0dc6f08020ac 100644
--- a/fs/cifs/misc.c
+++ b/fs/cifs/misc.c
@@ -789,6 +789,11 @@ cifs_aio_ctx_alloc(void)
 {
         struct cifs_aio_ctx *ctx;
 
+        /*
+         * Must use kzalloc to initialize ctx->bv to NULL and ctx->direct_io
+         * to false so that we know when we have to unreference pages within
+         * cifs_aio_ctx_release()
+         */
         ctx = kzalloc(sizeof(struct cifs_aio_ctx), GFP_KERNEL);
         if (!ctx)
                 return NULL;
@@ -807,7 +812,23 @@ cifs_aio_ctx_release(struct kref *refcount)
                                         struct cifs_aio_ctx, refcount);
 
         cifsFileInfo_put(ctx->cfile);
-        kvfree(ctx->bv);
+
+        /*
+         * ctx->bv is only set if setup_aio_ctx_iter() was call successfuly
+         * which means that iov_iter_get_pages() was a success and thus that
+         * we have taken reference on pages.
+         */
+        if (ctx->bv) {
+                unsigned i;
+
+                for (i = 0; i < ctx->npages; i++) {
+                        if (ctx->should_dirty)
+                                set_page_dirty(ctx->bv[i].bv_page);
+                        put_page(ctx->bv[i].bv_page);
+                }
+                kvfree(ctx->bv);
+        }
+
         kfree(ctx);
 }
 
diff --git a/fs/cifs/smb2pdu.c b/fs/cifs/smb2pdu.c
index b8f7262ac354..a37774a55f3a 100644
--- a/fs/cifs/smb2pdu.c
+++ b/fs/cifs/smb2pdu.c
@@ -3466,6 +3466,7 @@ SMB2_read(const unsigned int xid, struct cifs_io_parms *io_parms,
                                     io_parms->tcon->tid, ses->Suid,
                                     io_parms->offset, 0);
                 free_rsp_buf(resp_buftype, rsp_iov.iov_base);
+                cifs_small_buf_release(req);
                 return rc == -ENODATA ? 0 : rc;
         } else
                 trace_smb3_read_done(xid, req->PersistentFileId,
diff --git a/fs/io_uring.c b/fs/io_uring.c
index f65f85d89217..84efb8956734 100644
--- a/fs/io_uring.c
+++ b/fs/io_uring.c
@@ -4,15 +4,28 @@
  * supporting fast/efficient IO.
  *
  * A note on the read/write ordering memory barriers that are matched between
- * the application and kernel side. When the application reads the CQ ring
- * tail, it must use an appropriate smp_rmb() to order with the smp_wmb()
- * the kernel uses after writing the tail. Failure to do so could cause a
- * delay in when the application notices that completion events available.
- * This isn't a fatal condition. Likewise, the application must use an
- * appropriate smp_wmb() both before writing the SQ tail, and after writing
- * the SQ tail. The first one orders the sqe writes with the tail write, and
- * the latter is paired with the smp_rmb() the kernel will issue before
- * reading the SQ tail on submission.
+ * the application and kernel side.
+ *
+ * After the application reads the CQ ring tail, it must use an
+ * appropriate smp_rmb() to pair with the smp_wmb() the kernel uses
+ * before writing the tail (using smp_load_acquire to read the tail will
+ * do). It also needs a smp_mb() before updating CQ head (ordering the
+ * entry load(s) with the head store), pairing with an implicit barrier
+ * through a control-dependency in io_get_cqring (smp_store_release to
+ * store head will do). Failure to do so could lead to reading invalid
+ * CQ entries.
+ *
+ * Likewise, the application must use an appropriate smp_wmb() before
+ * writing the SQ tail (ordering SQ entry stores with the tail store),
+ * which pairs with smp_load_acquire in io_get_sqring (smp_store_release
+ * to store the tail will do). And it needs a barrier ordering the SQ
+ * head load before writing new SQ entries (smp_load_acquire to read
+ * head will do).
+ *
+ * When using the SQ poll thread (IORING_SETUP_SQPOLL), the application
+ * needs to check the SQ flags for IORING_SQ_NEED_WAKEUP *after*
+ * updating the SQ tail; a full memory barrier smp_mb() is needed
+ * between.
  *
  * Also see the examples in the liburing library:
  *
@@ -70,20 +83,108 @@ struct io_uring {
         u32 tail ____cacheline_aligned_in_smp;
 };
 
+/*
+ * This data is shared with the application through the mmap at offset
+ * IORING_OFF_SQ_RING.
+ *
+ * The offsets to the member fields are published through struct
+ * io_sqring_offsets when calling io_uring_setup.
+ */
 struct io_sq_ring {
+        /*
+         * Head and tail offsets into the ring; the offsets need to be
+         * masked to get valid indices.
+         *
+         * The kernel controls head and the application controls tail.
+         */
         struct io_uring         r;
+        /*
+         * Bitmask to apply to head and tail offsets (constant, equals
+         * ring_entries - 1)
+         */
         u32                     ring_mask;
+        /* Ring size (constant, power of 2) */
         u32                     ring_entries;
+        /*
+         * Number of invalid entries dropped by the kernel due to
+         * invalid index stored in array
+         *
+         * Written by the kernel, shouldn't be modified by the
+         * application (i.e. get number of "new events" by comparing to
+         * cached value).
+         *
+         * After a new SQ head value was read by the application this
+         * counter includes all submissions that were dropped reaching
+         * the new SQ head (and possibly more).
+         */
         u32                     dropped;
+        /*
+         * Runtime flags
+         *
+         * Written by the kernel, shouldn't be modified by the
+         * application.
+         *
+         * The application needs a full memory barrier before checking
+         * for IORING_SQ_NEED_WAKEUP after updating the sq tail.
+         */
         u32                     flags;
+        /*
+         * Ring buffer of indices into array of io_uring_sqe, which is
+         * mmapped by the application using the IORING_OFF_SQES offset.
+         *
+         * This indirection could e.g. be used to assign fixed
+         * io_uring_sqe entries to operations and only submit them to
+         * the queue when needed.
+         *
+         * The kernel modifies neither the indices array nor the entries
+         * array.
+         */
         u32                     array[];
 };
 
+/*
+ * This data is shared with the application through the mmap at offset
+ * IORING_OFF_CQ_RING.
+ *
+ * The offsets to the member fields are published through struct
+ * io_cqring_offsets when calling io_uring_setup.
+ */
 struct io_cq_ring {
+        /*
+         * Head and tail offsets into the ring; the offsets need to be
+         * masked to get valid indices.
+         *
+         * The application controls head and the kernel tail.
+         */
         struct io_uring         r;
+        /*
+         * Bitmask to apply to head and tail offsets (constant, equals
+         * ring_entries - 1)
+         */
         u32                     ring_mask;
+        /* Ring size (constant, power of 2) */
         u32                     ring_entries;
+        /*
+         * Number of completion events lost because the queue was full;
+         * this should be avoided by the application by making sure
+         * there are not more requests pending thatn there is space in
+         * the completion queue.
+         *
+         * Written by the kernel, shouldn't be modified by the
+         * application (i.e. get number of "new events" by comparing to
+         * cached value).
+         *
+         * As completion events come in out of order this counter is not
+         * ordered with any other data.
+         */
         u32                     overflow;
+        /*
+         * Ring buffer of completion events.
+         *
+         * The kernel writes completion events fresh every time they are
+         * produced, so the application is allowed to modify pending
+         * entries.
+         */
         struct io_uring_cqe     cqes[];
 };
 
@@ -221,7 +322,7 @@ struct io_kiocb {
         struct list_head        list;
         unsigned int            flags;
         refcount_t              refs;
-#define REQ_F_FORCE_NONBLOCK    1       /* inline submission attempt */
+#define REQ_F_NOWAIT            1       /* must not punt to workers */
 #define REQ_F_IOPOLL_COMPLETED  2       /* polled IO has completed */
 #define REQ_F_FIXED_FILE        4       /* ctx owns file */
 #define REQ_F_SEQ_PREV          8       /* sequential with previous */
@@ -317,12 +418,6 @@ static void io_commit_cqring(struct io_ring_ctx *ctx)
                 /* order cqe stores with ring update */
                 smp_store_release(&ring->r.tail, ctx->cached_cq_tail);
 
-                /*
-                 * Write sider barrier of tail update, app has read side. See
-                 * comment at the top of this file.
-                 */
-                smp_wmb();
-
                 if (wq_has_sleeper(&ctx->cq_wait)) {
                         wake_up_interruptible(&ctx->cq_wait);
                         kill_fasync(&ctx->cq_fasync, SIGIO, POLL_IN);
@@ -336,8 +431,11 @@ static struct io_uring_cqe *io_get_cqring(struct io_ring_ctx *ctx)
         unsigned tail;
 
         tail = ctx->cached_cq_tail;
-        /* See comment at the top of the file */
-        smp_rmb();
+        /*
+         * writes to the cq entry need to come after reading head; the
+         * control dependency is enough as we're using WRITE_ONCE to
+         * fill the cq entry
+         */
         if (tail - READ_ONCE(ring->r.head) == ring->ring_entries)
                 return NULL;
 
@@ -740,7 +838,7 @@ static bool io_file_supports_async(struct file *file)
 }
 
 static int io_prep_rw(struct io_kiocb *req, const struct sqe_submit *s,
-                      bool force_nonblock, struct io_submit_state *state)
+                      bool force_nonblock)
 {
         const struct io_uring_sqe *sqe = s->sqe;
         struct io_ring_ctx *ctx = req->ctx;
@@ -774,10 +872,14 @@ static int io_prep_rw(struct io_kiocb *req, const struct sqe_submit *s,
         ret = kiocb_set_rw_flags(kiocb, READ_ONCE(sqe->rw_flags));
         if (unlikely(ret))
                 return ret;
-        if (force_nonblock) {
+
+        /* don't allow async punt if RWF_NOWAIT was requested */
+        if (kiocb->ki_flags & IOCB_NOWAIT)
+                req->flags |= REQ_F_NOWAIT;
+
+        if (force_nonblock)
                 kiocb->ki_flags |= IOCB_NOWAIT;
-                req->flags |= REQ_F_FORCE_NONBLOCK;
-        }
+
         if (ctx->flags & IORING_SETUP_IOPOLL) {
                 if (!(kiocb->ki_flags & IOCB_DIRECT) ||
                     !kiocb->ki_filp->f_op->iopoll)
@@ -938,7 +1040,7 @@ static void io_async_list_note(int rw, struct io_kiocb *req, size_t len)
 }
 
 static int io_read(struct io_kiocb *req, const struct sqe_submit *s,
-                   bool force_nonblock, struct io_submit_state *state)
+                   bool force_nonblock)
 {
         struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
         struct kiocb *kiocb = &req->rw;
@@ -947,7 +1049,7 @@ static int io_read(struct io_kiocb *req, const struct sqe_submit *s,
         size_t iov_count;
         int ret;
 
-        ret = io_prep_rw(req, s, force_nonblock, state);
+        ret = io_prep_rw(req, s, force_nonblock);
         if (ret)
                 return ret;
         file = kiocb->ki_filp;
@@ -985,7 +1087,7 @@ static int io_read(struct io_kiocb *req, const struct sqe_submit *s,
 }
 
 static int io_write(struct io_kiocb *req, const struct sqe_submit *s,
-                    bool force_nonblock, struct io_submit_state *state)
+                    bool force_nonblock)
 {
         struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
         struct kiocb *kiocb = &req->rw;
@@ -994,7 +1096,7 @@ static int io_write(struct io_kiocb *req, const struct sqe_submit *s,
         size_t iov_count;
         int ret;
 
-        ret = io_prep_rw(req, s, force_nonblock, state);
+        ret = io_prep_rw(req, s, force_nonblock);
         if (ret)
                 return ret;
 
@@ -1336,8 +1438,7 @@ static int io_poll_add(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 }
 
 static int __io_submit_sqe(struct io_ring_ctx *ctx, struct io_kiocb *req,
-                           const struct sqe_submit *s, bool force_nonblock,
-                           struct io_submit_state *state)
+                           const struct sqe_submit *s, bool force_nonblock)
 {
         int ret, opcode;
 
@@ -1353,18 +1454,18 @@ static int __io_submit_sqe(struct io_ring_ctx *ctx, struct io_kiocb *req,
         case IORING_OP_READV:
                 if (unlikely(s->sqe->buf_index))
                         return -EINVAL;
-                ret = io_read(req, s, force_nonblock, state);
+                ret = io_read(req, s, force_nonblock);
                 break;
         case IORING_OP_WRITEV:
                 if (unlikely(s->sqe->buf_index))
                         return -EINVAL;
-                ret = io_write(req, s, force_nonblock, state);
+                ret = io_write(req, s, force_nonblock);
                 break;
         case IORING_OP_READ_FIXED:
-                ret = io_read(req, s, force_nonblock, state);
+                ret = io_read(req, s, force_nonblock);
                 break;
         case IORING_OP_WRITE_FIXED:
-                ret = io_write(req, s, force_nonblock, state);
+                ret = io_write(req, s, force_nonblock);
                 break;
         case IORING_OP_FSYNC:
                 ret = io_fsync(req, s->sqe, force_nonblock);
@@ -1437,8 +1538,7 @@ restart:
                 struct sqe_submit *s = &req->submit;
                 const struct io_uring_sqe *sqe = s->sqe;
 
-                /* Ensure we clear previously set forced non-block flag */
-                req->flags &= ~REQ_F_FORCE_NONBLOCK;
+                /* Ensure we clear previously set non-block flag */
                 req->rw.ki_flags &= ~IOCB_NOWAIT;
 
                 ret = 0;
@@ -1457,7 +1557,7 @@ restart:
                         s->has_user = cur_mm != NULL;
                         s->needs_lock = true;
                         do {
-                                ret = __io_submit_sqe(ctx, req, s, false, NULL);
+                                ret = __io_submit_sqe(ctx, req, s, false);
                                 /*
                                  * We can get EAGAIN for polled IO even though
                                  * we're forcing a sync submission from here,
@@ -1468,10 +1568,11 @@ restart:
                                         break;
                                 cond_resched();
                         } while (1);
-
-                        /* drop submission reference */
-                        io_put_req(req);
                 }
+
+                /* drop submission reference */
+                io_put_req(req);
+
                 if (ret) {
                         io_cqring_add_event(ctx, sqe->user_data, ret, 0);
                         io_put_req(req);
@@ -1623,8 +1724,8 @@ static int io_submit_sqe(struct io_ring_ctx *ctx, struct sqe_submit *s,
         if (unlikely(ret))
                 goto out;
 
-        ret = __io_submit_sqe(ctx, req, s, true, state);
-        if (ret == -EAGAIN) {
+        ret = __io_submit_sqe(ctx, req, s, true);
+        if (ret == -EAGAIN && !(req->flags & REQ_F_NOWAIT)) {
                 struct io_uring_sqe *sqe_copy;
 
                 sqe_copy = kmalloc(sizeof(*sqe_copy), GFP_KERNEL);
@@ -1698,24 +1799,10 @@ static void io_commit_sqring(struct io_ring_ctx *ctx)
                  * write new data to them.
                  */
                 smp_store_release(&ring->r.head, ctx->cached_sq_head);
-
-                /*
-                 * write side barrier of head update, app has read side. See
-                 * comment at the top of this file
-                 */
-                smp_wmb();
         }
 }
 
 /*
- * Undo last io_get_sqring()
- */
-static void io_drop_sqring(struct io_ring_ctx *ctx)
-{
-        ctx->cached_sq_head--;
-}
-
-/*
  * Fetch an sqe, if one is available. Note that s->sqe will point to memory
  * that is mapped by userspace. This means that care needs to be taken to
  * ensure that reads are stable, as we cannot rely on userspace always
@@ -1737,9 +1824,8 @@ static bool io_get_sqring(struct io_ring_ctx *ctx, struct sqe_submit *s)
          *    though the application is the one updating it.
          */
         head = ctx->cached_sq_head;
-        /* See comment at the top of this file */
-        smp_rmb();
-        if (head == READ_ONCE(ring->r.tail))
+        /* make sure SQ entry isn't read before tail */
+        if (head == smp_load_acquire(&ring->r.tail))
                 return false;
 
         head = READ_ONCE(ring->array[head & ctx->sq_mask]);
@@ -1753,8 +1839,6 @@ static bool io_get_sqring(struct io_ring_ctx *ctx, struct sqe_submit *s)
         /* drop invalid entries */
         ctx->cached_sq_head++;
         ring->dropped++;
-        /* See comment at the top of this file */
-        smp_wmb();
         return false;
 }
 
@@ -1864,7 +1948,8 @@ static int io_sq_thread(void *data)
 
                         /* Tell userspace we may need a wakeup call */
                         ctx->sq_ring->flags |= IORING_SQ_NEED_WAKEUP;
-                        smp_wmb();
+                        /* make sure to read SQ tail after writing flags */
+                        smp_mb();
 
                         if (!io_get_sqring(ctx, &sqes[0])) {
                                 if (kthread_should_stop()) {
@@ -1877,13 +1962,11 @@ static int io_sq_thread(void *data)
                                 finish_wait(&ctx->sqo_wait, &wait);
 
                                 ctx->sq_ring->flags &= ~IORING_SQ_NEED_WAKEUP;
-                                smp_wmb();
                                 continue;
                         }
                         finish_wait(&ctx->sqo_wait, &wait);
 
                         ctx->sq_ring->flags &= ~IORING_SQ_NEED_WAKEUP;
-                        smp_wmb();
                 }
 
                 i = 0;
@@ -1928,7 +2011,7 @@ static int io_sq_thread(void *data)
 static int io_ring_submit(struct io_ring_ctx *ctx, unsigned int to_submit)
 {
         struct io_submit_state state, *statep = NULL;
-        int i, ret = 0, submit = 0;
+        int i, submit = 0;
 
         if (to_submit > IO_PLUG_THRESHOLD) {
                 io_submit_state_start(&state, ctx, to_submit);
@@ -1937,6 +2020,7 @@ static int io_ring_submit(struct io_ring_ctx *ctx, unsigned int to_submit)
 
         for (i = 0; i < to_submit; i++) {
                 struct sqe_submit s;
+                int ret;
 
                 if (!io_get_sqring(ctx, &s))
                         break;
@@ -1944,21 +2028,18 @@ static int io_ring_submit(struct io_ring_ctx *ctx, unsigned int to_submit)
                 s.has_user = true;
                 s.needs_lock = false;
                 s.needs_fixed_file = false;
+                submit++;
 
                 ret = io_submit_sqe(ctx, &s, statep);
-                if (ret) {
-                        io_drop_sqring(ctx);
-                        break;
-                }
-
-                submit++;
+                if (ret)
+                        io_cqring_add_event(ctx, s.sqe->user_data, ret, 0);
         }
         io_commit_sqring(ctx);
 
         if (statep)
                 io_submit_state_end(statep);
 
-        return submit ? submit : ret;
+        return submit;
 }
 
 static unsigned io_cqring_events(struct io_cq_ring *ring)
@@ -2239,10 +2320,6 @@ static int io_sq_offload_start(struct io_ring_ctx *ctx,
         mmgrab(current->mm);
         ctx->sqo_mm = current->mm;
 
-        ret = -EINVAL;
-        if (!cpu_possible(p->sq_thread_cpu))
-                goto err;
-
         if (ctx->flags & IORING_SETUP_SQPOLL) {
                 ret = -EPERM;
                 if (!capable(CAP_SYS_ADMIN))
@@ -2253,11 +2330,11 @@ static int io_sq_offload_start(struct io_ring_ctx *ctx,
                         ctx->sq_thread_idle = HZ;
 
                 if (p->flags & IORING_SETUP_SQ_AFF) {
-                        int cpu;
+                        int cpu = array_index_nospec(p->sq_thread_cpu,
+                                                        nr_cpu_ids);
 
-                        cpu = array_index_nospec(p->sq_thread_cpu, NR_CPUS);
                         ret = -EINVAL;
-                        if (!cpu_possible(p->sq_thread_cpu))
+                        if (!cpu_possible(cpu))
                                 goto err;
 
                         ctx->sqo_thread = kthread_create_on_cpu(io_sq_thread,
@@ -2320,8 +2397,12 @@ static int io_account_mem(struct user_struct *user, unsigned long nr_pages)
 
 static void io_mem_free(void *ptr)
 {
-        struct page *page = virt_to_head_page(ptr);
+        struct page *page;
+
+        if (!ptr)
+                return;
 
+        page = virt_to_head_page(ptr);
         if (put_page_testzero(page))
                 free_compound_page(page);
 }
@@ -2362,7 +2443,7 @@ static int io_sqe_buffer_unregister(struct io_ring_ctx *ctx)
 
                 if (ctx->account_mem)
                         io_unaccount_mem(ctx->user, imu->nr_bvecs);
-                kfree(imu->bvec);
+                kvfree(imu->bvec);
                 imu->nr_bvecs = 0;
         }
 
@@ -2454,9 +2535,9 @@ static int io_sqe_buffer_register(struct io_ring_ctx *ctx, void __user *arg,
                 if (!pages || nr_pages > got_pages) {
                         kfree(vmas);
                         kfree(pages);
-                        pages = kmalloc_array(nr_pages, sizeof(struct page *),
+                        pages = kvmalloc_array(nr_pages, sizeof(struct page *),
                                                 GFP_KERNEL);
-                        vmas = kmalloc_array(nr_pages,
+                        vmas = kvmalloc_array(nr_pages,
                                         sizeof(struct vm_area_struct *),
                                         GFP_KERNEL);
                         if (!pages || !vmas) {
@@ -2468,7 +2549,7 @@ static int io_sqe_buffer_register(struct io_ring_ctx *ctx, void __user *arg,
                         got_pages = nr_pages;
                 }
 
-                imu->bvec = kmalloc_array(nr_pages, sizeof(struct bio_vec),
+                imu->bvec = kvmalloc_array(nr_pages, sizeof(struct bio_vec),
                                                 GFP_KERNEL);
                 ret = -ENOMEM;
                 if (!imu->bvec) {
@@ -2507,6 +2588,7 @@ static int io_sqe_buffer_register(struct io_ring_ctx *ctx, void __user *arg,
                         }
                         if (ctx->account_mem)
                                 io_unaccount_mem(ctx->user, nr_pages);
+                        kvfree(imu->bvec);
                         goto err;
                 }
 
@@ -2529,12 +2611,12 @@ static int io_sqe_buffer_register(struct io_ring_ctx *ctx, void __user *arg,
 
                 ctx->nr_user_bufs++;
         }
-        kfree(pages);
-        kfree(vmas);
+        kvfree(pages);
+        kvfree(vmas);
         return 0;
 err:
-        kfree(pages);
-        kfree(vmas);
+        kvfree(pages);
+        kvfree(vmas);
         io_sqe_buffer_unregister(ctx);
         return ret;
 }
@@ -2572,9 +2654,13 @@ static __poll_t io_uring_poll(struct file *file, poll_table *wait)
         __poll_t mask = 0;
 
         poll_wait(file, &ctx->cq_wait, wait);
-        /* See comment at the top of this file */
+        /*
+         * synchronizes with barrier from wq_has_sleeper call in
+         * io_commit_cqring
+         */
         smp_rmb();
-        if (READ_ONCE(ctx->sq_ring->r.tail) + 1 != ctx->cached_sq_head)
+        if (READ_ONCE(ctx->sq_ring->r.tail) - ctx->cached_sq_head !=
+            ctx->sq_ring->ring_entries)
                 mask |= EPOLLOUT | EPOLLWRNORM;
         if (READ_ONCE(ctx->cq_ring->r.head) != ctx->cached_cq_tail)
                 mask |= EPOLLIN | EPOLLRDNORM;
@@ -2685,24 +2771,12 @@ SYSCALL_DEFINE6(io_uring_enter, unsigned int, fd, u32, to_submit,
                 mutex_lock(&ctx->uring_lock);
                 submitted = io_ring_submit(ctx, to_submit);
                 mutex_unlock(&ctx->uring_lock);
-
-                if (submitted < 0)
-                        goto out_ctx;
         }
         if (flags & IORING_ENTER_GETEVENTS) {
                 unsigned nr_events = 0;
 
                 min_complete = min(min_complete, ctx->cq_entries);
 
-                /*
-                 * The application could have included the 'to_submit' count
-                 * in how many events it wanted to wait for. If we failed to
-                 * submit the desired count, we may need to adjust the number
-                 * of events to poll/wait for.
-                 */
-                if (submitted < to_submit)
-                        min_complete = min_t(unsigned, submitted, min_complete);
-
                 if (ctx->flags & IORING_SETUP_IOPOLL) {
                         mutex_lock(&ctx->uring_lock);
                         ret = io_iopoll_check(ctx, &nr_events, min_complete);
@@ -2748,17 +2822,12 @@ static int io_allocate_scq_urings(struct io_ring_ctx *ctx,
                 return -EOVERFLOW;
 
         ctx->sq_sqes = io_mem_alloc(size);
-        if (!ctx->sq_sqes) {
-                io_mem_free(ctx->sq_ring);
+        if (!ctx->sq_sqes)
                 return -ENOMEM;
-        }
 
         cq_ring = io_mem_alloc(struct_size(cq_ring, cqes, p->cq_entries));
-        if (!cq_ring) {
-                io_mem_free(ctx->sq_ring);
-                io_mem_free(ctx->sq_sqes);
+        if (!cq_ring)
                 return -ENOMEM;
-        }
 
         ctx->cq_ring = cq_ring;
         cq_ring->ring_mask = p->cq_entries - 1;
@@ -2934,6 +3003,14 @@ static int __io_uring_register(struct io_ring_ctx *ctx, unsigned opcode,
 {
         int ret;
 
+        /*
+         * We're inside the ring mutex, if the ref is already dying, then
+         * someone else killed the ctx or is already going through
+         * io_uring_register().
+         */
+        if (percpu_ref_is_dying(&ctx->refs))
+                return -ENXIO;
+
         percpu_ref_kill(&ctx->refs);
 
         /*
diff --git a/fs/notify/fanotify/fanotify.c b/fs/notify/fanotify/fanotify.c
index 6b9c27548997..63c6bb1f8c4d 100644
--- a/fs/notify/fanotify/fanotify.c
+++ b/fs/notify/fanotify/fanotify.c
@@ -346,10 +346,16 @@ static __kernel_fsid_t fanotify_get_fsid(struct fsnotify_iter_info *iter_info)
         __kernel_fsid_t fsid = {};
 
         fsnotify_foreach_obj_type(type) {
+                struct fsnotify_mark_connector *conn;
+
                 if (!fsnotify_iter_should_report_type(iter_info, type))
                         continue;
 
-                fsid = iter_info->marks[type]->connector->fsid;
+                conn = READ_ONCE(iter_info->marks[type]->connector);
+                /* Mark is just getting destroyed or created? */
+                if (!conn)
+                        continue;
+                fsid = conn->fsid;
                 if (WARN_ON_ONCE(!fsid.val[0] && !fsid.val[1]))
                         continue;
                 return fsid;
@@ -408,8 +414,12 @@ static int fanotify_handle_event(struct fsnotify_group *group,
                         return 0;
         }
 
-        if (FAN_GROUP_FLAG(group, FAN_REPORT_FID))
+        if (FAN_GROUP_FLAG(group, FAN_REPORT_FID)) {
                 fsid = fanotify_get_fsid(iter_info);
+                /* Racing with mark destruction or creation? */
+                if (!fsid.val[0] && !fsid.val[1])
+                        return 0;
+        }
 
         event = fanotify_alloc_event(group, inode, mask, data, data_type,
                                      &fsid);
diff --git a/fs/notify/mark.c b/fs/notify/mark.c
index d593d4269561..22acb0a79b53 100644
--- a/fs/notify/mark.c
+++ b/fs/notify/mark.c
@@ -239,13 +239,13 @@ static void fsnotify_drop_object(unsigned int type, void *objp)
 
 void fsnotify_put_mark(struct fsnotify_mark *mark)
 {
-        struct fsnotify_mark_connector *conn;
+        struct fsnotify_mark_connector *conn = READ_ONCE(mark->connector);
         void *objp = NULL;
         unsigned int type = FSNOTIFY_OBJ_TYPE_DETACHED;
         bool free_conn = false;
 
         /* Catch marks that were actually never attached to object */
-        if (!mark->connector) {
+        if (!conn) {
                 if (refcount_dec_and_test(&mark->refcnt))
                         fsnotify_final_mark_destroy(mark);
                 return;
@@ -255,10 +255,9 @@ void fsnotify_put_mark(struct fsnotify_mark *mark)
          * We have to be careful so that traversals of obj_list under lock can
          * safely grab mark reference.
          */
-        if (!refcount_dec_and_lock(&mark->refcnt, &mark->connector->lock))
+        if (!refcount_dec_and_lock(&mark->refcnt, &conn->lock))
                 return;
 
-        conn = mark->connector;
         hlist_del_init_rcu(&mark->obj_list);
         if (hlist_empty(&conn->list)) {
                 objp = fsnotify_detach_connector_from_object(conn, &type);
@@ -266,7 +265,7 @@ void fsnotify_put_mark(struct fsnotify_mark *mark)
         } else {
                 __fsnotify_recalc_mask(conn);
         }
-        mark->connector = NULL;
+        WRITE_ONCE(mark->connector, NULL);
         spin_unlock(&conn->lock);
 
         fsnotify_drop_object(type, objp);
@@ -620,7 +619,7 @@ restart:
         /* mark should be the last entry.  last is the current last entry */
         hlist_add_behind_rcu(&mark->obj_list, &last->obj_list);
 added:
-        mark->connector = conn;
+        WRITE_ONCE(mark->connector, conn);
 out_err:
         spin_unlock(&conn->lock);
         spin_unlock(&mark->lock);
@@ -808,6 +807,7 @@ void fsnotify_init_mark(struct fsnotify_mark *mark,
         refcount_set(&mark->refcnt, 1);
         fsnotify_get_group(group);
         mark->group = group;
+        WRITE_ONCE(mark->connector, NULL);
 }
 
 /*
diff --git a/fs/proc/proc_sysctl.c b/fs/proc/proc_sysctl.c
index 2d61e5e8c863..c74570736b24 100644
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -1643,9 +1643,11 @@ static void drop_sysctl_table(struct ctl_table_header *header)
         if (--header->nreg)
                 return;
 
-        if (parent)
+        if (parent) {
                 put_links(header);
-        start_unregistering(header);
+                start_unregistering(header);
+        }
+
         if (!--header->count)
                 kfree_rcu(header, rcu);
 
diff --git a/fs/splice.c b/fs/splice.c
index 98943d9b219c..25212dcca2df 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -330,8 +330,8 @@ const struct pipe_buf_operations default_pipe_buf_ops = {
         .get = generic_pipe_buf_get,
 };
 
-static int generic_pipe_buf_nosteal(struct pipe_inode_info *pipe,
-                                    struct pipe_buffer *buf)
+int generic_pipe_buf_nosteal(struct pipe_inode_info *pipe,
+                             struct pipe_buffer *buf)
 {
         return 1;
 }
diff --git a/include/drm/ttm/ttm_bo_driver.h b/include/drm/ttm/ttm_bo_driver.h
index cbf3180cb612..668ad971cd7b 100644
--- a/include/drm/ttm/ttm_bo_driver.h
+++ b/include/drm/ttm/ttm_bo_driver.h
@@ -420,7 +420,6 @@ extern struct ttm_bo_global {
         /**
          * Protected by ttm_global_mutex.
          */
-        unsigned int use_count;
         struct list_head device_list;
 
         /**
diff --git a/include/linux/bpf.h b/include/linux/bpf.h
index 9a21848fdb07..59631dd0777c 100644
--- a/include/linux/bpf.h
+++ b/include/linux/bpf.h
@@ -546,7 +546,7 @@ int bpf_prog_array_copy(struct bpf_prog_array __rcu *old_array,
                 }                                       \
 _out:                                                   \
                 rcu_read_unlock();                      \
-                preempt_enable_no_resched();            \
+                preempt_enable();                       \
                 _ret;                                   \
          })
 
diff --git a/include/linux/pipe_fs_i.h b/include/linux/pipe_fs_i.h
index abb2dac3da9b..5c626fdc10db 100644
--- a/include/linux/pipe_fs_i.h
+++ b/include/linux/pipe_fs_i.h
@@ -176,6 +176,7 @@ void free_pipe_info(struct pipe_inode_info *);
 bool generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *);
 int generic_pipe_buf_confirm(struct pipe_inode_info *, struct pipe_buffer *);
 int generic_pipe_buf_steal(struct pipe_inode_info *, struct pipe_buffer *);
+int generic_pipe_buf_nosteal(struct pipe_inode_info *, struct pipe_buffer *);
 void generic_pipe_buf_release(struct pipe_inode_info *, struct pipe_buffer *);
 void pipe_buf_mark_unmergeable(struct pipe_buffer *buf);
 
diff --git a/include/linux/uio.h b/include/linux/uio.h
index f184af1999a8..2d0131ad4604 100644
--- a/include/linux/uio.h
+++ b/include/linux/uio.h
@@ -60,7 +60,7 @@ struct iov_iter {
 
 static inline enum iter_type iov_iter_type(const struct iov_iter *i)
 {
-        return i->type & ~(READ | WRITE);
+        return i->type & ~(READ | WRITE | ITER_BVEC_FLAG_NO_REF);
 }
 
 static inline bool iter_is_iovec(const struct iov_iter *i)
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 5e49e82c4368..ff010d1fd1c7 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -200,7 +200,6 @@ usb_find_last_int_out_endpoint(struct usb_host_interface *alt,
  * @dev: driver model's view of this device
  * @usb_dev: if an interface is bound to the USB major, this will point
  *      to the sysfs representation for that device.
- * @pm_usage_cnt: PM usage counter for this interface
  * @reset_ws: Used for scheduling resets from atomic context.
  * @resetting_device: USB core reset the device, so use alt setting 0 as
  *      current; needs bandwidth alloc after reset.
@@ -257,7 +256,6 @@ struct usb_interface {
 
         struct device dev;              /* interface specific device info */
         struct device *usb_dev;
-        atomic_t pm_usage_cnt;          /* usage counter for autosuspend */
         struct work_struct reset_ws;    /* for resets in atomic context */
 };
 #define to_usb_interface(d) container_of(d, struct usb_interface, dev)
diff --git a/include/net/sctp/command.h b/include/net/sctp/command.h
index 6640f84fe536..6d5beac29bc1 100644
--- a/include/net/sctp/command.h
+++ b/include/net/sctp/command.h
@@ -105,7 +105,6 @@ enum sctp_verb {
         SCTP_CMD_T1_RETRAN,      /* Mark for retransmission after T1 timeout  */
         SCTP_CMD_UPDATE_INITTAG, /* Update peer inittag */
         SCTP_CMD_SEND_MSG,       /* Send the whole use message */
-        SCTP_CMD_SEND_NEXT_ASCONF, /* Send the next ASCONF after ACK */
         SCTP_CMD_PURGE_ASCONF_QUEUE, /* Purge all asconf queues.*/
         SCTP_CMD_SET_ASOC,       /* Restore association context */
         SCTP_CMD_LAST
diff --git a/include/net/xfrm.h b/include/net/xfrm.h
index eb5018b1cf9c..debcc5198e33 100644
--- a/include/net/xfrm.h
+++ b/include/net/xfrm.h
@@ -306,7 +306,8 @@ struct xfrm_replay {
 };
 
 struct xfrm_if_cb {
-        struct xfrm_if  *(*decode_session)(struct sk_buff *skb);
+        struct xfrm_if  *(*decode_session)(struct sk_buff *skb,
+                                           unsigned short family);
 };
 
 void xfrm_if_register_cb(const struct xfrm_if_cb *ifcb);
@@ -1335,6 +1336,23 @@ static inline int xfrm_state_kern(const struct xfrm_state *x)
         return atomic_read(&x->tunnel_users);
 }
 
+static inline bool xfrm_id_proto_valid(u8 proto)
+{
+        switch (proto) {
+        case IPPROTO_AH:
+        case IPPROTO_ESP:
+        case IPPROTO_COMP:
+#if IS_ENABLED(CONFIG_IPV6)
+        case IPPROTO_ROUTING:
+        case IPPROTO_DSTOPTS:
+#endif
+                return true;
+        default:
+                return false;
+        }
+}
+
+/* IPSEC_PROTO_ANY only matches 3 IPsec protocols, 0 could match all. */
 static inline int xfrm_id_proto_match(u8 proto, u8 userproto)
 {
         return (!userproto || proto == userproto ||
diff --git a/include/uapi/rdma/mlx5-abi.h b/include/uapi/rdma/mlx5-abi.h
index 87b3198f4b5d..f4d4010b7e3e 100644
--- a/include/uapi/rdma/mlx5-abi.h
+++ b/include/uapi/rdma/mlx5-abi.h
@@ -238,6 +238,7 @@ enum mlx5_ib_query_dev_resp_flags {
         MLX5_IB_QUERY_DEV_RESP_FLAGS_CQE_128B_COMP = 1 << 0,
         MLX5_IB_QUERY_DEV_RESP_FLAGS_CQE_128B_PAD  = 1 << 1,
         MLX5_IB_QUERY_DEV_RESP_PACKET_BASED_CREDIT_MODE = 1 << 2,
+        MLX5_IB_QUERY_DEV_RESP_FLAGS_SCAT2CQE_DCT = 1 << 3,
 };
 
 enum mlx5_ib_tunnel_offloads {
diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index 271717246af3..7b05e8938d5c 100644
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -4349,15 +4349,35 @@ static int check_alu_op(struct bpf_verifier_env *env, struct bpf_insn *insn)
         return 0;
 }
 
+static void __find_good_pkt_pointers(struct bpf_func_state *state,
+                                     struct bpf_reg_state *dst_reg,
+                                     enum bpf_reg_type type, u16 new_range)
+{
+        struct bpf_reg_state *reg;
+        int i;
+
+        for (i = 0; i < MAX_BPF_REG; i++) {
+                reg = &state->regs[i];
+                if (reg->type == type && reg->id == dst_reg->id)
+                        /* keep the maximum range already checked */
+                        reg->range = max(reg->range, new_range);
+        }
+
+        bpf_for_each_spilled_reg(i, state, reg) {
+                if (!reg)
+                        continue;
+                if (reg->type == type && reg->id == dst_reg->id)
+                        reg->range = max(reg->range, new_range);
+        }
+}
+
 static void find_good_pkt_pointers(struct bpf_verifier_state *vstate,
                                    struct bpf_reg_state *dst_reg,
                                    enum bpf_reg_type type,
                                    bool range_right_open)
 {
-        struct bpf_func_state *state = vstate->frame[vstate->curframe];
-        struct bpf_reg_state *regs = state->regs, *reg;
         u16 new_range;
-        int i, j;
+        int i;
 
         if (dst_reg->off < 0 ||
             (dst_reg->off == 0 && range_right_open))
@@ -4422,20 +4442,9 @@ static void find_good_pkt_pointers(struct bpf_verifier_state *vstate,
          * the range won't allow anything.
          * dst_reg->off is known < MAX_PACKET_OFF, therefore it fits in a u16.
          */
-        for (i = 0; i < MAX_BPF_REG; i++)
-                if (regs[i].type == type && regs[i].id == dst_reg->id)
-                        /* keep the maximum range already checked */
-                        regs[i].range = max(regs[i].range, new_range);
-
-        for (j = 0; j <= vstate->curframe; j++) {
-                state = vstate->frame[j];
-                bpf_for_each_spilled_reg(i, state, reg) {
-                        if (!reg)
-                                continue;
-                        if (reg->type == type && reg->id == dst_reg->id)
-                                reg->range = max(reg->range, new_range);
-                }
-        }
+        for (i = 0; i <= vstate->curframe; i++)
+                __find_good_pkt_pointers(vstate->frame[i], dst_reg, type,
+                                         new_range);
 }
 
 /* compute branch direction of the expression "if (reg opcode val) goto target;"
@@ -4909,6 +4918,22 @@ static void mark_ptr_or_null_reg(struct bpf_func_state *state,
         }
 }
 
+static void __mark_ptr_or_null_regs(struct bpf_func_state *state, u32 id,
+                                    bool is_null)
+{
+        struct bpf_reg_state *reg;
+        int i;
+
+        for (i = 0; i < MAX_BPF_REG; i++)
+                mark_ptr_or_null_reg(state, &state->regs[i], id, is_null);
+
+        bpf_for_each_spilled_reg(i, state, reg) {
+                if (!reg)
+                        continue;
+                mark_ptr_or_null_reg(state, reg, id, is_null);
+        }
+}
+
 /* The logic is similar to find_good_pkt_pointers(), both could eventually
  * be folded together at some point.
  */
@@ -4916,10 +4941,10 @@ static void mark_ptr_or_null_regs(struct bpf_verifier_state *vstate, u32 regno,
                                   bool is_null)
 {
         struct bpf_func_state *state = vstate->frame[vstate->curframe];
-        struct bpf_reg_state *reg, *regs = state->regs;
+        struct bpf_reg_state *regs = state->regs;
         u32 ref_obj_id = regs[regno].ref_obj_id;
         u32 id = regs[regno].id;
-        int i, j;
+        int i;
 
         if (ref_obj_id && ref_obj_id == id && is_null)
                 /* regs[regno] is in the " == NULL" branch.
@@ -4928,17 +4953,8 @@ static void mark_ptr_or_null_regs(struct bpf_verifier_state *vstate, u32 regno,
                  */
                 WARN_ON_ONCE(release_reference_state(state, id));
 
-        for (i = 0; i < MAX_BPF_REG; i++)
-                mark_ptr_or_null_reg(state, &regs[i], id, is_null);
-
-        for (j = 0; j <= vstate->curframe; j++) {
-                state = vstate->frame[j];
-                bpf_for_each_spilled_reg(i, state, reg) {
-                        if (!reg)
-                                continue;
-                        mark_ptr_or_null_reg(state, reg, id, is_null);
-                }
-        }
+        for (i = 0; i <= vstate->curframe; i++)
+                __mark_ptr_or_null_regs(vstate->frame[i], id, is_null);
 }
 
 static bool try_match_pkt_pointers(const struct bpf_insn *insn,
diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
index a4d9e14bf138..35f3ea375084 100644
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -2007,6 +2007,10 @@ static u64 numa_get_avg_runtime(struct task_struct *p, u64 *period)
         if (p->last_task_numa_placement) {
                 delta = runtime - p->last_sum_exec_runtime;
                 *period = now - p->last_task_numa_placement;
+
+                /* Avoid time going backwards, prevent potential divide error: */
+                if (unlikely((s64)*period < 0))
+                        *period = 0;
         } else {
                 delta = p->se.avg.load_sum;
                 *period = LOAD_AVG_MAX;
diff --git a/kernel/seccomp.c b/kernel/seccomp.c
index df27e499956a..3582eeb59893 100644
--- a/kernel/seccomp.c
+++ b/kernel/seccomp.c
@@ -502,7 +502,10 @@ out:
  *
  * Caller must be holding current->sighand->siglock lock.
  *
- * Returns 0 on success, -ve on error.
+ * Returns 0 on success, -ve on error, or
+ *   - in TSYNC mode: the pid of a thread which was either not in the correct
+ *     seccomp mode or did not have an ancestral seccomp filter
+ *   - in NEW_LISTENER mode: the fd of the new listener
  */
 static long seccomp_attach_filter(unsigned int flags,
                                   struct seccomp_filter *filter)
@@ -1258,6 +1261,16 @@ static long seccomp_set_mode_filter(unsigned int flags,
         if (flags & ~SECCOMP_FILTER_FLAG_MASK)
                 return -EINVAL;
 
+        /*
+         * In the successful case, NEW_LISTENER returns the new listener fd.
+         * But in the failure case, TSYNC returns the thread that died. If you
+         * combine these two flags, there's no way to tell whether something
+         * succeeded or failed. So, let's disallow this combination.
+         */
+        if ((flags & SECCOMP_FILTER_FLAG_TSYNC) &&
+            (flags & SECCOMP_FILTER_FLAG_NEW_LISTENER))
+                return -EINVAL;
+
         /* Prepare the new filter before holding any locks. */
         prepared = seccomp_prepare_user_filter(filter);
         if (IS_ERR(prepared))
@@ -1304,7 +1317,7 @@ out:
                 mutex_unlock(&current->signal->cred_guard_mutex);
 out_put_fd:
         if (flags & SECCOMP_FILTER_FLAG_NEW_LISTENER) {
-                if (ret < 0) {
+                if (ret) {
                         listener_f->private_data = NULL;
                         fput(listener_f);
                         put_unused_fd(listener);
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 41b6f96e5366..4ee8d8aa3d0f 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -762,7 +762,7 @@ u64 ring_buffer_time_stamp(struct ring_buffer *buffer, int cpu)
 
         preempt_disable_notrace();
         time = rb_time_stamp(buffer);
-        preempt_enable_no_resched_notrace();
+        preempt_enable_notrace();
 
         return time;
 }
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 6c24755655c7..ca1ee656d6d8 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -496,8 +496,10 @@ int trace_pid_write(struct trace_pid_list *filtered_pids,
          * not modified.
          */
         pid_list = kmalloc(sizeof(*pid_list), GFP_KERNEL);
-        if (!pid_list)
+        if (!pid_list) {
+                trace_parser_put(&parser);
                 return -ENOMEM;
+        }
 
         pid_list->pid_max = READ_ONCE(pid_max);
 
@@ -507,6 +509,7 @@ int trace_pid_write(struct trace_pid_list *filtered_pids,
 
         pid_list->pids = vzalloc((pid_list->pid_max + 7) >> 3);
         if (!pid_list->pids) {
+                trace_parser_put(&parser);
                 kfree(pid_list);
                 return -ENOMEM;
         }
@@ -7025,19 +7028,23 @@ struct buffer_ref {
         struct ring_buffer      *buffer;
         void                    *page;
         int                     cpu;
-        int                     ref;
+        refcount_t              refcount;
 };
 
+static void buffer_ref_release(struct buffer_ref *ref)
+{
+        if (!refcount_dec_and_test(&ref->refcount))
+                return;
+        ring_buffer_free_read_page(ref->buffer, ref->cpu, ref->page);
+        kfree(ref);
+}
+
 static void buffer_pipe_buf_release(struct pipe_inode_info *pipe,
                                     struct pipe_buffer *buf)
 {
         struct buffer_ref *ref = (struct buffer_ref *)buf->private;
 
-        if (--ref->ref)
-                return;
-
-        ring_buffer_free_read_page(ref->buffer, ref->cpu, ref->page);
-        kfree(ref);
+        buffer_ref_release(ref);
         buf->private = 0;
 }
 
@@ -7046,10 +7053,10 @@ static bool buffer_pipe_buf_get(struct pipe_inode_info *pipe,
 {
         struct buffer_ref *ref = (struct buffer_ref *)buf->private;
 
-        if (ref->ref > INT_MAX/2)
+        if (refcount_read(&ref->refcount) > INT_MAX/2)
                 return false;
 
-        ref->ref++;
+        refcount_inc(&ref->refcount);
         return true;
 }
 
@@ -7057,7 +7064,7 @@ static bool buffer_pipe_buf_get(struct pipe_inode_info *pipe,
 static const struct pipe_buf_operations buffer_pipe_buf_ops = {
         .confirm                = generic_pipe_buf_confirm,
         .release                = buffer_pipe_buf_release,
-        .steal                  = generic_pipe_buf_steal,
+        .steal                  = generic_pipe_buf_nosteal,
         .get                    = buffer_pipe_buf_get,
 };
 
@@ -7070,11 +7077,7 @@ static void buffer_spd_release(struct splice_pipe_desc *spd, unsigned int i)
         struct buffer_ref *ref =
                 (struct buffer_ref *)spd->partial[i].private;
 
-        if (--ref->ref)
-                return;
-
-        ring_buffer_free_read_page(ref->buffer, ref->cpu, ref->page);
-        kfree(ref);
+        buffer_ref_release(ref);
         spd->partial[i].private = 0;
 }
 
@@ -7129,7 +7132,7 @@ tracing_buffers_splice_read(struct file *file, loff_t *ppos,
                         break;
                 }
 
-                ref->ref = 1;
+                refcount_set(&ref->refcount, 1);
                 ref->buffer = iter->trace_buffer->buffer;
                 ref->page = ring_buffer_alloc_read_page(ref->buffer, iter->cpu_file);
                 if (IS_ERR(ref->page)) {
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 7117ac61174e..8ed7d276fe7d 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -1937,6 +1937,7 @@ config TEST_KMOD
         depends on m
         depends on BLOCK && (64BIT || LBDAF)      # for XFS, BTRFS
         depends on NETDEVICES && NET_CORE && INET # for TUN
+        depends on BLOCK
         select TEST_LKM
         select XFS_FS
         select TUN
diff --git a/lib/test_vmalloc.c b/lib/test_vmalloc.c
index 83cdcaa82bf6..f832b095afba 100644
--- a/lib/test_vmalloc.c
+++ b/lib/test_vmalloc.c
@@ -383,14 +383,14 @@ static void shuffle_array(int *arr, int n)
 static int test_func(void *private)
 {
         struct test_driver *t = private;
-        cpumask_t newmask = CPU_MASK_NONE;
         int random_array[ARRAY_SIZE(test_case_array)];
         int index, i, j, ret;
         ktime_t kt;
         u64 delta;
 
-        cpumask_set_cpu(t->cpu, &newmask);
-        set_cpus_allowed_ptr(current, &newmask);
+        ret = set_cpus_allowed_ptr(current, cpumask_of(t->cpu));
+        if (ret < 0)
+                pr_err("Failed to set affinity to %d CPU\n", t->cpu);
 
         for (i = 0; i < ARRAY_SIZE(test_case_array); i++)
                 random_array[i] = i;
diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
index 0082d699be94..b236069ff0d8 100644
--- a/mm/memory_hotplug.c
+++ b/mm/memory_hotplug.c
@@ -874,6 +874,7 @@ int __ref online_pages(unsigned long pfn, unsigned long nr_pages, int online_typ
          */
         mem = find_memory_block(__pfn_to_section(pfn));
         nid = mem->nid;
+        put_device(&mem->dev);
 
         /* associate pfn range with the zone */
         zone = move_pfn_range(online_type, nid, pfn, nr_pages);
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index c6ce20aaf80b..c02cff1ed56e 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -266,7 +266,20 @@ compound_page_dtor * const compound_page_dtors[] = {
 
 int min_free_kbytes = 1024;
 int user_min_free_kbytes = -1;
+#ifdef CONFIG_DISCONTIGMEM
+/*
+ * DiscontigMem defines memory ranges as separate pg_data_t even if the ranges
+ * are not on separate NUMA nodes. Functionally this works but with
+ * watermark_boost_factor, it can reclaim prematurely as the ranges can be
+ * quite small. By default, do not boost watermarks on discontigmem as in
+ * many cases very high-order allocations like THP are likely to be
+ * unsupported and the premature reclaim offsets the advantage of long-term
+ * fragmentation avoidance.
+ */
+int watermark_boost_factor __read_mostly;
+#else
 int watermark_boost_factor __read_mostly = 15000;
+#endif
 int watermark_scale_factor = 10;
 
 static unsigned long nr_kernel_pages __initdata;
@@ -3419,8 +3432,11 @@ alloc_flags_nofragment(struct zone *zone, gfp_t gfp_mask)
                 alloc_flags |= ALLOC_KSWAPD;
 
 #ifdef CONFIG_ZONE_DMA32
+        if (!zone)
+                return alloc_flags;
+
         if (zone_idx(zone) != ZONE_NORMAL)
-                goto out;
+                return alloc_flags;
 
         /*
          * If ZONE_DMA32 exists, assume it is the one after ZONE_NORMAL and
@@ -3429,9 +3445,9 @@ alloc_flags_nofragment(struct zone *zone, gfp_t gfp_mask)
          */
         BUILD_BUG_ON(ZONE_NORMAL - ZONE_DMA32 != 1);
         if (nr_online_nodes > 1 && !populated_zone(--zone))
-                goto out;
+                return alloc_flags;
 
-out:
+        alloc_flags |= ALLOC_NOFRAGMENT;
 #endif /* CONFIG_ZONE_DMA32 */
         return alloc_flags;
 }
@@ -3773,11 +3789,6 @@ __alloc_pages_direct_compact(gfp_t gfp_mask, unsigned int order,
         memalloc_noreclaim_restore(noreclaim_flag);
         psi_memstall_leave(&pflags);
 
-        if (*compact_result <= COMPACT_INACTIVE) {
-                WARN_ON_ONCE(page);
-                return NULL;
-        }
-
         /*
          * At least in one zone compaction wasn't deferred or skipped, so let's
          * count a compaction stall
diff --git a/net/appletalk/ddp.c b/net/appletalk/ddp.c
index e2511027d19b..a2555023c654 100644
--- a/net/appletalk/ddp.c
+++ b/net/appletalk/ddp.c
@@ -1915,6 +1915,7 @@ static int __init atalk_init(void)
         ddp_dl = register_snap_client(ddp_snap_id, atalk_rcv);
         if (!ddp_dl) {
                 pr_crit("Unable to register DDP with SNAP.\n");
+                rc = -ENOMEM;
                 goto out_sock;
         }
 
diff --git a/net/ipv4/esp4.c b/net/ipv4/esp4.c
index 10e809b296ec..fb065a8937ea 100644
--- a/net/ipv4/esp4.c
+++ b/net/ipv4/esp4.c
@@ -226,7 +226,7 @@ static void esp_output_fill_trailer(u8 *tail, int tfclen, int plen, __u8 proto)
         tail[plen - 1] = proto;
 }
 
-static void esp_output_udp_encap(struct xfrm_state *x, struct sk_buff *skb, struct esp_info *esp)
+static int esp_output_udp_encap(struct xfrm_state *x, struct sk_buff *skb, struct esp_info *esp)
 {
         int encap_type;
         struct udphdr *uh;
@@ -234,6 +234,7 @@ static void esp_output_udp_encap(struct xfrm_state *x, struct sk_buff *skb, stru
         __be16 sport, dport;
         struct xfrm_encap_tmpl *encap = x->encap;
         struct ip_esp_hdr *esph = esp->esph;
+        unsigned int len;
 
         spin_lock_bh(&x->lock);
         sport = encap->encap_sport;
@@ -241,11 +242,14 @@ static void esp_output_udp_encap(struct xfrm_state *x, struct sk_buff *skb, stru
         encap_type = encap->encap_type;
         spin_unlock_bh(&x->lock);
 
+        len = skb->len + esp->tailen - skb_transport_offset(skb);
+        if (len + sizeof(struct iphdr) >= IP_MAX_MTU)
+                return -EMSGSIZE;
+
         uh = (struct udphdr *)esph;
         uh->source = sport;
         uh->dest = dport;
-        uh->len = htons(skb->len + esp->tailen
-                  - skb_transport_offset(skb));
+        uh->len = htons(len);
         uh->check = 0;
 
         switch (encap_type) {
@@ -262,6 +266,8 @@ static void esp_output_udp_encap(struct xfrm_state *x, struct sk_buff *skb, stru
 
         *skb_mac_header(skb) = IPPROTO_UDP;
         esp->esph = esph;
+
+        return 0;
 }
 
 int esp_output_head(struct xfrm_state *x, struct sk_buff *skb, struct esp_info *esp)
@@ -275,8 +281,12 @@ int esp_output_head(struct xfrm_state *x, struct sk_buff *skb, struct esp_info *
         int tailen = esp->tailen;
 
         /* this is non-NULL only with UDP Encapsulation */
-        if (x->encap)
-                esp_output_udp_encap(x, skb, esp);
+        if (x->encap) {
+                int err = esp_output_udp_encap(x, skb, esp);
+
+                if (err < 0)
+                        return err;
+        }
 
         if (!skb_cloned(skb)) {
                 if (tailen <= skb_tailroom(skb)) {
diff --git a/net/ipv4/esp4_offload.c b/net/ipv4/esp4_offload.c
index b61a8ff558f9..8edcfa66d1e5 100644
--- a/net/ipv4/esp4_offload.c
+++ b/net/ipv4/esp4_offload.c
@@ -52,13 +52,13 @@ static struct sk_buff *esp4_gro_receive(struct list_head *head,
                         goto out;
 
                 if (sp->len == XFRM_MAX_DEPTH)
-                        goto out;
+                        goto out_reset;
 
                 x = xfrm_state_lookup(dev_net(skb->dev), skb->mark,
                                       (xfrm_address_t *)&ip_hdr(skb)->daddr,
                                       spi, IPPROTO_ESP, AF_INET);
                 if (!x)
-                        goto out;
+                        goto out_reset;
 
                 sp->xvec[sp->len++] = x;
                 sp->olen++;
@@ -66,7 +66,7 @@ static struct sk_buff *esp4_gro_receive(struct list_head *head,
                 xo = xfrm_offload(skb);
                 if (!xo) {
                         xfrm_state_put(x);
-                        goto out;
+                        goto out_reset;
                 }
         }
 
@@ -82,6 +82,8 @@ static struct sk_buff *esp4_gro_receive(struct list_head *head,
         xfrm_input(skb, IPPROTO_ESP, spi, -2);
 
         return ERR_PTR(-EINPROGRESS);
+out_reset:
+        secpath_reset(skb);
 out:
         skb_push(skb, offset);
         NAPI_GRO_CB(skb)->same_flow = 0;
diff --git a/net/ipv4/ip_output.c b/net/ipv4/ip_output.c
index 4e42c1974ba2..ac880beda8a7 100644
--- a/net/ipv4/ip_output.c
+++ b/net/ipv4/ip_output.c
@@ -516,6 +516,7 @@ static void ip_copy_metadata(struct sk_buff *to, struct sk_buff *from)
         to->pkt_type = from->pkt_type;
         to->priority = from->priority;
         to->protocol = from->protocol;
+        to->skb_iif = from->skb_iif;
         skb_dst_drop(to);
         skb_dst_copy(to, from);
         to->dev = from->dev;
diff --git a/net/ipv4/ip_vti.c b/net/ipv4/ip_vti.c
index cc5d9c0a8a10..254a42e83ff9 100644
--- a/net/ipv4/ip_vti.c
+++ b/net/ipv4/ip_vti.c
@@ -630,10 +630,8 @@ static int __init vti_init(void)
 
         msg = "ipip tunnel";
         err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
-        if (err < 0) {
-                pr_info("%s: cant't register tunnel\n",__func__);
+        if (err < 0)
                 goto xfrm_tunnel_failed;
-        }
 
         msg = "netlink interface";
         err = rtnl_link_register(&vti_link_ops);
@@ -643,9 +641,9 @@ static int __init vti_init(void)
         return err;
 
 rtnl_link_failed:
-        xfrm4_protocol_deregister(&vti_ipcomp4_protocol, IPPROTO_COMP);
-xfrm_tunnel_failed:
         xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
+xfrm_tunnel_failed:
+        xfrm4_protocol_deregister(&vti_ipcomp4_protocol, IPPROTO_COMP);
 xfrm_proto_comp_failed:
         xfrm4_protocol_deregister(&vti_ah4_protocol, IPPROTO_AH);
 xfrm_proto_ah_failed:
@@ -660,6 +658,7 @@ pernet_dev_failed:
 static void __exit vti_fini(void)
 {
         rtnl_link_unregister(&vti_link_ops);
+        xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
         xfrm4_protocol_deregister(&vti_ipcomp4_protocol, IPPROTO_COMP);
         xfrm4_protocol_deregister(&vti_ah4_protocol, IPPROTO_AH);
         xfrm4_protocol_deregister(&vti_esp4_protocol, IPPROTO_ESP);
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index faa6fa619f59..af81e4a6a8d8 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -1673,7 +1673,9 @@ bool tcp_add_backlog(struct sock *sk, struct sk_buff *skb)
         if (TCP_SKB_CB(tail)->end_seq != TCP_SKB_CB(skb)->seq ||
             TCP_SKB_CB(tail)->ip_dsfield != TCP_SKB_CB(skb)->ip_dsfield ||
             ((TCP_SKB_CB(tail)->tcp_flags |
-              TCP_SKB_CB(skb)->tcp_flags) & TCPHDR_URG) ||
+              TCP_SKB_CB(skb)->tcp_flags) & (TCPHDR_SYN | TCPHDR_RST | TCPHDR_URG)) ||
+            !((TCP_SKB_CB(tail)->tcp_flags &
+              TCP_SKB_CB(skb)->tcp_flags) & TCPHDR_ACK) ||
             ((TCP_SKB_CB(tail)->tcp_flags ^
               TCP_SKB_CB(skb)->tcp_flags) & (TCPHDR_ECE | TCPHDR_CWR)) ||
 #ifdef CONFIG_TLS_DEVICE
@@ -1692,6 +1694,15 @@ bool tcp_add_backlog(struct sock *sk, struct sk_buff *skb)
                 if (after(TCP_SKB_CB(skb)->ack_seq, TCP_SKB_CB(tail)->ack_seq))
                         TCP_SKB_CB(tail)->ack_seq = TCP_SKB_CB(skb)->ack_seq;
 
+                /* We have to update both TCP_SKB_CB(tail)->tcp_flags and
+                 * thtail->fin, so that the fast path in tcp_rcv_established()
+                 * is not entered if we append a packet with a FIN.
+                 * SYN, RST, URG are not present.
+                 * ACK is set on both packets.
+                 * PSH : we do not really care in TCP stack,
+                 *       at least for 'GRO' packets.
+                 */
+                thtail->fin |= th->fin;
                 TCP_SKB_CB(tail)->tcp_flags |= TCP_SKB_CB(skb)->tcp_flags;
 
                 if (TCP_SKB_CB(skb)->has_rxtstamp) {
diff --git a/net/ipv4/udp_offload.c b/net/ipv4/udp_offload.c
index 64f9715173ac..065334b41d57 100644
--- a/net/ipv4/udp_offload.c
+++ b/net/ipv4/udp_offload.c
@@ -352,6 +352,7 @@ static struct sk_buff *udp_gro_receive_segment(struct list_head *head,
         struct sk_buff *pp = NULL;
         struct udphdr *uh2;
         struct sk_buff *p;
+        unsigned int ulen;
 
         /* requires non zero csum, for symmetry with GSO */
         if (!uh->check) {
@@ -359,6 +360,12 @@ static struct sk_buff *udp_gro_receive_segment(struct list_head *head,
                 return NULL;
         }
 
+        /* Do not deal with padded or malicious packets, sorry ! */
+        ulen = ntohs(uh->len);
+        if (ulen <= sizeof(*uh) || ulen != skb_gro_len(skb)) {
+                NAPI_GRO_CB(skb)->flush = 1;
+                return NULL;
+        }
         /* pull encapsulating udp header */
         skb_gro_pull(skb, sizeof(struct udphdr));
         skb_gro_postpull_rcsum(skb, uh, sizeof(struct udphdr));
@@ -377,13 +384,14 @@ static struct sk_buff *udp_gro_receive_segment(struct list_head *head,
 
                 /* Terminate the flow on len mismatch or if it grow "too much".
                  * Under small packet flood GRO count could elsewhere grow a lot
-                 * leading to execessive truesize values
+                 * leading to excessive truesize values.
+                 * On len mismatch merge the first packet shorter than gso_size,
+                 * otherwise complete the GRO packet.
                  */
-                if (!skb_gro_receive(p, skb) &&
+                if (ulen > ntohs(uh2->len) || skb_gro_receive(p, skb) ||
+                    ulen != ntohs(uh2->len) ||
                     NAPI_GRO_CB(p)->count >= UDP_GRO_CNT_MAX)
                         pp = p;
-                else if (uh->len != uh2->len)
-                        pp = p;
 
                 return pp;
         }
diff --git a/net/ipv6/esp6_offload.c b/net/ipv6/esp6_offload.c
index bff83279d76f..d453cf417b03 100644
--- a/net/ipv6/esp6_offload.c
+++ b/net/ipv6/esp6_offload.c
@@ -74,13 +74,13 @@ static struct sk_buff *esp6_gro_receive(struct list_head *head,
                         goto out;
 
                 if (sp->len == XFRM_MAX_DEPTH)
-                        goto out;
+                        goto out_reset;
 
                 x = xfrm_state_lookup(dev_net(skb->dev), skb->mark,
                                       (xfrm_address_t *)&ipv6_hdr(skb)->daddr,
                                       spi, IPPROTO_ESP, AF_INET6);
                 if (!x)
-                        goto out;
+                        goto out_reset;
 
                 sp->xvec[sp->len++] = x;
                 sp->olen++;
@@ -88,7 +88,7 @@ static struct sk_buff *esp6_gro_receive(struct list_head *head,
                 xo = xfrm_offload(skb);
                 if (!xo) {
                         xfrm_state_put(x);
-                        goto out;
+                        goto out_reset;
                 }
         }
 
@@ -109,6 +109,8 @@ static struct sk_buff *esp6_gro_receive(struct list_head *head,
         xfrm_input(skb, IPPROTO_ESP, spi, -2);
 
         return ERR_PTR(-EINPROGRESS);
+out_reset:
+        secpath_reset(skb);
 out:
         skb_push(skb, offset);
         NAPI_GRO_CB(skb)->same_flow = 0;
diff --git a/net/ipv6/ip6_fib.c b/net/ipv6/ip6_fib.c
index a8919c217cc2..08e0390e001c 100644
--- a/net/ipv6/ip6_fib.c
+++ b/net/ipv6/ip6_fib.c
@@ -916,9 +916,7 @@ static void fib6_drop_pcpu_from(struct fib6_info *f6i,
                 if (pcpu_rt) {
                         struct fib6_info *from;
 
-                        from = rcu_dereference_protected(pcpu_rt->from,
-                                             lockdep_is_held(&table->tb6_lock));
-                        rcu_assign_pointer(pcpu_rt->from, NULL);
+                        from = xchg((__force struct fib6_info **)&pcpu_rt->from, NULL);
                         fib6_info_release(from);
                 }
         }
diff --git a/net/ipv6/ip6_flowlabel.c b/net/ipv6/ip6_flowlabel.c
index cb54a8a3c273..be5f3d7ceb96 100644
--- a/net/ipv6/ip6_flowlabel.c
+++ b/net/ipv6/ip6_flowlabel.c
@@ -94,15 +94,21 @@ static struct ip6_flowlabel *fl_lookup(struct net *net, __be32 label)
         return fl;
 }
 
+static void fl_free_rcu(struct rcu_head *head)
+{
+        struct ip6_flowlabel *fl = container_of(head, struct ip6_flowlabel, rcu);
+
+        if (fl->share == IPV6_FL_S_PROCESS)
+                put_pid(fl->owner.pid);
+        kfree(fl->opt);
+        kfree(fl);
+}
+
 
 static void fl_free(struct ip6_flowlabel *fl)
 {
-        if (fl) {
-                if (fl->share == IPV6_FL_S_PROCESS)
-                        put_pid(fl->owner.pid);
-                kfree(fl->opt);
-                kfree_rcu(fl, rcu);
-        }
+        if (fl)
+                call_rcu(&fl->rcu, fl_free_rcu);
 }
 
 static void fl_release(struct ip6_flowlabel *fl)
@@ -633,9 +639,9 @@ recheck:
                                 if (fl1->share == IPV6_FL_S_EXCL ||
                                     fl1->share != fl->share ||
                                     ((fl1->share == IPV6_FL_S_PROCESS) &&
-                                     (fl1->owner.pid == fl->owner.pid)) ||
+                                     (fl1->owner.pid != fl->owner.pid)) ||
                                     ((fl1->share == IPV6_FL_S_USER) &&
-                                     uid_eq(fl1->owner.uid, fl->owner.uid)))
+                                     !uid_eq(fl1->owner.uid, fl->owner.uid)))
                                         goto release;
 
                                 err = -ENOMEM;
diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index b18e85cd7587..23a20d62daac 100644
--- a/net/ipv6/route.c
+++ b/net/ipv6/route.c
@@ -380,11 +380,8 @@ static void ip6_dst_destroy(struct dst_entry *dst)
                 in6_dev_put(idev);
         }
 
-        rcu_read_lock();
-        from = rcu_dereference(rt->from);
-        rcu_assign_pointer(rt->from, NULL);
+        from = xchg((__force struct fib6_info **)&rt->from, NULL);
         fib6_info_release(from);
-        rcu_read_unlock();
 }
 
 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
@@ -1323,9 +1320,7 @@ static void rt6_remove_exception(struct rt6_exception_bucket *bucket,
         /* purge completely the exception to allow releasing the held resources:
          * some [sk] cache may keep the dst around for unlimited time
          */
-        from = rcu_dereference_protected(rt6_ex->rt6i->from,
-                                         lockdep_is_held(&rt6_exception_lock));
-        rcu_assign_pointer(rt6_ex->rt6i->from, NULL);
+        from = xchg((__force struct fib6_info **)&rt6_ex->rt6i->from, NULL);
         fib6_info_release(from);
         dst_dev_put(&rt6_ex->rt6i->dst);
 
@@ -3495,11 +3490,8 @@ static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_bu
 
         rcu_read_lock();
         res.f6i = rcu_dereference(rt->from);
-        /* This fib6_info_hold() is safe here because we hold reference to rt
-         * and rt already holds reference to fib6_info.
-         */
-        fib6_info_hold(res.f6i);
-        rcu_read_unlock();
+        if (!res.f6i)
+                goto out;
 
         res.nh = &res.f6i->fib6_nh;
         res.fib6_flags = res.f6i->fib6_flags;
@@ -3514,10 +3506,7 @@ static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_bu
 
         nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
 
-        /* No need to remove rt from the exception table if rt is
-         * a cached route because rt6_insert_exception() will
-         * takes care of it
-         */
+        /* rt6_insert_exception() will take care of duplicated exceptions */
         if (rt6_insert_exception(nrt, &res)) {
                 dst_release_immediate(&nrt->dst);
                 goto out;
@@ -3530,7 +3519,7 @@ static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_bu
         call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
 
 out:
-        fib6_info_release(res.f6i);
+        rcu_read_unlock();
         neigh_release(neigh);
 }
 
@@ -3772,23 +3761,34 @@ int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
 
 static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
 {
-        int type;
         struct dst_entry *dst = skb_dst(skb);
+        struct net *net = dev_net(dst->dev);
+        struct inet6_dev *idev;
+        int type;
+
+        if (netif_is_l3_master(skb->dev) &&
+            dst->dev == net->loopback_dev)
+                idev = __in6_dev_get_safely(dev_get_by_index_rcu(net, IP6CB(skb)->iif));
+        else
+                idev = ip6_dst_idev(dst);
+
         switch (ipstats_mib_noroutes) {
         case IPSTATS_MIB_INNOROUTES:
                 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
                 if (type == IPV6_ADDR_ANY) {
-                        IP6_INC_STATS(dev_net(dst->dev),
-                                      __in6_dev_get_safely(skb->dev),
-                                      IPSTATS_MIB_INADDRERRORS);
+                        IP6_INC_STATS(net, idev, IPSTATS_MIB_INADDRERRORS);
                         break;
                 }
                 /* FALLTHROUGH */
         case IPSTATS_MIB_OUTNOROUTES:
-                IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
-                              ipstats_mib_noroutes);
+                IP6_INC_STATS(net, idev, ipstats_mib_noroutes);
                 break;
         }
+
+        /* Start over by dropping the dst for l3mdev case */
+        if (netif_is_l3_master(skb->dev))
+                skb_dst_drop(skb);
+
         icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
         kfree_skb(skb);
         return 0;
@@ -5056,16 +5056,20 @@ static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh,
 
         rcu_read_lock();
         from = rcu_dereference(rt->from);
-
-        if (fibmatch)
-                err = rt6_fill_node(net, skb, from, NULL, NULL, NULL, iif,
-                                    RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
-                                    nlh->nlmsg_seq, 0);
-        else
-                err = rt6_fill_node(net, skb, from, dst, &fl6.daddr,
-                                    &fl6.saddr, iif, RTM_NEWROUTE,
-                                    NETLINK_CB(in_skb).portid, nlh->nlmsg_seq,
-                                    0);
+        if (from) {
+                if (fibmatch)
+                        err = rt6_fill_node(net, skb, from, NULL, NULL, NULL,
+                                            iif, RTM_NEWROUTE,
+                                            NETLINK_CB(in_skb).portid,
+                                            nlh->nlmsg_seq, 0);
+                else
+                        err = rt6_fill_node(net, skb, from, dst, &fl6.daddr,
+                                            &fl6.saddr, iif, RTM_NEWROUTE,
+                                            NETLINK_CB(in_skb).portid,
+                                            nlh->nlmsg_seq, 0);
+        } else {
+                err = -ENETUNREACH;
+        }
         rcu_read_unlock();
 
         if (err < 0) {
diff --git a/net/ipv6/xfrm6_tunnel.c b/net/ipv6/xfrm6_tunnel.c
index bc65db782bfb..d9e5f6808811 100644
--- a/net/ipv6/xfrm6_tunnel.c
+++ b/net/ipv6/xfrm6_tunnel.c
@@ -345,7 +345,7 @@ static void __net_exit xfrm6_tunnel_net_exit(struct net *net)
         unsigned int i;
 
         xfrm_flush_gc();
-        xfrm_state_flush(net, IPSEC_PROTO_ANY, false, true);
+        xfrm_state_flush(net, 0, false, true);
 
         for (i = 0; i < XFRM6_TUNNEL_SPI_BYADDR_HSIZE; i++)
                 WARN_ON_ONCE(!hlist_empty(&xfrm6_tn->spi_byaddr[i]));
@@ -402,6 +402,10 @@ static void __exit xfrm6_tunnel_fini(void)
         xfrm6_tunnel_deregister(&xfrm6_tunnel_handler, AF_INET6);
         xfrm_unregister_type(&xfrm6_tunnel_type, AF_INET6);
         unregister_pernet_subsys(&xfrm6_tunnel_net_ops);
+        /* Someone maybe has gotten the xfrm6_tunnel_spi.
+         * So need to wait it.
+         */
+        rcu_barrier();
         kmem_cache_destroy(xfrm6_tunnel_spi_kmem);
 }
 
diff --git a/net/key/af_key.c b/net/key/af_key.c
index 5651c29cb5bd..4af1e1d60b9f 100644
--- a/net/key/af_key.c
+++ b/net/key/af_key.c
@@ -1951,8 +1951,10 @@ parse_ipsecrequest(struct xfrm_policy *xp, struct sadb_x_ipsecrequest *rq)
 
         if (rq->sadb_x_ipsecrequest_mode == 0)
                 return -EINVAL;
+        if (!xfrm_id_proto_valid(rq->sadb_x_ipsecrequest_proto))
+                return -EINVAL;
 
-        t->id.proto = rq->sadb_x_ipsecrequest_proto; /* XXX check proto */
+        t->id.proto = rq->sadb_x_ipsecrequest_proto;
         if ((mode = pfkey_mode_to_xfrm(rq->sadb_x_ipsecrequest_mode)) < 0)
                 return -EINVAL;
         t->mode = mode;
diff --git a/net/l2tp/l2tp_core.c b/net/l2tp/l2tp_core.c
index fed6becc5daf..52b5a2797c0c 100644
--- a/net/l2tp/l2tp_core.c
+++ b/net/l2tp/l2tp_core.c
@@ -169,8 +169,8 @@ struct l2tp_tunnel *l2tp_tunnel_get(const struct net *net, u32 tunnel_id)
 
         rcu_read_lock_bh();
         list_for_each_entry_rcu(tunnel, &pn->l2tp_tunnel_list, list) {
-                if (tunnel->tunnel_id == tunnel_id) {
-                        l2tp_tunnel_inc_refcount(tunnel);
+                if (tunnel->tunnel_id == tunnel_id &&
+                    refcount_inc_not_zero(&tunnel->ref_count)) {
                         rcu_read_unlock_bh();
 
                         return tunnel;
@@ -190,8 +190,8 @@ struct l2tp_tunnel *l2tp_tunnel_get_nth(const struct net *net, int nth)
 
         rcu_read_lock_bh();
         list_for_each_entry_rcu(tunnel, &pn->l2tp_tunnel_list, list) {
-                if (++count > nth) {
-                        l2tp_tunnel_inc_refcount(tunnel);
+                if (++count > nth &&
+                    refcount_inc_not_zero(&tunnel->ref_count)) {
                         rcu_read_unlock_bh();
                         return tunnel;
                 }
@@ -909,7 +909,7 @@ int l2tp_udp_encap_recv(struct sock *sk, struct sk_buff *skb)
 {
         struct l2tp_tunnel *tunnel;
 
-        tunnel = l2tp_tunnel(sk);
+        tunnel = rcu_dereference_sk_user_data(sk);
         if (tunnel == NULL)
                 goto pass_up;
 
diff --git a/net/mac80211/debugfs_netdev.c b/net/mac80211/debugfs_netdev.c
index cff0fb3578c9..deb3faf08337 100644
--- a/net/mac80211/debugfs_netdev.c
+++ b/net/mac80211/debugfs_netdev.c
@@ -841,7 +841,7 @@ void ieee80211_debugfs_rename_netdev(struct ieee80211_sub_if_data *sdata)
 
         dir = sdata->vif.debugfs_dir;
 
-        if (!dir)
+        if (IS_ERR_OR_NULL(dir))
                 return;
 
         sprintf(buf, "netdev:%s", sdata->name);
diff --git a/net/mac80211/ht.c b/net/mac80211/ht.c
index e03c46ac8e4d..c62101857b9b 100644
--- a/net/mac80211/ht.c
+++ b/net/mac80211/ht.c
@@ -112,8 +112,9 @@ void ieee80211_apply_htcap_overrides(struct ieee80211_sub_if_data *sdata,
                              IEEE80211_HT_CAP_TX_STBC);
 
         /* Allow user to configure RX STBC bits */
-        if (ht_capa_mask->cap_info & IEEE80211_HT_CAP_RX_STBC)
-                ht_cap->cap |= ht_capa->cap_info & IEEE80211_HT_CAP_RX_STBC;
+        if (ht_capa_mask->cap_info & cpu_to_le16(IEEE80211_HT_CAP_RX_STBC))
+                ht_cap->cap |= le16_to_cpu(ht_capa->cap_info) &
+                                        IEEE80211_HT_CAP_RX_STBC;
 
         /* Allow user to decrease AMPDU factor */
         if (ht_capa_mask->ampdu_params_info &
diff --git a/net/mac80211/iface.c b/net/mac80211/iface.c
index 94459b2b3d2a..410685d38c46 100644
--- a/net/mac80211/iface.c
+++ b/net/mac80211/iface.c
@@ -1907,6 +1907,9 @@ void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)
         list_del_rcu(&sdata->list);
         mutex_unlock(&sdata->local->iflist_mtx);
 
+        if (sdata->vif.txq)
+                ieee80211_txq_purge(sdata->local, to_txq_info(sdata->vif.txq));
+
         synchronize_rcu();
 
         if (sdata->dev) {
diff --git a/net/netlink/genetlink.c b/net/netlink/genetlink.c
index 72668759cd2b..79cfa031dc7d 100644
--- a/net/netlink/genetlink.c
+++ b/net/netlink/genetlink.c
@@ -362,8 +362,8 @@ int genl_register_family(struct genl_family *family)
         } else
                 family->attrbuf = NULL;
 
-        family->id = idr_alloc(&genl_fam_idr, family,
-                               start, end + 1, GFP_KERNEL);
+        family->id = idr_alloc_cyclic(&genl_fam_idr, family,
+                                      start, end + 1, GFP_KERNEL);
         if (family->id < 0) {
                 err = family->id;
                 goto errout_free;
diff --git a/net/packet/af_packet.c b/net/packet/af_packet.c
index 5c4a118d6f96..90d4e3ce00e5 100644
--- a/net/packet/af_packet.c
+++ b/net/packet/af_packet.c
@@ -2600,8 +2600,8 @@ static int tpacket_snd(struct packet_sock *po, struct msghdr *msg)
         void *ph;
         DECLARE_SOCKADDR(struct sockaddr_ll *, saddr, msg->msg_name);
         bool need_wait = !(msg->msg_flags & MSG_DONTWAIT);
+        unsigned char *addr = NULL;
         int tp_len, size_max;
-        unsigned char *addr;
         void *data;
         int len_sum = 0;
         int status = TP_STATUS_AVAILABLE;
@@ -2612,7 +2612,6 @@ static int tpacket_snd(struct packet_sock *po, struct msghdr *msg)
         if (likely(saddr == NULL)) {
                 dev     = packet_cached_dev_get(po);
                 proto   = po->num;
-                addr    = NULL;
         } else {
                 err = -EINVAL;
                 if (msg->msg_namelen < sizeof(struct sockaddr_ll))
@@ -2622,10 +2621,13 @@ static int tpacket_snd(struct packet_sock *po, struct msghdr *msg)
                                                 sll_addr)))
                         goto out;
                 proto   = saddr->sll_protocol;
-                addr    = saddr->sll_halen ? saddr->sll_addr : NULL;
                 dev = dev_get_by_index(sock_net(&po->sk), saddr->sll_ifindex);
-                if (addr && dev && saddr->sll_halen < dev->addr_len)
-                        goto out_put;
+                if (po->sk.sk_socket->type == SOCK_DGRAM) {
+                        if (dev && msg->msg_namelen < dev->addr_len +
+                                   offsetof(struct sockaddr_ll, sll_addr))
+                                goto out_put;
+                        addr = saddr->sll_addr;
+                }
         }
 
         err = -ENXIO;
@@ -2797,7 +2799,7 @@ static int packet_snd(struct socket *sock, struct msghdr *msg, size_t len)
         struct sk_buff *skb;
         struct net_device *dev;
         __be16 proto;
-        unsigned char *addr;
+        unsigned char *addr = NULL;
         int err, reserve = 0;
         struct sockcm_cookie sockc;
         struct virtio_net_hdr vnet_hdr = { 0 };
@@ -2814,7 +2816,6 @@ static int packet_snd(struct socket *sock, struct msghdr *msg, size_t len)
         if (likely(saddr == NULL)) {
                 dev     = packet_cached_dev_get(po);
                 proto   = po->num;
-                addr    = NULL;
         } else {
                 err = -EINVAL;
                 if (msg->msg_namelen < sizeof(struct sockaddr_ll))
@@ -2822,10 +2823,13 @@ static int packet_snd(struct socket *sock, struct msghdr *msg, size_t len)
                 if (msg->msg_namelen < (saddr->sll_halen + offsetof(struct sockaddr_ll, sll_addr)))
                         goto out;
                 proto   = saddr->sll_protocol;
-                addr    = saddr->sll_halen ? saddr->sll_addr : NULL;
                 dev = dev_get_by_index(sock_net(sk), saddr->sll_ifindex);
-                if (addr && dev && saddr->sll_halen < dev->addr_len)
-                        goto out_unlock;
+                if (sock->type == SOCK_DGRAM) {
+                        if (dev && msg->msg_namelen < dev->addr_len +
+                                   offsetof(struct sockaddr_ll, sll_addr))
+                                goto out_unlock;
+                        addr = saddr->sll_addr;
+                }
         }
 
         err = -ENXIO;
@@ -3342,20 +3346,29 @@ static int packet_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
         sock_recv_ts_and_drops(msg, sk, skb);
 
         if (msg->msg_name) {
+                int copy_len;
+
                 /* If the address length field is there to be filled
                  * in, we fill it in now.
                  */
                 if (sock->type == SOCK_PACKET) {
                         __sockaddr_check_size(sizeof(struct sockaddr_pkt));
                         msg->msg_namelen = sizeof(struct sockaddr_pkt);
+                        copy_len = msg->msg_namelen;
                 } else {
                         struct sockaddr_ll *sll = &PACKET_SKB_CB(skb)->sa.ll;
 
                         msg->msg_namelen = sll->sll_halen +
                                 offsetof(struct sockaddr_ll, sll_addr);
+                        copy_len = msg->msg_namelen;
+                        if (msg->msg_namelen < sizeof(struct sockaddr_ll)) {
+                                memset(msg->msg_name +
+                                       offsetof(struct sockaddr_ll, sll_addr),
+                                       0, sizeof(sll->sll_addr));
+                                msg->msg_namelen = sizeof(struct sockaddr_ll);
+                        }
                 }
-                memcpy(msg->msg_name, &PACKET_SKB_CB(skb)->sa,
-                       msg->msg_namelen);
+                memcpy(msg->msg_name, &PACKET_SKB_CB(skb)->sa, copy_len);
         }
 
         if (pkt_sk(sk)->auxdata) {
diff --git a/net/rds/ib_recv.c b/net/rds/ib_recv.c
index 70559854837e..8946c89d7392 100644
--- a/net/rds/ib_recv.c
+++ b/net/rds/ib_recv.c
@@ -772,7 +772,7 @@ static void rds_ib_cong_recv(struct rds_connection *conn,
         unsigned long frag_off;
         unsigned long to_copy;
         unsigned long copied;
-        uint64_t uncongested = 0;
+        __le64 uncongested = 0;
         void *addr;
 
         /* catch completely corrupt packets */
@@ -789,7 +789,7 @@ static void rds_ib_cong_recv(struct rds_connection *conn,
         copied = 0;
 
         while (copied < RDS_CONG_MAP_BYTES) {
-                uint64_t *src, *dst;
+                __le64 *src, *dst;
                 unsigned int k;
 
                 to_copy = min(RDS_FRAG_SIZE - frag_off, PAGE_SIZE - map_off);
@@ -824,9 +824,7 @@ static void rds_ib_cong_recv(struct rds_connection *conn,
         }
 
         /* the congestion map is in little endian order */
-        uncongested = le64_to_cpu(uncongested);
-
-        rds_cong_map_updated(map, uncongested);
+        rds_cong_map_updated(map, le64_to_cpu(uncongested));
 }
 
 static void rds_ib_process_recv(struct rds_connection *conn,
diff --git a/net/rxrpc/call_object.c b/net/rxrpc/call_object.c
index 8aa2937b069f..fe96881a334d 100644
--- a/net/rxrpc/call_object.c
+++ b/net/rxrpc/call_object.c
@@ -604,30 +604,30 @@ void rxrpc_destroy_all_calls(struct rxrpc_net *rxnet)
 
         _enter("");
 
-        if (list_empty(&rxnet->calls))
-                return;
+        if (!list_empty(&rxnet->calls)) {
+                write_lock(&rxnet->call_lock);
 
-        write_lock(&rxnet->call_lock);
+                while (!list_empty(&rxnet->calls)) {
+                        call = list_entry(rxnet->calls.next,
+                                          struct rxrpc_call, link);
+                        _debug("Zapping call %p", call);
 
-        while (!list_empty(&rxnet->calls)) {
-                call = list_entry(rxnet->calls.next, struct rxrpc_call, link);
-                _debug("Zapping call %p", call);
+                        rxrpc_see_call(call);
+                        list_del_init(&call->link);
 
-                rxrpc_see_call(call);
-                list_del_init(&call->link);
+                        pr_err("Call %p still in use (%d,%s,%lx,%lx)!\n",
+                               call, atomic_read(&call->usage),
+                               rxrpc_call_states[call->state],
+                               call->flags, call->events);
 
-                pr_err("Call %p still in use (%d,%s,%lx,%lx)!\n",
-                       call, atomic_read(&call->usage),
-                       rxrpc_call_states[call->state],
-                       call->flags, call->events);
+                        write_unlock(&rxnet->call_lock);
+                        cond_resched();
+                        write_lock(&rxnet->call_lock);
+                }
 
                 write_unlock(&rxnet->call_lock);
-                cond_resched();
-                write_lock(&rxnet->call_lock);
         }
 
-        write_unlock(&rxnet->call_lock);
-
         atomic_dec(&rxnet->nr_calls);
         wait_var_event(&rxnet->nr_calls, !atomic_read(&rxnet->nr_calls));
 }
diff --git a/net/sctp/sm_sideeffect.c b/net/sctp/sm_sideeffect.c
index 1d143bc3f73d..4aa03588f87b 100644
--- a/net/sctp/sm_sideeffect.c
+++ b/net/sctp/sm_sideeffect.c
@@ -1112,32 +1112,6 @@ static void sctp_cmd_send_msg(struct sctp_association *asoc,
 }
 
 
-/* Sent the next ASCONF packet currently stored in the association.
- * This happens after the ASCONF_ACK was succeffully processed.
- */
-static void sctp_cmd_send_asconf(struct sctp_association *asoc)
-{
-        struct net *net = sock_net(asoc->base.sk);
-
-        /* Send the next asconf chunk from the addip chunk
-         * queue.
-         */
-        if (!list_empty(&asoc->addip_chunk_list)) {
-                struct list_head *entry = asoc->addip_chunk_list.next;
-                struct sctp_chunk *asconf = list_entry(entry,
-                                                struct sctp_chunk, list);
-                list_del_init(entry);
-
-                /* Hold the chunk until an ASCONF_ACK is received. */
-                sctp_chunk_hold(asconf);
-                if (sctp_primitive_ASCONF(net, asoc, asconf))
-                        sctp_chunk_free(asconf);
-                else
-                        asoc->addip_last_asconf = asconf;
-        }
-}
-
-
 /* These three macros allow us to pull the debugging code out of the
  * main flow of sctp_do_sm() to keep attention focused on the real
  * functionality there.
@@ -1783,9 +1757,6 @@ static int sctp_cmd_interpreter(enum sctp_event_type event_type,
                         }
                         sctp_cmd_send_msg(asoc, cmd->obj.msg, gfp);
                         break;
-                case SCTP_CMD_SEND_NEXT_ASCONF:
-                        sctp_cmd_send_asconf(asoc);
-                        break;
                 case SCTP_CMD_PURGE_ASCONF_QUEUE:
                         sctp_asconf_queue_teardown(asoc);
                         break;
diff --git a/net/sctp/sm_statefuns.c b/net/sctp/sm_statefuns.c
index 7dfc34b28f4f..e3f4abe6134e 100644
--- a/net/sctp/sm_statefuns.c
+++ b/net/sctp/sm_statefuns.c
@@ -3824,6 +3824,29 @@ enum sctp_disposition sctp_sf_do_asconf(struct net *net,
         return SCTP_DISPOSITION_CONSUME;
 }
 
+static enum sctp_disposition sctp_send_next_asconf(
+                                        struct net *net,
+                                        const struct sctp_endpoint *ep,
+                                        struct sctp_association *asoc,
+                                        const union sctp_subtype type,
+                                        struct sctp_cmd_seq *commands)
+{
+        struct sctp_chunk *asconf;
+        struct list_head *entry;
+
+        if (list_empty(&asoc->addip_chunk_list))
+                return SCTP_DISPOSITION_CONSUME;
+
+        entry = asoc->addip_chunk_list.next;
+        asconf = list_entry(entry, struct sctp_chunk, list);
+
+        list_del_init(entry);
+        sctp_chunk_hold(asconf);
+        asoc->addip_last_asconf = asconf;
+
+        return sctp_sf_do_prm_asconf(net, ep, asoc, type, asconf, commands);
+}
+
 /*
  * ADDIP Section 4.3 General rules for address manipulation
  * When building TLV parameters for the ASCONF Chunk that will add or
@@ -3915,14 +3938,10 @@ enum sctp_disposition sctp_sf_do_asconf_ack(struct net *net,
                                 SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
 
                 if (!sctp_process_asconf_ack((struct sctp_association *)asoc,
-                                             asconf_ack)) {
-                        /* Successfully processed ASCONF_ACK.  We can
-                         * release the next asconf if we have one.
-                         */
-                        sctp_add_cmd_sf(commands, SCTP_CMD_SEND_NEXT_ASCONF,
-                                        SCTP_NULL());
-                        return SCTP_DISPOSITION_CONSUME;
-                }
+                                             asconf_ack))
+                        return sctp_send_next_asconf(net, ep,
+                                        (struct sctp_association *)asoc,
+                                                        type, commands);
 
                 abort = sctp_make_abort(asoc, asconf_ack,
                                         sizeof(struct sctp_errhdr));
diff --git a/net/tls/tls_device.c b/net/tls/tls_device.c
index 26f26e71ef3f..e225c81e6b35 100644
--- a/net/tls/tls_device.c
+++ b/net/tls/tls_device.c
@@ -580,7 +580,7 @@ void handle_device_resync(struct sock *sk, u32 seq, u64 rcd_sn)
 static int tls_device_reencrypt(struct sock *sk, struct sk_buff *skb)
 {
         struct strp_msg *rxm = strp_msg(skb);
-        int err = 0, offset = rxm->offset, copy, nsg;
+        int err = 0, offset = rxm->offset, copy, nsg, data_len, pos;
         struct sk_buff *skb_iter, *unused;
         struct scatterlist sg[1];
         char *orig_buf, *buf;
@@ -611,25 +611,42 @@ static int tls_device_reencrypt(struct sock *sk, struct sk_buff *skb)
         else
                 err = 0;
 
-        copy = min_t(int, skb_pagelen(skb) - offset,
-                     rxm->full_len - TLS_CIPHER_AES_GCM_128_TAG_SIZE);
+        data_len = rxm->full_len - TLS_CIPHER_AES_GCM_128_TAG_SIZE;
 
-        if (skb->decrypted)
-                skb_store_bits(skb, offset, buf, copy);
+        if (skb_pagelen(skb) > offset) {
+                copy = min_t(int, skb_pagelen(skb) - offset, data_len);
 
-        offset += copy;
-        buf += copy;
+                if (skb->decrypted)
+                        skb_store_bits(skb, offset, buf, copy);
 
+                offset += copy;
+                buf += copy;
+        }
+
+        pos = skb_pagelen(skb);
         skb_walk_frags(skb, skb_iter) {
-                copy = min_t(int, skb_iter->len,
-                             rxm->full_len - offset + rxm->offset -
-                             TLS_CIPHER_AES_GCM_128_TAG_SIZE);
+                int frag_pos;
+
+                /* Practically all frags must belong to msg if reencrypt
+                 * is needed with current strparser and coalescing logic,
+                 * but strparser may "get optimized", so let's be safe.
+                 */
+                if (pos + skb_iter->len <= offset)
+                        goto done_with_frag;
+                if (pos >= data_len + rxm->offset)
+                        break;
+
+                frag_pos = offset - pos;
+                copy = min_t(int, skb_iter->len - frag_pos,
+                             data_len + rxm->offset - offset);
 
                 if (skb_iter->decrypted)
-                        skb_store_bits(skb_iter, offset, buf, copy);
+                        skb_store_bits(skb_iter, frag_pos, buf, copy);
 
                 offset += copy;
                 buf += copy;
+done_with_frag:
+                pos += skb_iter->len;
         }
 
 free_buf:
diff --git a/net/tls/tls_device_fallback.c b/net/tls/tls_device_fallback.c
index a3ebd4b02714..c3a5fe624b4e 100644
--- a/net/tls/tls_device_fallback.c
+++ b/net/tls/tls_device_fallback.c
@@ -201,13 +201,14 @@ static void complete_skb(struct sk_buff *nskb, struct sk_buff *skb, int headln)
 
         skb_put(nskb, skb->len);
         memcpy(nskb->data, skb->data, headln);
-        update_chksum(nskb, headln);
 
         nskb->destructor = skb->destructor;
         nskb->sk = sk;
         skb->destructor = NULL;
         skb->sk = NULL;
 
+        update_chksum(nskb, headln);
+
         delta = nskb->truesize - skb->truesize;
         if (likely(delta < 0))
                 WARN_ON_ONCE(refcount_sub_and_test(-delta, &sk->sk_wmem_alloc));
diff --git a/net/wireless/reg.c b/net/wireless/reg.c
index 816425ffe05a..4831ad745f91 100644
--- a/net/wireless/reg.c
+++ b/net/wireless/reg.c
@@ -3769,10 +3769,9 @@ void wiphy_regulatory_register(struct wiphy *wiphy)
                 /*
                  * The last request may have been received before this
                  * registration call. Call the driver notifier if
-                 * initiator is USER and user type is CELL_BASE.
+                 * initiator is USER.
                  */
-                if (lr->initiator == NL80211_REGDOM_SET_BY_USER &&
-                    lr->user_reg_hint_type == NL80211_USER_REG_HINT_CELL_BASE)
+                if (lr->initiator == NL80211_REGDOM_SET_BY_USER)
                         reg_call_notifier(wiphy, lr);
         }
 
diff --git a/net/xfrm/xfrm_interface.c b/net/xfrm/xfrm_interface.c
index b9f118530db6..ad3a2555c517 100644
--- a/net/xfrm/xfrm_interface.c
+++ b/net/xfrm/xfrm_interface.c
@@ -70,17 +70,28 @@ static struct xfrm_if *xfrmi_lookup(struct net *net, struct xfrm_state *x)
         return NULL;
 }
 
-static struct xfrm_if *xfrmi_decode_session(struct sk_buff *skb)
+static struct xfrm_if *xfrmi_decode_session(struct sk_buff *skb,
+                                            unsigned short family)
 {
         struct xfrmi_net *xfrmn;
-        int ifindex;
         struct xfrm_if *xi;
+        int ifindex = 0;
 
         if (!secpath_exists(skb) || !skb->dev)
                 return NULL;
 
+        switch (family) {
+        case AF_INET6:
+                ifindex = inet6_sdif(skb);
+                break;
+        case AF_INET:
+                ifindex = inet_sdif(skb);
+                break;
+        }
+        if (!ifindex)
+                ifindex = skb->dev->ifindex;
+
         xfrmn = net_generic(xs_net(xfrm_input_state(skb)), xfrmi_net_id);
-        ifindex = skb->dev->ifindex;
 
         for_each_xfrmi_rcu(xfrmn->xfrmi[0], xi) {
                 if (ifindex == xi->dev->ifindex &&
diff --git a/net/xfrm/xfrm_policy.c b/net/xfrm/xfrm_policy.c
index 03b6bf85d70b..410233c5681e 100644
--- a/net/xfrm/xfrm_policy.c
+++ b/net/xfrm/xfrm_policy.c
@@ -3519,7 +3519,7 @@ int __xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb,
         ifcb = xfrm_if_get_cb();
 
         if (ifcb) {
-                xi = ifcb->decode_session(skb);
+                xi = ifcb->decode_session(skb, family);
                 if (xi) {
                         if_id = xi->p.if_id;
                         net = xi->net;
diff --git a/net/xfrm/xfrm_state.c b/net/xfrm/xfrm_state.c
index ed25eb81aabe..3edbf4b26116 100644
--- a/net/xfrm/xfrm_state.c
+++ b/net/xfrm/xfrm_state.c
@@ -2340,7 +2340,7 @@ void xfrm_state_fini(struct net *net)
 
         flush_work(&net->xfrm.state_hash_work);
         flush_work(&xfrm_state_gc_work);
-        xfrm_state_flush(net, IPSEC_PROTO_ANY, false, true);
+        xfrm_state_flush(net, 0, false, true);
 
         WARN_ON(!list_empty(&net->xfrm.state_all));
 
diff --git a/net/xfrm/xfrm_user.c b/net/xfrm/xfrm_user.c
index d7cb16f0df5b..eb8d14389601 100644
--- a/net/xfrm/xfrm_user.c
+++ b/net/xfrm/xfrm_user.c
@@ -1424,7 +1424,7 @@ static int verify_newpolicy_info(struct xfrm_userpolicy_info *p)
         ret = verify_policy_dir(p->dir);
         if (ret)
                 return ret;
-        if (p->index && ((p->index & XFRM_POLICY_MAX) != p->dir))
+        if (p->index && (xfrm_policy_id2dir(p->index) != p->dir))
                 return -EINVAL;
 
         return 0;
@@ -1513,20 +1513,8 @@ static int validate_tmpl(int nr, struct xfrm_user_tmpl *ut, u16 family)
                         return -EINVAL;
                 }
 
-                switch (ut[i].id.proto) {
-                case IPPROTO_AH:
-                case IPPROTO_ESP:
-                case IPPROTO_COMP:
-#if IS_ENABLED(CONFIG_IPV6)
-                case IPPROTO_ROUTING:
-                case IPPROTO_DSTOPTS:
-#endif
-                case IPSEC_PROTO_ANY:
-                        break;
-                default:
+                if (!xfrm_id_proto_valid(ut[i].id.proto))
                         return -EINVAL;
-                }
-
         }
 
         return 0;
diff --git a/scripts/selinux/genheaders/genheaders.c b/scripts/selinux/genheaders/genheaders.c
index 1ceedea847dd..544ca126a8a8 100644
--- a/scripts/selinux/genheaders/genheaders.c
+++ b/scripts/selinux/genheaders/genheaders.c
@@ -9,7 +9,6 @@
 #include <string.h>
 #include <errno.h>
 #include <ctype.h>
-#include <sys/socket.h>
 
 struct security_class_mapping {
         const char *name;
diff --git a/scripts/selinux/mdp/mdp.c b/scripts/selinux/mdp/mdp.c
index 073fe7537f6c..6d51b74bc679 100644
--- a/scripts/selinux/mdp/mdp.c
+++ b/scripts/selinux/mdp/mdp.c
@@ -32,7 +32,6 @@
 #include <stdlib.h>
 #include <unistd.h>
 #include <string.h>
-#include <sys/socket.h>
 
 static void usage(char *name)
 {
diff --git a/security/selinux/include/classmap.h b/security/selinux/include/classmap.h
index bd5fe0d3204a..201f7e588a29 100644
--- a/security/selinux/include/classmap.h
+++ b/security/selinux/include/classmap.h
@@ -1,5 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 #include <linux/capability.h>
+#include <linux/socket.h>
 
 #define COMMON_FILE_SOCK_PERMS "ioctl", "read", "write", "create", \
     "getattr", "setattr", "lock", "relabelfrom", "relabelto", "append", "map"
diff --git a/tools/bpf/bpftool/map.c b/tools/bpf/bpftool/map.c
index e951d45c0131..3ec82904ccec 100644
--- a/tools/bpf/bpftool/map.c
+++ b/tools/bpf/bpftool/map.c
@@ -1163,6 +1163,9 @@ static int do_create(int argc, char **argv)
                                 return -1;
                         }
                         NEXT_ARG();
+                } else {
+                        p_err("unknown arg %s", *argv);
+                        return -1;
                 }
         }
 
diff --git a/tools/lib/bpf/.gitignore b/tools/lib/bpf/.gitignore
index 7d9e182a1f51..d9e9dec04605 100644
--- a/tools/lib/bpf/.gitignore
+++ b/tools/lib/bpf/.gitignore
@@ -2,3 +2,4 @@ libbpf_version.h
 libbpf.pc
 FEATURE-DUMP.libbpf
 test_libbpf
+libbpf.so.*
diff --git a/tools/testing/selftests/bpf/verifier/calls.c b/tools/testing/selftests/bpf/verifier/calls.c
index fb11240b758b..9093a8f64dc6 100644
--- a/tools/testing/selftests/bpf/verifier/calls.c
+++ b/tools/testing/selftests/bpf/verifier/calls.c
@@ -375,6 +375,31 @@
         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 },
 {
+        "calls: ptr null check in subprog",
+        .insns = {
+        BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
+        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
+        BPF_LD_MAP_FD(BPF_REG_1, 0),
+        BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
+        BPF_MOV64_REG(BPF_REG_1, BPF_REG_0),
+        BPF_MOV64_REG(BPF_REG_6, BPF_REG_0),
+        BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3),
+        BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 1),
+        BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_6, 0),
+        BPF_EXIT_INSN(),
+        BPF_MOV64_IMM(BPF_REG_0, 0),
+        BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, 1),
+        BPF_MOV64_IMM(BPF_REG_0, 1),
+        BPF_EXIT_INSN(),
+        },
+        .errstr_unpriv = "function calls to other bpf functions are allowed for root only",
+        .fixup_map_hash_48b = { 3 },
+        .result_unpriv = REJECT,
+        .result = ACCEPT,
+        .retval = 0,
+},
+{
         "calls: two calls with args",
         .insns = {
         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1),
diff --git a/tools/testing/selftests/bpf/verifier/direct_packet_access.c b/tools/testing/selftests/bpf/verifier/direct_packet_access.c
index e3fc22e672c2..d5c596fdc4b9 100644
--- a/tools/testing/selftests/bpf/verifier/direct_packet_access.c
+++ b/tools/testing/selftests/bpf/verifier/direct_packet_access.c
@@ -631,3 +631,25 @@
         .errstr = "invalid access to packet",
         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 },
+{
+        "direct packet access: test29 (reg > pkt_end in subprog)",
+        .insns = {
+        BPF_LDX_MEM(BPF_W, BPF_REG_6, BPF_REG_1,
+                    offsetof(struct __sk_buff, data)),
+        BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+                    offsetof(struct __sk_buff, data_end)),
+        BPF_MOV64_REG(BPF_REG_3, BPF_REG_6),
+        BPF_ALU64_IMM(BPF_ADD, BPF_REG_3, 8),
+        BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 4),
+        BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 1),
+        BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_6, 0),
+        BPF_MOV64_IMM(BPF_REG_0, 0),
+        BPF_EXIT_INSN(),
+        BPF_MOV64_IMM(BPF_REG_0, 0),
+        BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_2, 1),
+        BPF_MOV64_IMM(BPF_REG_0, 1),
+        BPF_EXIT_INSN(),
+        },
+        .result = ACCEPT,
+        .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+},
diff --git a/tools/testing/selftests/net/fib_rule_tests.sh b/tools/testing/selftests/net/fib_rule_tests.sh
index d4cfb6a7a086..4b7e107865bf 100755
--- a/tools/testing/selftests/net/fib_rule_tests.sh
+++ b/tools/testing/selftests/net/fib_rule_tests.sh
@@ -27,6 +27,7 @@ log_test()
                 nsuccess=$((nsuccess+1))
                 printf "\n    TEST: %-50s  [ OK ]\n" "${msg}"
         else
+                ret=1
                 nfail=$((nfail+1))
                 printf "\n    TEST: %-50s  [FAIL]\n" "${msg}"
                 if [ "${PAUSE_ON_FAIL}" = "yes" ]; then
@@ -147,8 +148,8 @@ fib_rule6_test()
 
         fib_check_iproute_support "ipproto" "ipproto"
         if [ $? -eq 0 ]; then
-                match="ipproto icmp"
-                fib_rule6_test_match_n_redirect "$match" "$match" "ipproto icmp match"
+                match="ipproto ipv6-icmp"
+                fib_rule6_test_match_n_redirect "$match" "$match" "ipproto ipv6-icmp match"
         fi
 }
 
@@ -245,4 +246,9 @@ setup
 run_fibrule_tests
 cleanup
 
+if [ "$TESTS" != "none" ]; then
+        printf "\nTests passed: %3d\n" ${nsuccess}
+        printf "Tests failed: %3d\n"   ${nfail}
+fi
+
 exit $ret
diff --git a/tools/testing/selftests/seccomp/seccomp_bpf.c b/tools/testing/selftests/seccomp/seccomp_bpf.c
index f69d2ee29742..5019cdae5d0b 100644
--- a/tools/testing/selftests/seccomp/seccomp_bpf.c
+++ b/tools/testing/selftests/seccomp/seccomp_bpf.c
@@ -2166,11 +2166,14 @@ TEST(detect_seccomp_filter_flags)
                                  SECCOMP_FILTER_FLAG_LOG,
                                  SECCOMP_FILTER_FLAG_SPEC_ALLOW,
                                  SECCOMP_FILTER_FLAG_NEW_LISTENER };
-        unsigned int flag, all_flags;
+        unsigned int exclusive[] = {
+                                SECCOMP_FILTER_FLAG_TSYNC,
+                                SECCOMP_FILTER_FLAG_NEW_LISTENER };
+        unsigned int flag, all_flags, exclusive_mask;
         int i;
         long ret;
 
-        /* Test detection of known-good filter flags */
+        /* Test detection of individual known-good filter flags */
         for (i = 0, all_flags = 0; i < ARRAY_SIZE(flags); i++) {
                 int bits = 0;
 
@@ -2197,16 +2200,29 @@ TEST(detect_seccomp_filter_flags)
                 all_flags |= flag;
         }
 
-        /* Test detection of all known-good filter flags */
-        ret = seccomp(SECCOMP_SET_MODE_FILTER, all_flags, NULL);
-        EXPECT_EQ(-1, ret);
-        EXPECT_EQ(EFAULT, errno) {
-                TH_LOG("Failed to detect that all known-good filter flags (0x%X) are supported!",
-                       all_flags);
+        /*
+         * Test detection of all known-good filter flags combined. But
+         * for the exclusive flags we need to mask them out and try them
+         * individually for the "all flags" testing.
+         */
+        exclusive_mask = 0;
+        for (i = 0; i < ARRAY_SIZE(exclusive); i++)
+                exclusive_mask |= exclusive[i];
+        for (i = 0; i < ARRAY_SIZE(exclusive); i++) {
+                flag = all_flags & ~exclusive_mask;
+                flag |= exclusive[i];
+
+                ret = seccomp(SECCOMP_SET_MODE_FILTER, flag, NULL);
+                EXPECT_EQ(-1, ret);
+                EXPECT_EQ(EFAULT, errno) {
+                        TH_LOG("Failed to detect that all known-good filter flags (0x%X) are supported!",
+                               flag);
+                }
         }
 
-        /* Test detection of an unknown filter flag */
+        /* Test detection of an unknown filter flags, without exclusives. */
         flag = -1;
+        flag &= ~exclusive_mask;
         ret = seccomp(SECCOMP_SET_MODE_FILTER, flag, NULL);
         EXPECT_EQ(-1, ret);
         EXPECT_EQ(EINVAL, errno) {