Merge branch 'akpm' (patches from Andrew)

Merge more updates from Andrew Morton: "VM: - z3fold fixes and enhancements by Henry Burns and Vitaly Wool - more accurate reclaimed slab caches calculations by Yafang Shao - fix MAP_UNINITIALIZED UAPI symbol to not depend on config, by Christoph Hellwig - !CONFIG_MMU fixes by Christoph Hellwig - new novmcoredd parameter to omit device dumps from vmcore, by Kairui Song - new test_meminit module for testing heap and pagealloc initialization, by Alexander Potapenko - ioremap improvements for huge mappings, by Anshuman Khandual - generalize kprobe page fault handling, by Anshuman Khandual - device-dax hotplug fixes and improvements, by Pavel Tatashin - enable synchronous DAX fault on powerpc, by Aneesh Kumar K.V - add pte_devmap() support for arm64, by Robin Murphy - unify locked_vm accounting with a helper, by Daniel Jordan - several misc fixes core/lib: - new typeof_member() macro including some users, by Alexey Dobriyan - make BIT() and GENMASK() available in asm, by Masahiro Yamada - changed LIST_POISON2 on x86_64 to 0xdead000000000122 for better code generation, by Alexey Dobriyan - rbtree code size optimizations, by Michel Lespinasse - convert struct pid count to refcount_t, by Joel Fernandes get_maintainer.pl: - add --no-moderated switch to skip moderated ML's, by Joe Perches misc: - ptrace PTRACE_GET_SYSCALL_INFO interface - coda updates - gdb scripts, various" [ Using merge message suggestion from Vlastimil Babka, with some editing - Linus ] * emailed patches from Andrew Morton <akpm@linux-foundation.org>: (100 commits) fs/select.c: use struct_size() in kmalloc() mm: add account_locked_vm utility function arm64: mm: implement pte_devmap support mm: introduce ARCH_HAS_PTE_DEVMAP mm: clean up is_device_*_page() definitions mm/mmap: move common defines to mman-common.h mm: move MAP_SYNC to asm-generic/mman-common.h device-dax: "Hotremove" persistent memory that is used like normal RAM mm/hotplug: make remove_memory() interface usable device-dax: fix memory and resource leak if hotplug fails include/linux/lz4.h: fix spelling and copy-paste errors in documentation ipc/mqueue.c: only perform resource calculation if user valid include/asm-generic/bug.h: fix "cut here" for WARN_ON for __WARN_TAINT architectures scripts/gdb: add helpers to find and list devices scripts/gdb: add lx-genpd-summary command drivers/pps/pps.c: clear offset flags in PPS_SETPARAMS ioctl kernel/pid.c: convert struct pid count to refcount_t drivers/rapidio/devices/rio_mport_cdev.c: NUL terminate some strings select: shift restore_saved_sigmask_unless() into poll_select_copy_remaining() select: change do_poll() to return -ERESTARTNOHAND rather than -EINTR ...
author: Linus Torvalds <torvalds@linux-foundation.org> 2019-07-17 11:58:04 -0400
committer: Linus Torvalds <torvalds@linux-foundation.org> 2019-07-17 11:58:04 -0400
commit: 57a8ec387e1441ea5e1232bc0749fb99a8cba7e7 (patch)
tree: b5fb03fc6bc5754de8b5b1f8b0e4f36d67c8315c
parent: 0a8ad0ffa4d80a544f6cbff703bf6394339afcdf (diff)
parent: 43e11fa2d1d3b6e35629fa556eb7d571edba2010 (diff)
151 files changed, 2674 insertions, 1225 deletions
diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
index 34a363f91b46..a5f4004e8705 100644
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -2877,6 +2877,17 @@
                        /sys/module/printk/parameters/console_suspend) to
                        turn on/off it dynamically.
+        novmcoredd      [KNL,KDUMP]
+                        Disable device dump. Device dump allows drivers to
+                        append dump data to vmcore so you can collect driver
+                        specified debug info.  Drivers can append the data
+                        without any limit and this data is stored in memory,
+                        so this may cause significant memory stress.  Disabling
+                        device dump can help save memory but the driver debug
+                        data will be no longer available.  This parameter
+                        is only available when CONFIG_PROC_VMCORE_DEVICE_DUMP
+                        is set.
        noaliencache    [MM, NUMA, SLAB] Disables the allocation of alien
                        caches in the slab allocator.  Saves per-node memory,
                        but will impact performance.
diff --git a/Documentation/devicetree/bindings/usb/s3c2410-usb.txt b/Documentation/devicetree/bindings/usb/s3c2410-usb.txt
index e45b38ce2986..26c85afd0b53 100644
--- a/Documentation/devicetree/bindings/usb/s3c2410-usb.txt
+++ b/Documentation/devicetree/bindings/usb/s3c2410-usb.txt
@@ -4,7 +4,7 @@ OHCI
 Required properties:
 - compatible: should be "samsung,s3c2410-ohci" for USB host controller
- - reg: address and lenght of the controller memory mapped region
+ - reg: address and length of the controller memory mapped region
 - interrupts: interrupt number for the USB OHCI controller
 - clocks: Should reference the bus and host clocks
 - clock-names: Should contain two strings
diff --git a/Documentation/filesystems/coda.txt b/Documentation/filesystems/coda.txt
index 61311356025d..545262c167c3 100644
--- a/Documentation/filesystems/coda.txt
+++ b/Documentation/filesystems/coda.txt
@@ -481,7 +481,10 @@ kernel support.
+  struct coda_timespec {
+          int64_t         tv_sec;         /* seconds */
+          long            tv_nsec;        /* nanoseconds */
+  };
  struct coda_vattr {
          enum coda_vtype va_type;        /* vnode type (for create) */
@@ -493,9 +496,9 @@ kernel support.
          long            va_fileid;      /* file id */
          u_quad_t        va_size;        /* file size in bytes */
          long            va_blocksize;   /* blocksize preferred for i/o */
-          struct timespec va_atime;       /* time of last access */
+          struct coda_timespec va_atime;  /* time of last access */
-          struct timespec va_mtime;       /* time of last modification */
+          struct coda_timespec va_mtime;  /* time of last modification */
-          struct timespec va_ctime;       /* time file changed */
+          struct coda_timespec va_ctime;  /* time file changed */
          u_long          va_gen;         /* generation number of file */
          u_long          va_flags;       /* flags defined for file */
          dev_t           va_rdev;        /* device special file represents */
diff --git a/arch/alpha/include/asm/io.h b/arch/alpha/include/asm/io.h
index ccf9d65166bb..af2c0063dc75 100644
--- a/arch/alpha/include/asm/io.h
+++ b/arch/alpha/include/asm/io.h
@@ -93,11 +93,6 @@ static inline void * phys_to_virt(unsigned long address)
 #define page_to_phys(page)      page_to_pa(page)
-static inline dma_addr_t __deprecated isa_page_to_bus(struct page *page)
-{
-        return page_to_phys(page);
-}
 /* Maximum PIO space address supported?  */
 #define IO_SPACE_LIMIT 0xffff
diff --git a/arch/arc/include/asm/pgtable.h b/arch/arc/include/asm/pgtable.h
index da446180f17b..1d87c18a2976 100644
--- a/arch/arc/include/asm/pgtable.h
+++ b/arch/arc/include/asm/pgtable.h
@@ -32,7 +32,7 @@
 #ifndef _ASM_ARC_PGTABLE_H
 #define _ASM_ARC_PGTABLE_H
-#include <linux/const.h>
+#include <linux/bits.h>
 #define __ARCH_USE_5LEVEL_HACK
 #include <asm-generic/pgtable-nopmd.h>
 #include <asm/page.h>
@@ -215,11 +215,11 @@
 #define BITS_FOR_PTE    (PGDIR_SHIFT - PAGE_SHIFT)
 #define BITS_FOR_PGD    (32 - PGDIR_SHIFT)
-#define PGDIR_SIZE      _BITUL(PGDIR_SHIFT)     /* vaddr span, not PDG sz */
+#define PGDIR_SIZE      BIT(PGDIR_SHIFT)        /* vaddr span, not PDG sz */
 #define PGDIR_MASK      (~(PGDIR_SIZE-1))
-#define PTRS_PER_PTE    _BITUL(BITS_FOR_PTE)
+#define PTRS_PER_PTE    BIT(BITS_FOR_PTE)
-#define PTRS_PER_PGD    _BITUL(BITS_FOR_PGD)
+#define PTRS_PER_PGD    BIT(BITS_FOR_PGD)
 /*
 * Number of entries a user land program use.
diff --git a/arch/arc/plat-eznps/include/plat/ctop.h b/arch/arc/plat-eznps/include/plat/ctop.h
index 309a994f64f0..a4a61531c7fb 100644
--- a/arch/arc/plat-eznps/include/plat/ctop.h
+++ b/arch/arc/plat-eznps/include/plat/ctop.h
@@ -10,6 +10,7 @@
 #error "Incorrect ctop.h include"
 #endif
+#include <linux/bits.h>
 #include <linux/types.h>
 #include <soc/nps/common.h>
@@ -51,19 +52,19 @@
 #define CTOP_INST_AXOR_DI_R2_R2_R3              0x4A664C06
 /* Do not use D$ for address in 2G-3G */
-#define HW_COMPLY_KRN_NOT_D_CACHED              _BITUL(28)
+#define HW_COMPLY_KRN_NOT_D_CACHED              BIT(28)
 #define NPS_MSU_EN_CFG                          0x80
 #define NPS_CRG_BLKID                           0x480
-#define NPS_CRG_SYNC_BIT                        _BITUL(0)
+#define NPS_CRG_SYNC_BIT                        BIT(0)
 #define NPS_GIM_BLKID                           0x5C0
 /* GIM registers and fields*/
-#define NPS_GIM_UART_LINE                       _BITUL(7)
+#define NPS_GIM_UART_LINE                       BIT(7)
-#define NPS_GIM_DBG_LAN_EAST_TX_DONE_LINE       _BITUL(10)
+#define NPS_GIM_DBG_LAN_EAST_TX_DONE_LINE       BIT(10)
-#define NPS_GIM_DBG_LAN_EAST_RX_RDY_LINE        _BITUL(11)
+#define NPS_GIM_DBG_LAN_EAST_RX_RDY_LINE        BIT(11)
-#define NPS_GIM_DBG_LAN_WEST_TX_DONE_LINE       _BITUL(25)
+#define NPS_GIM_DBG_LAN_WEST_TX_DONE_LINE       BIT(25)
-#define NPS_GIM_DBG_LAN_WEST_RX_RDY_LINE        _BITUL(26)
+#define NPS_GIM_DBG_LAN_WEST_RX_RDY_LINE        BIT(26)
 #ifndef __ASSEMBLY__
 /* Functional registers definition */
diff --git a/arch/arm/include/asm/io.h b/arch/arm/include/asm/io.h
index f11c35cf0b74..7a0596fcb2e7 100644
--- a/arch/arm/include/asm/io.h
+++ b/arch/arm/include/asm/io.h
@@ -30,7 +30,6 @@
 * ISA I/O bus memory addresses are 1:1 with the physical address.
 */
 #define isa_virt_to_bus virt_to_phys
-#define isa_page_to_bus page_to_phys
 #define isa_bus_to_virt phys_to_virt
 /*
diff --git a/arch/arm/mm/fault.c b/arch/arm/mm/fault.c
index 0e417233dad7..890eeaac3cbb 100644
--- a/arch/arm/mm/fault.c
+++ b/arch/arm/mm/fault.c
@@ -27,28 +27,6 @@
 #ifdef CONFIG_MMU
-#ifdef CONFIG_KPROBES
-static inline int notify_page_fault(struct pt_regs *regs, unsigned int fsr)
-{
-        int ret = 0;
-        if (!user_mode(regs)) {
-                /* kprobe_running() needs smp_processor_id() */
-                preempt_disable();
-                if (kprobe_running() && kprobe_fault_handler(regs, fsr))
-                        ret = 1;
-                preempt_enable();
-        }
-        return ret;
-}
-#else
-static inline int notify_page_fault(struct pt_regs *regs, unsigned int fsr)
-{
-        return 0;
-}
-#endif
 /*
 * This is useful to dump out the page tables associated with
 * 'addr' in mm 'mm'.
@@ -265,7 +243,7 @@ do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
        vm_fault_t fault;
        unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
-        if (notify_page_fault(regs, fsr))
+        if (kprobe_page_fault(regs, fsr))
                return 0;
        tsk = current;
diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig
index 86f81b5afd95..e1ea69994e0f 100644
--- a/arch/arm64/Kconfig
+++ b/arch/arm64/Kconfig
@@ -24,6 +24,7 @@ config ARM64
        select ARCH_HAS_KCOV
        select ARCH_HAS_KEEPINITRD
        select ARCH_HAS_MEMBARRIER_SYNC_CORE
+        select ARCH_HAS_PTE_DEVMAP
        select ARCH_HAS_PTE_SPECIAL
        select ARCH_HAS_SETUP_DMA_OPS
        select ARCH_HAS_SET_DIRECT_MAP
diff --git a/arch/arm64/include/asm/pgtable-prot.h b/arch/arm64/include/asm/pgtable-prot.h
index f318258a14be..92d2e9f28f28 100644
--- a/arch/arm64/include/asm/pgtable-prot.h
+++ b/arch/arm64/include/asm/pgtable-prot.h
@@ -16,6 +16,7 @@
 #define PTE_WRITE               (PTE_DBM)                /* same as DBM (51) */
 #define PTE_DIRTY               (_AT(pteval_t, 1) << 55)
 #define PTE_SPECIAL             (_AT(pteval_t, 1) << 56)
+#define PTE_DEVMAP              (_AT(pteval_t, 1) << 57)
 #define PTE_PROT_NONE           (_AT(pteval_t, 1) << 58) /* only when !PTE_VALID */
 #ifndef __ASSEMBLY__
diff --git a/arch/arm64/include/asm/pgtable.h b/arch/arm64/include/asm/pgtable.h
index 3052381baaeb..87a4b2ddc1a1 100644
--- a/arch/arm64/include/asm/pgtable.h
+++ b/arch/arm64/include/asm/pgtable.h
@@ -79,6 +79,7 @@ extern unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)];
 #define pte_write(pte)          (!!(pte_val(pte) & PTE_WRITE))
 #define pte_user_exec(pte)      (!(pte_val(pte) & PTE_UXN))
 #define pte_cont(pte)           (!!(pte_val(pte) & PTE_CONT))
+#define pte_devmap(pte)         (!!(pte_val(pte) & PTE_DEVMAP))
 #define pte_cont_addr_end(addr, end)                                            \
 ({      unsigned long __boundary = ((addr) + CONT_PTE_SIZE) & CONT_PTE_MASK;    \
@@ -206,6 +207,11 @@ static inline pmd_t pmd_mkcont(pmd_t pmd)
        return __pmd(pmd_val(pmd) | PMD_SECT_CONT);
 }
+static inline pte_t pte_mkdevmap(pte_t pte)
+{
+        return set_pte_bit(pte, __pgprot(PTE_DEVMAP));
+}
 static inline void set_pte(pte_t *ptep, pte_t pte)
 {
        WRITE_ONCE(*ptep, pte);
@@ -388,6 +394,11 @@ static inline int pmd_protnone(pmd_t pmd)
 #define pmd_mkhuge(pmd)         (__pmd(pmd_val(pmd) & ~PMD_TABLE_BIT))
+#ifdef CONFIG_TRANSPARENT_HUGEPAGE
+#define pmd_devmap(pmd)         pte_devmap(pmd_pte(pmd))
+#endif
+#define pmd_mkdevmap(pmd)       pte_pmd(pte_mkdevmap(pmd_pte(pmd)))
 #define __pmd_to_phys(pmd)      __pte_to_phys(pmd_pte(pmd))
 #define __phys_to_pmd_val(phys) __phys_to_pte_val(phys)
 #define pmd_pfn(pmd)            ((__pmd_to_phys(pmd) & PMD_MASK) >> PAGE_SHIFT)
@@ -673,6 +684,16 @@ static inline int pmdp_set_access_flags(struct vm_area_struct *vma,
 {
        return ptep_set_access_flags(vma, address, (pte_t *)pmdp, pmd_pte(entry), dirty);
 }
+static inline int pud_devmap(pud_t pud)
+{
+        return 0;
+}
+static inline int pgd_devmap(pgd_t pgd)
+{
+        return 0;
+}
 #endif
 /*
diff --git a/arch/arm64/include/asm/sysreg.h b/arch/arm64/include/asm/sysreg.h
index a7522fca1105..06ebcfef73df 100644
--- a/arch/arm64/include/asm/sysreg.h
+++ b/arch/arm64/include/asm/sysreg.h
@@ -9,7 +9,7 @@
 #ifndef __ASM_SYSREG_H
 #define __ASM_SYSREG_H
-#include <linux/const.h>
+#include <linux/bits.h>
 #include <linux/stringify.h>
 /*
@@ -478,31 +478,31 @@
 #define SYS_CNTV_CVAL_EL02              sys_reg(3, 5, 14, 3, 2)
 /* Common SCTLR_ELx flags. */
-#define SCTLR_ELx_DSSBS (_BITUL(44))
+#define SCTLR_ELx_DSSBS (BIT(44))
-#define SCTLR_ELx_ENIA  (_BITUL(31))
+#define SCTLR_ELx_ENIA  (BIT(31))
-#define SCTLR_ELx_ENIB  (_BITUL(30))
+#define SCTLR_ELx_ENIB  (BIT(30))
-#define SCTLR_ELx_ENDA  (_BITUL(27))
+#define SCTLR_ELx_ENDA  (BIT(27))
-#define SCTLR_ELx_EE    (_BITUL(25))
+#define SCTLR_ELx_EE    (BIT(25))
-#define SCTLR_ELx_IESB  (_BITUL(21))
+#define SCTLR_ELx_IESB  (BIT(21))
-#define SCTLR_ELx_WXN   (_BITUL(19))
+#define SCTLR_ELx_WXN   (BIT(19))
-#define SCTLR_ELx_ENDB  (_BITUL(13))
+#define SCTLR_ELx_ENDB  (BIT(13))
-#define SCTLR_ELx_I     (_BITUL(12))
+#define SCTLR_ELx_I     (BIT(12))
-#define SCTLR_ELx_SA    (_BITUL(3))
+#define SCTLR_ELx_SA    (BIT(3))
-#define SCTLR_ELx_C     (_BITUL(2))
+#define SCTLR_ELx_C     (BIT(2))
-#define SCTLR_ELx_A     (_BITUL(1))
+#define SCTLR_ELx_A     (BIT(1))
-#define SCTLR_ELx_M     (_BITUL(0))
+#define SCTLR_ELx_M     (BIT(0))
 #define SCTLR_ELx_FLAGS (SCTLR_ELx_M  | SCTLR_ELx_A | SCTLR_ELx_C | \
                         SCTLR_ELx_SA | SCTLR_ELx_I | SCTLR_ELx_IESB)
 /* SCTLR_EL2 specific flags. */
-#define SCTLR_EL2_RES1  ((_BITUL(4))  | (_BITUL(5))  | (_BITUL(11)) | (_BITUL(16)) | \
+#define SCTLR_EL2_RES1  ((BIT(4))  | (BIT(5))  | (BIT(11)) | (BIT(16)) | \
-                         (_BITUL(18)) | (_BITUL(22)) | (_BITUL(23)) | (_BITUL(28)) | \
+                         (BIT(18)) | (BIT(22)) | (BIT(23)) | (BIT(28)) | \
-                         (_BITUL(29)))
+                         (BIT(29)))
-#define SCTLR_EL2_RES0  ((_BITUL(6))  | (_BITUL(7))  | (_BITUL(8))  | (_BITUL(9))  | \
+#define SCTLR_EL2_RES0  ((BIT(6))  | (BIT(7))  | (BIT(8))  | (BIT(9))  | \
-                         (_BITUL(10)) | (_BITUL(13)) | (_BITUL(14)) | (_BITUL(15)) | \
+                         (BIT(10)) | (BIT(13)) | (BIT(14)) | (BIT(15)) | \
-                         (_BITUL(17)) | (_BITUL(20)) | (_BITUL(24)) | (_BITUL(26)) | \
+                         (BIT(17)) | (BIT(20)) | (BIT(24)) | (BIT(26)) | \
-                         (_BITUL(27)) | (_BITUL(30)) | (_BITUL(31)) | \
+                         (BIT(27)) | (BIT(30)) | (BIT(31)) | \
                         (0xffffefffUL << 32))
 #ifdef CONFIG_CPU_BIG_ENDIAN
@@ -524,23 +524,23 @@
 #endif
 /* SCTLR_EL1 specific flags. */
-#define SCTLR_EL1_UCI           (_BITUL(26))
+#define SCTLR_EL1_UCI           (BIT(26))
-#define SCTLR_EL1_E0E           (_BITUL(24))
+#define SCTLR_EL1_E0E           (BIT(24))
-#define SCTLR_EL1_SPAN          (_BITUL(23))
+#define SCTLR_EL1_SPAN          (BIT(23))
-#define SCTLR_EL1_NTWE          (_BITUL(18))
+#define SCTLR_EL1_NTWE          (BIT(18))
-#define SCTLR_EL1_NTWI          (_BITUL(16))
+#define SCTLR_EL1_NTWI          (BIT(16))
-#define SCTLR_EL1_UCT           (_BITUL(15))
+#define SCTLR_EL1_UCT           (BIT(15))
-#define SCTLR_EL1_DZE           (_BITUL(14))
+#define SCTLR_EL1_DZE           (BIT(14))
-#define SCTLR_EL1_UMA           (_BITUL(9))
+#define SCTLR_EL1_UMA           (BIT(9))
-#define SCTLR_EL1_SED           (_BITUL(8))
+#define SCTLR_EL1_SED           (BIT(8))
-#define SCTLR_EL1_ITD           (_BITUL(7))
+#define SCTLR_EL1_ITD           (BIT(7))
-#define SCTLR_EL1_CP15BEN       (_BITUL(5))
+#define SCTLR_EL1_CP15BEN       (BIT(5))
-#define SCTLR_EL1_SA0           (_BITUL(4))
+#define SCTLR_EL1_SA0           (BIT(4))
-#define SCTLR_EL1_RES1  ((_BITUL(11)) | (_BITUL(20)) | (_BITUL(22)) | (_BITUL(28)) | \
+#define SCTLR_EL1_RES1  ((BIT(11)) | (BIT(20)) | (BIT(22)) | (BIT(28)) | \
-                         (_BITUL(29)))
+                         (BIT(29)))
-#define SCTLR_EL1_RES0  ((_BITUL(6))  | (_BITUL(10)) | (_BITUL(13)) | (_BITUL(17)) | \
+#define SCTLR_EL1_RES0  ((BIT(6))  | (BIT(10)) | (BIT(13)) | (BIT(17)) | \
-                         (_BITUL(27)) | (_BITUL(30)) | (_BITUL(31)) | \
+                         (BIT(27)) | (BIT(30)) | (BIT(31)) | \
                         (0xffffefffUL << 32))
 #ifdef CONFIG_CPU_BIG_ENDIAN
@@ -756,13 +756,13 @@
 #define ZCR_ELx_LEN_SIZE        9
 #define ZCR_ELx_LEN_MASK        0x1ff
-#define CPACR_EL1_ZEN_EL1EN     (_BITUL(16)) /* enable EL1 access */
+#define CPACR_EL1_ZEN_EL1EN     (BIT(16)) /* enable EL1 access */
-#define CPACR_EL1_ZEN_EL0EN     (_BITUL(17)) /* enable EL0 access, if EL1EN set */
+#define CPACR_EL1_ZEN_EL0EN     (BIT(17)) /* enable EL0 access, if EL1EN set */
 #define CPACR_EL1_ZEN           (CPACR_EL1_ZEN_EL1EN | CPACR_EL1_ZEN_EL0EN)
 /* Safe value for MPIDR_EL1: Bit31:RES1, Bit30:U:0, Bit24:MT:0 */
-#define SYS_MPIDR_SAFE_VAL      (_BITUL(31))
+#define SYS_MPIDR_SAFE_VAL      (BIT(31))
 #ifdef __ASSEMBLY__
diff --git a/arch/arm64/mm/fault.c b/arch/arm64/mm/fault.c
index c8c61b1eb479..9568c116ac7f 100644
--- a/arch/arm64/mm/fault.c
+++ b/arch/arm64/mm/fault.c
@@ -59,28 +59,6 @@ static inline const struct fault_info *esr_to_debug_fault_info(unsigned int esr)
        return debug_fault_info + DBG_ESR_EVT(esr);
 }
-#ifdef CONFIG_KPROBES
-static inline int notify_page_fault(struct pt_regs *regs, unsigned int esr)
-{
-        int ret = 0;
-        /* kprobe_running() needs smp_processor_id() */
-        if (!user_mode(regs)) {
-                preempt_disable();
-                if (kprobe_running() && kprobe_fault_handler(regs, esr))
-                        ret = 1;
-                preempt_enable();
-        }
-        return ret;
-}
-#else
-static inline int notify_page_fault(struct pt_regs *regs, unsigned int esr)
-{
-        return 0;
-}
-#endif
 static void data_abort_decode(unsigned int esr)
 {
        pr_alert("Data abort info:\n");
@@ -434,7 +412,7 @@ static int __kprobes do_page_fault(unsigned long addr, unsigned int esr,
        unsigned long vm_flags = VM_READ | VM_WRITE;
        unsigned int mm_flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
-        if (notify_page_fault(regs, esr))
+        if (kprobe_page_fault(regs, esr))
                return 0;
        /*
diff --git a/arch/arm64/mm/mmu.c b/arch/arm64/mm/mmu.c
index 1b49c08dfa2b..e661469cabdd 100644
--- a/arch/arm64/mm/mmu.c
+++ b/arch/arm64/mm/mmu.c
@@ -942,6 +942,11 @@ void *__init fixmap_remap_fdt(phys_addr_t dt_phys)
        return dt_virt;
 }
+int __init arch_ioremap_p4d_supported(void)
+{
+        return 0;
+}
 int __init arch_ioremap_pud_supported(void)
 {
        /*
diff --git a/arch/hexagon/include/asm/syscall.h b/arch/hexagon/include/asm/syscall.h
index 4f054b1ddef5..f6e454f18038 100644
--- a/arch/hexagon/include/asm/syscall.h
+++ b/arch/hexagon/include/asm/syscall.h
@@ -9,6 +9,8 @@
 #define _ASM_HEXAGON_SYSCALL_H
 #include <uapi/linux/audit.h>
+#include <linux/err.h>
+#include <asm/ptrace.h>
 typedef long (*syscall_fn)(unsigned long, unsigned long,
        unsigned long, unsigned long,
@@ -31,6 +33,18 @@ static inline void syscall_get_arguments(struct task_struct *task,
        memcpy(args, &(&regs->r00)[0], 6 * sizeof(args[0]));
 }
+static inline long syscall_get_error(struct task_struct *task,
+                                     struct pt_regs *regs)
+{
+        return IS_ERR_VALUE(regs->r00) ? regs->r00 : 0;
+}
+static inline long syscall_get_return_value(struct task_struct *task,
+                                            struct pt_regs *regs)
+{
+        return regs->r00;
+}
 static inline int syscall_get_arch(struct task_struct *task)
 {
        return AUDIT_ARCH_HEXAGON;
diff --git a/arch/ia64/mm/fault.c b/arch/ia64/mm/fault.c
index 3c3a283d3172..c2f299fe9e04 100644
--- a/arch/ia64/mm/fault.c
+++ b/arch/ia64/mm/fault.c
@@ -21,28 +21,6 @@
 extern int die(char *, struct pt_regs *, long);
-#ifdef CONFIG_KPROBES
-static inline int notify_page_fault(struct pt_regs *regs, int trap)
-{
-        int ret = 0;
-        if (!user_mode(regs)) {
-                /* kprobe_running() needs smp_processor_id() */
-                preempt_disable();
-                if (kprobe_running() && kprobe_fault_handler(regs, trap))
-                        ret = 1;
-                preempt_enable();
-        }
-        return ret;
-}
-#else
-static inline int notify_page_fault(struct pt_regs *regs, int trap)
-{
-        return 0;
-}
-#endif
 /*
 * Return TRUE if ADDRESS points at a page in the kernel's mapped segment
 * (inside region 5, on ia64) and that page is present.
@@ -116,7 +94,7 @@ ia64_do_page_fault (unsigned long address, unsigned long isr, struct pt_regs *re
        /*
         * This is to handle the kprobes on user space access instructions
         */
-        if (notify_page_fault(regs, TRAP_BRKPT))
+        if (kprobe_page_fault(regs, TRAP_BRKPT))
                return;
        if (user_mode(regs))
diff --git a/arch/mips/include/asm/io.h b/arch/mips/include/asm/io.h
index 29997e42480e..1790274c27eb 100644
--- a/arch/mips/include/asm/io.h
+++ b/arch/mips/include/asm/io.h
@@ -149,8 +149,6 @@ static inline void *isa_bus_to_virt(unsigned long address)
        return phys_to_virt(address);
 }
-#define isa_page_to_bus page_to_phys
 /*
 * However PCI ones are not necessarily 1:1 and therefore these interfaces
 * are forbidden in portable PCI drivers.
diff --git a/arch/mips/include/asm/kprobes.h b/arch/mips/include/asm/kprobes.h
index 3cf8e4d5fa28..68b1e5d458cf 100644
--- a/arch/mips/include/asm/kprobes.h
+++ b/arch/mips/include/asm/kprobes.h
@@ -41,6 +41,7 @@ do {									\
 #define kretprobe_blacklist_size 0
 void arch_remove_kprobe(struct kprobe *p);
+int kprobe_fault_handler(struct pt_regs *regs, int trapnr);
 /* Architecture specific copy of original instruction*/
 struct arch_specific_insn {
diff --git a/arch/mips/include/asm/syscall.h b/arch/mips/include/asm/syscall.h
index acf80ae0a430..83bb439597d8 100644
--- a/arch/mips/include/asm/syscall.h
+++ b/arch/mips/include/asm/syscall.h
@@ -89,6 +89,12 @@ static inline unsigned long mips_get_syscall_arg(unsigned long *arg,
        unreachable();
 }
+static inline long syscall_get_error(struct task_struct *task,
+                                     struct pt_regs *regs)
+{
+        return regs->regs[7] ? -regs->regs[2] : 0;
+}
 static inline long syscall_get_return_value(struct task_struct *task,
                                            struct pt_regs *regs)
 {
diff --git a/arch/mips/kernel/kprobes.c b/arch/mips/kernel/kprobes.c
index 81ba1d3c367c..6cfae2411c04 100644
--- a/arch/mips/kernel/kprobes.c
+++ b/arch/mips/kernel/kprobes.c
@@ -398,7 +398,7 @@ out:
        return 1;
 }
-static inline int kprobe_fault_handler(struct pt_regs *regs, int trapnr)
+int kprobe_fault_handler(struct pt_regs *regs, int trapnr)
 {
        struct kprobe *cur = kprobe_running();
        struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
diff --git a/arch/nds32/include/asm/syscall.h b/arch/nds32/include/asm/syscall.h
index 899b2fb4b52f..7b5180d78e20 100644
--- a/arch/nds32/include/asm/syscall.h
+++ b/arch/nds32/include/asm/syscall.h
@@ -26,7 +26,8 @@ struct pt_regs;
 *
 * It's only valid to call this when @task is known to be blocked.
 */
-int syscall_get_nr(struct task_struct *task, struct pt_regs *regs)
+static inline int
+syscall_get_nr(struct task_struct *task, struct pt_regs *regs)
 {
        return regs->syscallno;
 }
@@ -47,7 +48,8 @@ int syscall_get_nr(struct task_struct *task, struct pt_regs *regs)
 * system call instruction.  This may not be the same as what the
 * register state looked like at system call entry tracing.
 */
-void syscall_rollback(struct task_struct *task, struct pt_regs *regs)
+static inline void
+syscall_rollback(struct task_struct *task, struct pt_regs *regs)
 {
        regs->uregs[0] = regs->orig_r0;
 }
@@ -62,7 +64,8 @@ void syscall_rollback(struct task_struct *task, struct pt_regs *regs)
 * It's only valid to call this when @task is stopped for tracing on exit
 * from a system call, due to %TIF_SYSCALL_TRACE or %TIF_SYSCALL_AUDIT.
 */
-long syscall_get_error(struct task_struct *task, struct pt_regs *regs)
+static inline long
+syscall_get_error(struct task_struct *task, struct pt_regs *regs)
 {
        unsigned long error = regs->uregs[0];
        return IS_ERR_VALUE(error) ? error : 0;
@@ -79,7 +82,8 @@ long syscall_get_error(struct task_struct *task, struct pt_regs *regs)
 * It's only valid to call this when @task is stopped for tracing on exit
 * from a system call, due to %TIF_SYSCALL_TRACE or %TIF_SYSCALL_AUDIT.
 */
-long syscall_get_return_value(struct task_struct *task, struct pt_regs *regs)
+static inline long
+syscall_get_return_value(struct task_struct *task, struct pt_regs *regs)
 {
        return regs->uregs[0];
 }
@@ -99,8 +103,9 @@ long syscall_get_return_value(struct task_struct *task, struct pt_regs *regs)
 * It's only valid to call this when @task is stopped for tracing on exit
 * from a system call, due to %TIF_SYSCALL_TRACE or %TIF_SYSCALL_AUDIT.
 */
-void syscall_set_return_value(struct task_struct *task, struct pt_regs *regs,
+static inline void
-                              int error, long val)
+syscall_set_return_value(struct task_struct *task, struct pt_regs *regs,
+                         int error, long val)
 {
        regs->uregs[0] = (long)error ? error : val;
 }
@@ -118,8 +123,9 @@ void syscall_set_return_value(struct task_struct *task, struct pt_regs *regs,
 * entry to a system call, due to %TIF_SYSCALL_TRACE or %TIF_SYSCALL_AUDIT.
 */
 #define SYSCALL_MAX_ARGS 6
-void syscall_get_arguments(struct task_struct *task, struct pt_regs *regs,
+static inline void
-                           unsigned long *args)
+syscall_get_arguments(struct task_struct *task, struct pt_regs *regs,
+                      unsigned long *args)
 {
        args[0] = regs->orig_r0;
        args++;
@@ -138,8 +144,9 @@ void syscall_get_arguments(struct task_struct *task, struct pt_regs *regs,
 * It's only valid to call this when @task is stopped for tracing on
 * entry to a system call, due to %TIF_SYSCALL_TRACE or %TIF_SYSCALL_AUDIT.
 */
-void syscall_set_arguments(struct task_struct *task, struct pt_regs *regs,
+static inline void
-                           const unsigned long *args)
+syscall_set_arguments(struct task_struct *task, struct pt_regs *regs,
+                      const unsigned long *args)
 {
        regs->orig_r0 = args[0];
        args++;
diff --git a/arch/parisc/include/asm/syscall.h b/arch/parisc/include/asm/syscall.h
index 80757e43cf2c..00b127a5e09b 100644
--- a/arch/parisc/include/asm/syscall.h
+++ b/arch/parisc/include/asm/syscall.h
@@ -29,6 +29,13 @@ static inline void syscall_get_arguments(struct task_struct *tsk,
        args[0] = regs->gr[26];
 }
+static inline long syscall_get_error(struct task_struct *task,
+                                     struct pt_regs *regs)
+{
+        unsigned long error = regs->gr[28];
+        return IS_ERR_VALUE(error) ? error : 0;
+}
 static inline long syscall_get_return_value(struct task_struct *task,
                                                struct pt_regs *regs)
 {
diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig
index f516796dd819..d8dcd8820369 100644
--- a/arch/powerpc/Kconfig
+++ b/arch/powerpc/Kconfig
@@ -129,6 +129,7 @@ config PPC
        select ARCH_HAS_MMIOWB                  if PPC64
        select ARCH_HAS_PHYS_TO_DMA
        select ARCH_HAS_PMEM_API                if PPC64
+        select ARCH_HAS_PTE_DEVMAP              if PPC_BOOK3S_64
        select ARCH_HAS_PTE_SPECIAL
        select ARCH_HAS_MEMBARRIER_CALLBACKS
        select ARCH_HAS_SCALED_CPUTIME          if VIRT_CPU_ACCOUNTING_NATIVE && PPC64
@@ -136,7 +137,6 @@ config PPC
        select ARCH_HAS_TICK_BROADCAST          if GENERIC_CLOCKEVENTS_BROADCAST
        select ARCH_HAS_UACCESS_FLUSHCACHE      if PPC64
        select ARCH_HAS_UBSAN_SANITIZE_ALL
-        select ARCH_HAS_ZONE_DEVICE             if PPC_BOOK3S_64
        select ARCH_HAVE_NMI_SAFE_CMPXCHG
        select ARCH_KEEP_MEMBLOCK
        select ARCH_MIGHT_HAVE_PC_PARPORT
diff --git a/arch/powerpc/include/asm/book3s/64/pgtable.h b/arch/powerpc/include/asm/book3s/64/pgtable.h
index 62e6ea0a7650..8308f32e9782 100644
--- a/arch/powerpc/include/asm/book3s/64/pgtable.h
+++ b/arch/powerpc/include/asm/book3s/64/pgtable.h
@@ -90,7 +90,6 @@
 #define _PAGE_SOFT_DIRTY        _RPAGE_SW3 /* software: software dirty tracking */
 #define _PAGE_SPECIAL           _RPAGE_SW2 /* software: special page */
 #define _PAGE_DEVMAP            _RPAGE_SW1 /* software: ZONE_DEVICE page */
-#define __HAVE_ARCH_PTE_DEVMAP
 /*
 * Drivers request for cache inhibited pte mapping using _PAGE_NO_CACHE
diff --git a/arch/powerpc/include/asm/syscall.h b/arch/powerpc/include/asm/syscall.h
index 81abcf6a737b..38d62acfdce7 100644
--- a/arch/powerpc/include/asm/syscall.h
+++ b/arch/powerpc/include/asm/syscall.h
@@ -35,6 +35,16 @@ static inline void syscall_rollback(struct task_struct *task,
        regs->gpr[3] = regs->orig_gpr3;
 }
+static inline long syscall_get_error(struct task_struct *task,
+                                     struct pt_regs *regs)
+{
+        /*
+         * If the system call failed,
+         * regs->gpr[3] contains a positive ERRORCODE.
+         */
+        return (regs->ccr & 0x10000000UL) ? -regs->gpr[3] : 0;
+}
 static inline long syscall_get_return_value(struct task_struct *task,
                                            struct pt_regs *regs)
 {
diff --git a/arch/powerpc/include/uapi/asm/mman.h b/arch/powerpc/include/uapi/asm/mman.h
index 65065ce32814..c0c737215b00 100644
--- a/arch/powerpc/include/uapi/asm/mman.h
+++ b/arch/powerpc/include/uapi/asm/mman.h
@@ -21,15 +21,11 @@
 #define MAP_DENYWRITE   0x0800          /* ETXTBSY */
 #define MAP_EXECUTABLE  0x1000          /* mark it as an executable */
 #define MCL_CURRENT     0x2000          /* lock all currently mapped pages */
 #define MCL_FUTURE      0x4000          /* lock all additions to address space */
 #define MCL_ONFAULT     0x8000          /* lock all pages that are faulted in */
-#define MAP_POPULATE    0x8000          /* populate (prefault) pagetables */
-#define MAP_NONBLOCK    0x10000         /* do not block on IO */
-#define MAP_STACK       0x20000         /* give out an address that is best suited for process/thread stacks */
-#define MAP_HUGETLB     0x40000         /* create a huge page mapping */
 /* Override any generic PKEY permission defines */
 #define PKEY_DISABLE_EXECUTE   0x4
 #undef PKEY_ACCESS_MASK
diff --git a/arch/powerpc/kvm/book3s_64_vio.c b/arch/powerpc/kvm/book3s_64_vio.c
index 5bf05cc774e2..e99a14798ab0 100644
--- a/arch/powerpc/kvm/book3s_64_vio.c
+++ b/arch/powerpc/kvm/book3s_64_vio.c
@@ -19,6 +19,7 @@
 #include <linux/anon_inodes.h>
 #include <linux/iommu.h>
 #include <linux/file.h>
+#include <linux/mm.h>
 #include <asm/kvm_ppc.h>
 #include <asm/kvm_book3s.h>
@@ -45,43 +46,6 @@ static unsigned long kvmppc_stt_pages(unsigned long tce_pages)
        return tce_pages + ALIGN(stt_bytes, PAGE_SIZE) / PAGE_SIZE;
 }
-static long kvmppc_account_memlimit(unsigned long stt_pages, bool inc)
-{
-        long ret = 0;
-        if (!current || !current->mm)
-                return ret; /* process exited */
-        down_write(&current->mm->mmap_sem);
-        if (inc) {
-                unsigned long locked, lock_limit;
-                locked = current->mm->locked_vm + stt_pages;
-                lock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
-                if (locked > lock_limit && !capable(CAP_IPC_LOCK))
-                        ret = -ENOMEM;
-                else
-                        current->mm->locked_vm += stt_pages;
-        } else {
-                if (WARN_ON_ONCE(stt_pages > current->mm->locked_vm))
-                        stt_pages = current->mm->locked_vm;
-                current->mm->locked_vm -= stt_pages;
-        }
-        pr_debug("[%d] RLIMIT_MEMLOCK KVM %c%ld %ld/%ld%s\n", current->pid,
-                        inc ? '+' : '-',
-                        stt_pages << PAGE_SHIFT,
-                        current->mm->locked_vm << PAGE_SHIFT,
-                        rlimit(RLIMIT_MEMLOCK),
-                        ret ? " - exceeded" : "");
-        up_write(&current->mm->mmap_sem);
-        return ret;
-}
 static void kvm_spapr_tce_iommu_table_free(struct rcu_head *head)
 {
        struct kvmppc_spapr_tce_iommu_table *stit = container_of(head,
@@ -291,7 +255,7 @@ static int kvm_spapr_tce_release(struct inode *inode, struct file *filp)
        kvm_put_kvm(stt->kvm);
-        kvmppc_account_memlimit(
+        account_locked_vm(current->mm,
                kvmppc_stt_pages(kvmppc_tce_pages(stt->size)), false);
        call_rcu(&stt->rcu, release_spapr_tce_table);
@@ -316,7 +280,7 @@ long kvm_vm_ioctl_create_spapr_tce(struct kvm *kvm,
                return -EINVAL;
        npages = kvmppc_tce_pages(size);
-        ret = kvmppc_account_memlimit(kvmppc_stt_pages(npages), true);
+        ret = account_locked_vm(current->mm, kvmppc_stt_pages(npages), true);
        if (ret)
                return ret;
@@ -362,7 +326,7 @@ long kvm_vm_ioctl_create_spapr_tce(struct kvm *kvm,
        kfree(stt);
 fail_acct:
-        kvmppc_account_memlimit(kvmppc_stt_pages(npages), false);
+        account_locked_vm(current->mm, kvmppc_stt_pages(npages), false);
        return ret;
 }
diff --git a/arch/powerpc/mm/book3s64/iommu_api.c b/arch/powerpc/mm/book3s64/iommu_api.c
index 90ee3a89722c..b056cae3388b 100644
--- a/arch/powerpc/mm/book3s64/iommu_api.c
+++ b/arch/powerpc/mm/book3s64/iommu_api.c
@@ -14,6 +14,7 @@
 #include <linux/hugetlb.h>
 #include <linux/swap.h>
 #include <linux/sizes.h>
+#include <linux/mm.h>
 #include <asm/mmu_context.h>
 #include <asm/pte-walk.h>
 #include <linux/mm_inline.h>
@@ -46,40 +47,6 @@ struct mm_iommu_table_group_mem_t {
        u64 dev_hpa;            /* Device memory base address */
 };
-static long mm_iommu_adjust_locked_vm(struct mm_struct *mm,
-                unsigned long npages, bool incr)
-{
-        long ret = 0, locked, lock_limit;
-        if (!npages)
-                return 0;
-        down_write(&mm->mmap_sem);
-        if (incr) {
-                locked = mm->locked_vm + npages;
-                lock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
-                if (locked > lock_limit && !capable(CAP_IPC_LOCK))
-                        ret = -ENOMEM;
-                else
-                        mm->locked_vm += npages;
-        } else {
-                if (WARN_ON_ONCE(npages > mm->locked_vm))
-                        npages = mm->locked_vm;
-                mm->locked_vm -= npages;
-        }
-        pr_debug("[%d] RLIMIT_MEMLOCK HASH64 %c%ld %ld/%ld\n",
-                        current ? current->pid : 0,
-                        incr ? '+' : '-',
-                        npages << PAGE_SHIFT,
-                        mm->locked_vm << PAGE_SHIFT,
-                        rlimit(RLIMIT_MEMLOCK));
-        up_write(&mm->mmap_sem);
-        return ret;
-}
 bool mm_iommu_preregistered(struct mm_struct *mm)
 {
        return !list_empty(&mm->context.iommu_group_mem_list);
@@ -96,7 +63,7 @@ static long mm_iommu_do_alloc(struct mm_struct *mm, unsigned long ua,
        unsigned long entry, chunk;
        if (dev_hpa == MM_IOMMU_TABLE_INVALID_HPA) {
-                ret = mm_iommu_adjust_locked_vm(mm, entries, true);
+                ret = account_locked_vm(mm, entries, true);
                if (ret)
                        return ret;
@@ -211,7 +178,7 @@ free_exit:
        kfree(mem);
 unlock_exit:
-        mm_iommu_adjust_locked_vm(mm, locked_entries, false);
+        account_locked_vm(mm, locked_entries, false);
        return ret;
 }
@@ -311,7 +278,7 @@ long mm_iommu_put(struct mm_struct *mm, struct mm_iommu_table_group_mem_t *mem)
 unlock_exit:
        mutex_unlock(&mem_list_mutex);
-        mm_iommu_adjust_locked_vm(mm, unlock_entries, false);
+        account_locked_vm(mm, unlock_entries, false);
        return ret;
 }
diff --git a/arch/powerpc/mm/book3s64/radix_pgtable.c b/arch/powerpc/mm/book3s64/radix_pgtable.c
index 65c2ba1e1783..b4ca9e95e678 100644
--- a/arch/powerpc/mm/book3s64/radix_pgtable.c
+++ b/arch/powerpc/mm/book3s64/radix_pgtable.c
@@ -1237,3 +1237,8 @@ int radix__ioremap_range(unsigned long ea, phys_addr_t pa, unsigned long size,
                return 0;
        }
 }
+int __init arch_ioremap_p4d_supported(void)
+{
+        return 0;
+}
diff --git a/arch/powerpc/mm/fault.c b/arch/powerpc/mm/fault.c
index d989592b6fc8..8432c281de92 100644
--- a/arch/powerpc/mm/fault.c
+++ b/arch/powerpc/mm/fault.c
@@ -42,26 +42,6 @@
 #include <asm/debug.h>
 #include <asm/kup.h>
-static inline bool notify_page_fault(struct pt_regs *regs)
-{
-        bool ret = false;
-#ifdef CONFIG_KPROBES
-        /* kprobe_running() needs smp_processor_id() */
-        if (!user_mode(regs)) {
-                preempt_disable();
-                if (kprobe_running() && kprobe_fault_handler(regs, 11))
-                        ret = true;
-                preempt_enable();
-        }
-#endif /* CONFIG_KPROBES */
-        if (unlikely(debugger_fault_handler(regs)))
-                ret = true;
-        return ret;
-}
 /*
 * Check whether the instruction inst is a store using
 * an update addressing form which will update r1.
@@ -461,8 +441,9 @@ static int __do_page_fault(struct pt_regs *regs, unsigned long address,
        int is_write = page_fault_is_write(error_code);
        vm_fault_t fault, major = 0;
        bool must_retry = false;
+        bool kprobe_fault = kprobe_page_fault(regs, 11);
-        if (notify_page_fault(regs))
+        if (unlikely(debugger_fault_handler(regs) || kprobe_fault))
                return 0;
        if (unlikely(page_fault_is_bad(error_code))) {
diff --git a/arch/s390/include/asm/ctl_reg.h b/arch/s390/include/asm/ctl_reg.h
index 0cf6b53587db..60f907516335 100644
--- a/arch/s390/include/asm/ctl_reg.h
+++ b/arch/s390/include/asm/ctl_reg.h
@@ -8,27 +8,27 @@
 #ifndef __ASM_CTL_REG_H
 #define __ASM_CTL_REG_H
-#include <linux/const.h>
+#include <linux/bits.h>
-#define CR0_CLOCK_COMPARATOR_SIGN       _BITUL(63 - 10)
+#define CR0_CLOCK_COMPARATOR_SIGN       BIT(63 - 10)
-#define CR0_EMERGENCY_SIGNAL_SUBMASK    _BITUL(63 - 49)
+#define CR0_EMERGENCY_SIGNAL_SUBMASK    BIT(63 - 49)
-#define CR0_EXTERNAL_CALL_SUBMASK       _BITUL(63 - 50)
+#define CR0_EXTERNAL_CALL_SUBMASK       BIT(63 - 50)
-#define CR0_CLOCK_COMPARATOR_SUBMASK    _BITUL(63 - 52)
+#define CR0_CLOCK_COMPARATOR_SUBMASK    BIT(63 - 52)
-#define CR0_CPU_TIMER_SUBMASK           _BITUL(63 - 53)
+#define CR0_CPU_TIMER_SUBMASK           BIT(63 - 53)
-#define CR0_SERVICE_SIGNAL_SUBMASK      _BITUL(63 - 54)
+#define CR0_SERVICE_SIGNAL_SUBMASK      BIT(63 - 54)
-#define CR0_UNUSED_56                   _BITUL(63 - 56)
+#define CR0_UNUSED_56                   BIT(63 - 56)
-#define CR0_INTERRUPT_KEY_SUBMASK       _BITUL(63 - 57)
+#define CR0_INTERRUPT_KEY_SUBMASK       BIT(63 - 57)
-#define CR0_MEASUREMENT_ALERT_SUBMASK   _BITUL(63 - 58)
+#define CR0_MEASUREMENT_ALERT_SUBMASK   BIT(63 - 58)
-#define CR2_GUARDED_STORAGE             _BITUL(63 - 59)
+#define CR2_GUARDED_STORAGE             BIT(63 - 59)
-#define CR14_UNUSED_32                  _BITUL(63 - 32)
+#define CR14_UNUSED_32                  BIT(63 - 32)
-#define CR14_UNUSED_33                  _BITUL(63 - 33)
+#define CR14_UNUSED_33                  BIT(63 - 33)
-#define CR14_CHANNEL_REPORT_SUBMASK     _BITUL(63 - 35)
+#define CR14_CHANNEL_REPORT_SUBMASK     BIT(63 - 35)
-#define CR14_RECOVERY_SUBMASK           _BITUL(63 - 36)
+#define CR14_RECOVERY_SUBMASK           BIT(63 - 36)
-#define CR14_DEGRADATION_SUBMASK        _BITUL(63 - 37)
+#define CR14_DEGRADATION_SUBMASK        BIT(63 - 37)
-#define CR14_EXTERNAL_DAMAGE_SUBMASK    _BITUL(63 - 38)
+#define CR14_EXTERNAL_DAMAGE_SUBMASK    BIT(63 - 38)
-#define CR14_WARNING_SUBMASK            _BITUL(63 - 39)
+#define CR14_WARNING_SUBMASK            BIT(63 - 39)
 #ifndef __ASSEMBLY__
diff --git a/arch/s390/include/asm/nmi.h b/arch/s390/include/asm/nmi.h
index 1e5dc4537bf2..b160da8fa14b 100644
--- a/arch/s390/include/asm/nmi.h
+++ b/arch/s390/include/asm/nmi.h
@@ -12,7 +12,7 @@
 #ifndef _ASM_S390_NMI_H
 #define _ASM_S390_NMI_H
-#include <linux/const.h>
+#include <linux/bits.h>
 #include <linux/types.h>
 #define MCIC_SUBCLASS_MASK      (1ULL<<63 | 1ULL<<62 | 1ULL<<61 | \
@@ -20,15 +20,15 @@
                                1ULL<<55 | 1ULL<<54 | 1ULL<<53 | \
                                1ULL<<52 | 1ULL<<47 | 1ULL<<46 | \
                                1ULL<<45 | 1ULL<<44)
-#define MCCK_CODE_SYSTEM_DAMAGE         _BITUL(63)
+#define MCCK_CODE_SYSTEM_DAMAGE         BIT(63)
-#define MCCK_CODE_EXT_DAMAGE            _BITUL(63 - 5)
+#define MCCK_CODE_EXT_DAMAGE            BIT(63 - 5)
-#define MCCK_CODE_CP                    _BITUL(63 - 9)
+#define MCCK_CODE_CP                    BIT(63 - 9)
-#define MCCK_CODE_CPU_TIMER_VALID       _BITUL(63 - 46)
+#define MCCK_CODE_CPU_TIMER_VALID       BIT(63 - 46)
-#define MCCK_CODE_PSW_MWP_VALID         _BITUL(63 - 20)
+#define MCCK_CODE_PSW_MWP_VALID         BIT(63 - 20)
-#define MCCK_CODE_PSW_IA_VALID          _BITUL(63 - 23)
+#define MCCK_CODE_PSW_IA_VALID          BIT(63 - 23)
-#define MCCK_CODE_CR_VALID              _BITUL(63 - 29)
+#define MCCK_CODE_CR_VALID              BIT(63 - 29)
-#define MCCK_CODE_GS_VALID              _BITUL(63 - 36)
+#define MCCK_CODE_GS_VALID              BIT(63 - 36)
-#define MCCK_CODE_FC_VALID              _BITUL(63 - 43)
+#define MCCK_CODE_FC_VALID              BIT(63 - 43)
 #ifndef __ASSEMBLY__
diff --git a/arch/s390/include/asm/processor.h b/arch/s390/include/asm/processor.h
index 14883b1562e0..d56c519bc696 100644
--- a/arch/s390/include/asm/processor.h
+++ b/arch/s390/include/asm/processor.h
@@ -12,7 +12,7 @@
 #ifndef __ASM_S390_PROCESSOR_H
 #define __ASM_S390_PROCESSOR_H
-#include <linux/const.h>
+#include <linux/bits.h>
 #define CIF_MCCK_PENDING        0       /* machine check handling is pending */
 #define CIF_ASCE_PRIMARY        1       /* primary asce needs fixup / uaccess */
@@ -24,15 +24,15 @@
 #define CIF_MCCK_GUEST          7       /* machine check happening in guest */
 #define CIF_DEDICATED_CPU       8       /* this CPU is dedicated */
-#define _CIF_MCCK_PENDING       _BITUL(CIF_MCCK_PENDING)
+#define _CIF_MCCK_PENDING       BIT(CIF_MCCK_PENDING)
-#define _CIF_ASCE_PRIMARY       _BITUL(CIF_ASCE_PRIMARY)
+#define _CIF_ASCE_PRIMARY       BIT(CIF_ASCE_PRIMARY)
-#define _CIF_ASCE_SECONDARY     _BITUL(CIF_ASCE_SECONDARY)
+#define _CIF_ASCE_SECONDARY     BIT(CIF_ASCE_SECONDARY)
-#define _CIF_NOHZ_DELAY         _BITUL(CIF_NOHZ_DELAY)
+#define _CIF_NOHZ_DELAY         BIT(CIF_NOHZ_DELAY)
-#define _CIF_FPU                _BITUL(CIF_FPU)
+#define _CIF_FPU                BIT(CIF_FPU)
-#define _CIF_IGNORE_IRQ         _BITUL(CIF_IGNORE_IRQ)
+#define _CIF_IGNORE_IRQ         BIT(CIF_IGNORE_IRQ)
-#define _CIF_ENABLED_WAIT       _BITUL(CIF_ENABLED_WAIT)
+#define _CIF_ENABLED_WAIT       BIT(CIF_ENABLED_WAIT)
-#define _CIF_MCCK_GUEST         _BITUL(CIF_MCCK_GUEST)
+#define _CIF_MCCK_GUEST         BIT(CIF_MCCK_GUEST)
-#define _CIF_DEDICATED_CPU      _BITUL(CIF_DEDICATED_CPU)
+#define _CIF_DEDICATED_CPU      BIT(CIF_DEDICATED_CPU)
 #ifndef __ASSEMBLY__
diff --git a/arch/s390/include/asm/ptrace.h b/arch/s390/include/asm/ptrace.h
index 6f70d81c40f2..f009a13afe71 100644
--- a/arch/s390/include/asm/ptrace.h
+++ b/arch/s390/include/asm/ptrace.h
@@ -7,7 +7,7 @@
 #ifndef _S390_PTRACE_H
 #define _S390_PTRACE_H
-#include <linux/const.h>
+#include <linux/bits.h>
 #include <uapi/asm/ptrace.h>
 #define PIF_SYSCALL             0       /* inside a system call */
@@ -15,10 +15,10 @@
 #define PIF_SYSCALL_RESTART     2       /* restart the current system call */
 #define PIF_GUEST_FAULT         3       /* indicates program check in sie64a */
-#define _PIF_SYSCALL            _BITUL(PIF_SYSCALL)
+#define _PIF_SYSCALL            BIT(PIF_SYSCALL)
-#define _PIF_PER_TRAP           _BITUL(PIF_PER_TRAP)
+#define _PIF_PER_TRAP           BIT(PIF_PER_TRAP)
-#define _PIF_SYSCALL_RESTART    _BITUL(PIF_SYSCALL_RESTART)
+#define _PIF_SYSCALL_RESTART    BIT(PIF_SYSCALL_RESTART)
-#define _PIF_GUEST_FAULT        _BITUL(PIF_GUEST_FAULT)
+#define _PIF_GUEST_FAULT        BIT(PIF_GUEST_FAULT)
 #ifndef __ASSEMBLY__
diff --git a/arch/s390/include/asm/setup.h b/arch/s390/include/asm/setup.h
index 925889d360c1..82deb8fc8319 100644
--- a/arch/s390/include/asm/setup.h
+++ b/arch/s390/include/asm/setup.h
@@ -6,7 +6,7 @@
 #ifndef _ASM_S390_SETUP_H
 #define _ASM_S390_SETUP_H
-#include <linux/const.h>
+#include <linux/bits.h>
 #include <uapi/asm/setup.h>
 #define EP_OFFSET               0x10008
@@ -21,25 +21,25 @@
 * Machine features detected in early.c
 */
-#define MACHINE_FLAG_VM         _BITUL(0)
+#define MACHINE_FLAG_VM         BIT(0)
-#define MACHINE_FLAG_KVM        _BITUL(1)
+#define MACHINE_FLAG_KVM        BIT(1)
-#define MACHINE_FLAG_LPAR       _BITUL(2)
+#define MACHINE_FLAG_LPAR       BIT(2)
-#define MACHINE_FLAG_DIAG9C     _BITUL(3)
+#define MACHINE_FLAG_DIAG9C     BIT(3)
-#define MACHINE_FLAG_ESOP       _BITUL(4)
+#define MACHINE_FLAG_ESOP       BIT(4)
-#define MACHINE_FLAG_IDTE       _BITUL(5)
+#define MACHINE_FLAG_IDTE       BIT(5)
-#define MACHINE_FLAG_DIAG44     _BITUL(6)
+#define MACHINE_FLAG_DIAG44     BIT(6)
-#define MACHINE_FLAG_EDAT1      _BITUL(7)
+#define MACHINE_FLAG_EDAT1      BIT(7)
-#define MACHINE_FLAG_EDAT2      _BITUL(8)
+#define MACHINE_FLAG_EDAT2      BIT(8)
-#define MACHINE_FLAG_TOPOLOGY   _BITUL(10)
+#define MACHINE_FLAG_TOPOLOGY   BIT(10)
-#define MACHINE_FLAG_TE         _BITUL(11)
+#define MACHINE_FLAG_TE         BIT(11)
-#define MACHINE_FLAG_TLB_LC     _BITUL(12)
+#define MACHINE_FLAG_TLB_LC     BIT(12)
-#define MACHINE_FLAG_VX         _BITUL(13)
+#define MACHINE_FLAG_VX         BIT(13)
-#define MACHINE_FLAG_TLB_GUEST  _BITUL(14)
+#define MACHINE_FLAG_TLB_GUEST  BIT(14)
-#define MACHINE_FLAG_NX         _BITUL(15)
+#define MACHINE_FLAG_NX         BIT(15)
-#define MACHINE_FLAG_GS         _BITUL(16)
+#define MACHINE_FLAG_GS         BIT(16)
-#define MACHINE_FLAG_SCC        _BITUL(17)
+#define MACHINE_FLAG_SCC        BIT(17)
-#define LPP_MAGIC               _BITUL(31)
+#define LPP_MAGIC               BIT(31)
 #define LPP_PID_MASK            _AC(0xffffffff, UL)
 /* Offsets to entry points in kernel/head.S  */
diff --git a/arch/s390/include/asm/thread_info.h b/arch/s390/include/asm/thread_info.h
index ce4e17c9aad6..e582fbe59e20 100644
--- a/arch/s390/include/asm/thread_info.h
+++ b/arch/s390/include/asm/thread_info.h
@@ -8,7 +8,7 @@
 #ifndef _ASM_THREAD_INFO_H
 #define _ASM_THREAD_INFO_H
-#include <linux/const.h>
+#include <linux/bits.h>
 /*
 * General size of kernel stacks
@@ -82,21 +82,21 @@ void arch_setup_new_exec(void);
 #define TIF_SECCOMP             26      /* secure computing */
 #define TIF_SYSCALL_TRACEPOINT  27      /* syscall tracepoint instrumentation */
-#define _TIF_NOTIFY_RESUME      _BITUL(TIF_NOTIFY_RESUME)
+#define _TIF_NOTIFY_RESUME      BIT(TIF_NOTIFY_RESUME)
-#define _TIF_SIGPENDING         _BITUL(TIF_SIGPENDING)
+#define _TIF_SIGPENDING         BIT(TIF_SIGPENDING)
-#define _TIF_NEED_RESCHED       _BITUL(TIF_NEED_RESCHED)
+#define _TIF_NEED_RESCHED       BIT(TIF_NEED_RESCHED)
-#define _TIF_UPROBE             _BITUL(TIF_UPROBE)
+#define _TIF_UPROBE             BIT(TIF_UPROBE)
-#define _TIF_GUARDED_STORAGE    _BITUL(TIF_GUARDED_STORAGE)
+#define _TIF_GUARDED_STORAGE    BIT(TIF_GUARDED_STORAGE)
-#define _TIF_PATCH_PENDING      _BITUL(TIF_PATCH_PENDING)
+#define _TIF_PATCH_PENDING      BIT(TIF_PATCH_PENDING)
-#define _TIF_ISOLATE_BP         _BITUL(TIF_ISOLATE_BP)
+#define _TIF_ISOLATE_BP         BIT(TIF_ISOLATE_BP)
-#define _TIF_ISOLATE_BP_GUEST   _BITUL(TIF_ISOLATE_BP_GUEST)
+#define _TIF_ISOLATE_BP_GUEST   BIT(TIF_ISOLATE_BP_GUEST)
-#define _TIF_31BIT              _BITUL(TIF_31BIT)
+#define _TIF_31BIT              BIT(TIF_31BIT)
-#define _TIF_SINGLE_STEP        _BITUL(TIF_SINGLE_STEP)
+#define _TIF_SINGLE_STEP        BIT(TIF_SINGLE_STEP)
-#define _TIF_SYSCALL_TRACE      _BITUL(TIF_SYSCALL_TRACE)
+#define _TIF_SYSCALL_TRACE      BIT(TIF_SYSCALL_TRACE)
-#define _TIF_SYSCALL_AUDIT      _BITUL(TIF_SYSCALL_AUDIT)
+#define _TIF_SYSCALL_AUDIT      BIT(TIF_SYSCALL_AUDIT)
-#define _TIF_SECCOMP            _BITUL(TIF_SECCOMP)
+#define _TIF_SECCOMP            BIT(TIF_SECCOMP)
-#define _TIF_SYSCALL_TRACEPOINT _BITUL(TIF_SYSCALL_TRACEPOINT)
+#define _TIF_SYSCALL_TRACEPOINT BIT(TIF_SYSCALL_TRACEPOINT)
 #endif /* _ASM_THREAD_INFO_H */
diff --git a/arch/s390/mm/fault.c b/arch/s390/mm/fault.c
index 0ba174f779da..63507662828f 100644
--- a/arch/s390/mm/fault.c
+++ b/arch/s390/mm/fault.c
@@ -67,20 +67,6 @@ static int __init fault_init(void)
 }
 early_initcall(fault_init);
-static inline int notify_page_fault(struct pt_regs *regs)
-{
-        int ret = 0;
-        /* kprobe_running() needs smp_processor_id() */
-        if (kprobes_built_in() && !user_mode(regs)) {
-                preempt_disable();
-                if (kprobe_running() && kprobe_fault_handler(regs, 14))
-                        ret = 1;
-                preempt_enable();
-        }
-        return ret;
-}
 /*
 * Find out which address space caused the exception.
 */
@@ -412,7 +398,7 @@ static inline vm_fault_t do_exception(struct pt_regs *regs, int access)
         */
        clear_pt_regs_flag(regs, PIF_PER_TRAP);
-        if (notify_page_fault(regs))
+        if (kprobe_page_fault(regs, 14))
                return 0;
        mm = tsk->mm;
diff --git a/arch/sh/mm/fault.c b/arch/sh/mm/fault.c
index 3093bc372138..5f51456f4fc7 100644
--- a/arch/sh/mm/fault.c
+++ b/arch/sh/mm/fault.c
@@ -24,20 +24,6 @@
 #include <asm/tlbflush.h>
 #include <asm/traps.h>
-static inline int notify_page_fault(struct pt_regs *regs, int trap)
-{
-        int ret = 0;
-        if (kprobes_built_in() && !user_mode(regs)) {
-                preempt_disable();
-                if (kprobe_running() && kprobe_fault_handler(regs, trap))
-                        ret = 1;
-                preempt_enable();
-        }
-        return ret;
-}
 static void
 force_sig_info_fault(int si_signo, int si_code, unsigned long address)
 {
@@ -412,14 +398,14 @@ asmlinkage void __kprobes do_page_fault(struct pt_regs *regs,
        if (unlikely(fault_in_kernel_space(address))) {
                if (vmalloc_fault(address) >= 0)
                        return;
-                if (notify_page_fault(regs, vec))
+                if (kprobe_page_fault(regs, vec))
                        return;
                bad_area_nosemaphore(regs, error_code, address);
                return;
        }
-        if (unlikely(notify_page_fault(regs, vec)))
+        if (unlikely(kprobe_page_fault(regs, vec)))
                return;
        /* Only enable interrupts if they were on before the fault */
diff --git a/arch/sparc/include/uapi/asm/mman.h b/arch/sparc/include/uapi/asm/mman.h
index f6f99ec65bb3..cec9f4109687 100644
--- a/arch/sparc/include/uapi/asm/mman.h
+++ b/arch/sparc/include/uapi/asm/mman.h
@@ -22,10 +22,4 @@
 #define MCL_FUTURE      0x4000          /* lock all additions to address space */
 #define MCL_ONFAULT     0x8000          /* lock all pages that are faulted in */
-#define MAP_POPULATE    0x8000          /* populate (prefault) pagetables */
-#define MAP_NONBLOCK    0x10000         /* do not block on IO */
-#define MAP_STACK       0x20000         /* give out an address that is best suited for process/thread stacks */
-#define MAP_HUGETLB     0x40000         /* create a huge page mapping */
 #endif /* _UAPI__SPARC_MMAN_H__ */
diff --git a/arch/sparc/mm/fault_64.c b/arch/sparc/mm/fault_64.c
index 83fda4d9c3b2..2371fb6b97e4 100644
--- a/arch/sparc/mm/fault_64.c
+++ b/arch/sparc/mm/fault_64.c
@@ -38,20 +38,6 @@
 int show_unhandled_signals = 1;
-static inline __kprobes int notify_page_fault(struct pt_regs *regs)
-{
-        int ret = 0;
-        /* kprobe_running() needs smp_processor_id() */
-        if (kprobes_built_in() && !user_mode(regs)) {
-                preempt_disable();
-                if (kprobe_running() && kprobe_fault_handler(regs, 0))
-                        ret = 1;
-                preempt_enable();
-        }
-        return ret;
-}
 static void __kprobes unhandled_fault(unsigned long address,
                                      struct task_struct *tsk,
                                      struct pt_regs *regs)
@@ -285,7 +271,7 @@ asmlinkage void __kprobes do_sparc64_fault(struct pt_regs *regs)
        fault_code = get_thread_fault_code();
-        if (notify_page_fault(regs))
+        if (kprobe_page_fault(regs, 0))
                goto exit_exception;
        si_code = SEGV_MAPERR;
diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index 57d3b5d96bd2..1342654e8057 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -70,6 +70,7 @@ config X86
        select ARCH_HAS_KCOV                    if X86_64
        select ARCH_HAS_MEMBARRIER_SYNC_CORE
        select ARCH_HAS_PMEM_API                if X86_64
+        select ARCH_HAS_PTE_DEVMAP              if X86_64
        select ARCH_HAS_PTE_SPECIAL
        select ARCH_HAS_REFCOUNT
        select ARCH_HAS_UACCESS_FLUSHCACHE      if X86_64
@@ -80,7 +81,6 @@ config X86
        select ARCH_HAS_STRICT_MODULE_RWX
        select ARCH_HAS_SYNC_CORE_BEFORE_USERMODE
        select ARCH_HAS_UBSAN_SANITIZE_ALL
-        select ARCH_HAS_ZONE_DEVICE             if X86_64
        select ARCH_HAVE_NMI_SAFE_CMPXCHG
        select ARCH_MIGHT_HAVE_ACPI_PDC         if ACPI
        select ARCH_MIGHT_HAVE_PC_PARPORT
diff --git a/arch/x86/include/asm/io.h b/arch/x86/include/asm/io.h
index a06a9f8294ea..6bed97ff6db2 100644
--- a/arch/x86/include/asm/io.h
+++ b/arch/x86/include/asm/io.h
@@ -165,7 +165,6 @@ static inline unsigned int isa_virt_to_bus(volatile void *address)
 {
        return (unsigned int)virt_to_phys(address);
 }
-#define isa_page_to_bus(page)   ((unsigned int)page_to_phys(page))
 #define isa_bus_to_virt         phys_to_virt
 /*
diff --git a/arch/x86/include/asm/pgtable.h b/arch/x86/include/asm/pgtable.h
index 5e0509b41986..0bc530c4eb13 100644
--- a/arch/x86/include/asm/pgtable.h
+++ b/arch/x86/include/asm/pgtable.h
@@ -271,7 +271,7 @@ static inline int has_transparent_hugepage(void)
        return boot_cpu_has(X86_FEATURE_PSE);
 }
-#ifdef __HAVE_ARCH_PTE_DEVMAP
+#ifdef CONFIG_ARCH_HAS_PTE_DEVMAP
 static inline int pmd_devmap(pmd_t pmd)
 {
        return !!(pmd_val(pmd) & _PAGE_DEVMAP);
@@ -732,7 +732,7 @@ static inline int pte_present(pte_t a)
        return pte_flags(a) & (_PAGE_PRESENT | _PAGE_PROTNONE);
 }
-#ifdef __HAVE_ARCH_PTE_DEVMAP
+#ifdef CONFIG_ARCH_HAS_PTE_DEVMAP
 static inline int pte_devmap(pte_t a)
 {
        return (pte_flags(a) & _PAGE_DEVMAP) == _PAGE_DEVMAP;
diff --git a/arch/x86/include/asm/pgtable_types.h b/arch/x86/include/asm/pgtable_types.h
index d6ff0bbdb394..b5e49e6bac63 100644
--- a/arch/x86/include/asm/pgtable_types.h
+++ b/arch/x86/include/asm/pgtable_types.h
@@ -103,7 +103,6 @@
 #if defined(CONFIG_X86_64) || defined(CONFIG_X86_PAE)
 #define _PAGE_NX        (_AT(pteval_t, 1) << _PAGE_BIT_NX)
 #define _PAGE_DEVMAP    (_AT(u64, 1) << _PAGE_BIT_DEVMAP)
-#define __HAVE_ARCH_PTE_DEVMAP
 #else
 #define _PAGE_NX        (_AT(pteval_t, 0))
 #define _PAGE_DEVMAP    (_AT(pteval_t, 0))
diff --git a/arch/x86/mm/fault.c b/arch/x86/mm/fault.c
index 794f364cb882..d1634c59ed56 100644
--- a/arch/x86/mm/fault.c
+++ b/arch/x86/mm/fault.c
@@ -46,23 +46,6 @@ kmmio_fault(struct pt_regs *regs, unsigned long addr)
        return 0;
 }
-static nokprobe_inline int kprobes_fault(struct pt_regs *regs)
-{
-        if (!kprobes_built_in())
-                return 0;
-        if (user_mode(regs))
-                return 0;
-        /*
-         * To be potentially processing a kprobe fault and to be allowed to call
-         * kprobe_running(), we have to be non-preemptible.
-         */
-        if (preemptible())
-                return 0;
-        if (!kprobe_running())
-                return 0;
-        return kprobe_fault_handler(regs, X86_TRAP_PF);
-}
 /*
 * Prefetch quirks:
 *
@@ -1282,7 +1265,7 @@ do_kern_addr_fault(struct pt_regs *regs, unsigned long hw_error_code,
                return;
        /* kprobes don't want to hook the spurious faults: */
-        if (kprobes_fault(regs))
+        if (kprobe_page_fault(regs, X86_TRAP_PF))
                return;
        /*
@@ -1313,7 +1296,7 @@ void do_user_addr_fault(struct pt_regs *regs,
        mm = tsk->mm;
        /* kprobes don't want to hook the spurious faults: */
-        if (unlikely(kprobes_fault(regs)))
+        if (unlikely(kprobe_page_fault(regs, X86_TRAP_PF)))
                return;
        /*
diff --git a/arch/x86/mm/ioremap.c b/arch/x86/mm/ioremap.c
index e500f1df1140..63e99f15d7cf 100644
--- a/arch/x86/mm/ioremap.c
+++ b/arch/x86/mm/ioremap.c
@@ -459,6 +459,11 @@ void iounmap(volatile void __iomem *addr)
 }
 EXPORT_SYMBOL(iounmap);
+int __init arch_ioremap_p4d_supported(void)
+{
+        return 0;
+}
 int __init arch_ioremap_pud_supported(void)
 {
 #ifdef CONFIG_X86_64
diff --git a/arch/xtensa/include/uapi/asm/mman.h b/arch/xtensa/include/uapi/asm/mman.h
index be726062412b..ebbb48842190 100644
--- a/arch/xtensa/include/uapi/asm/mman.h
+++ b/arch/xtensa/include/uapi/asm/mman.h
@@ -56,12 +56,8 @@
 #define MAP_STACK       0x40000         /* give out an address that is best suited for process/thread stacks */
 #define MAP_HUGETLB     0x80000         /* create a huge page mapping */
 #define MAP_FIXED_NOREPLACE 0x100000    /* MAP_FIXED which doesn't unmap underlying mapping */
-#ifdef CONFIG_MMAP_ALLOW_UNINITIALIZED
+#define MAP_UNINITIALIZED 0x4000000     /* For anonymous mmap, memory could be
-# define MAP_UNINITIALIZED 0x4000000    /* For anonymous mmap, memory could be
                                         * uninitialized */
-#else
-# define MAP_UNINITIALIZED 0x0          /* Don't support this flag */
-#endif
 /*
 * Flags for msync
diff --git a/drivers/dax/dax-private.h b/drivers/dax/dax-private.h
index c915889d1769..6ccca3b890d6 100644
--- a/drivers/dax/dax-private.h
+++ b/drivers/dax/dax-private.h
@@ -43,6 +43,7 @@ struct dax_region {
 * @target_node: effective numa node if dev_dax memory range is onlined
 * @dev - device core
 * @pgmap - pgmap for memmap setup / lifetime (driver owned)
+ * @dax_mem_res: physical address range of hotadded DAX memory
 */
 struct dev_dax {
        struct dax_region *region;
@@ -50,6 +51,7 @@ struct dev_dax {
        int target_node;
        struct device dev;
        struct dev_pagemap pgmap;
+        struct resource *dax_kmem_res;
 };
 static inline struct dev_dax *to_dev_dax(struct device *dev)
diff --git a/drivers/dax/kmem.c b/drivers/dax/kmem.c
index a02318c6d28a..3d0a7e702c94 100644
--- a/drivers/dax/kmem.c
+++ b/drivers/dax/kmem.c
@@ -66,23 +66,59 @@ int dev_dax_kmem_probe(struct device *dev)
        new_res->name = dev_name(dev);
        rc = add_memory(numa_node, new_res->start, resource_size(new_res));
-        if (rc)
+        if (rc) {
+                release_resource(new_res);
+                kfree(new_res);
                return rc;
+        }
+        dev_dax->dax_kmem_res = new_res;
        return 0;
 }
+#ifdef CONFIG_MEMORY_HOTREMOVE
+static int dev_dax_kmem_remove(struct device *dev)
+{
+        struct dev_dax *dev_dax = to_dev_dax(dev);
+        struct resource *res = dev_dax->dax_kmem_res;
+        resource_size_t kmem_start = res->start;
+        resource_size_t kmem_size = resource_size(res);
+        int rc;
+        /*
+         * We have one shot for removing memory, if some memory blocks were not
+         * offline prior to calling this function remove_memory() will fail, and
+         * there is no way to hotremove this memory until reboot because device
+         * unbind will succeed even if we return failure.
+         */
+        rc = remove_memory(dev_dax->target_node, kmem_start, kmem_size);
+        if (rc) {
+                dev_err(dev,
+                        "DAX region %pR cannot be hotremoved until the next reboot\n",
+                        res);
+                return rc;
+        }
+        /* Release and free dax resources */
+        release_resource(res);
+        kfree(res);
+        dev_dax->dax_kmem_res = NULL;
+        return 0;
+}
+#else
 static int dev_dax_kmem_remove(struct device *dev)
 {
        /*
-         * Purposely leak the request_mem_region() for the device-dax
+         * Without hotremove purposely leak the request_mem_region() for the
-         * range and return '0' to ->remove() attempts. The removal of
+         * device-dax range and return '0' to ->remove() attempts. The removal
-         * the device from the driver always succeeds, but the region
+         * of the device from the driver always succeeds, but the region is
-         * is permanently pinned as reserved by the unreleased
+         * permanently pinned as reserved by the unreleased
         * request_mem_region().
         */
        return 0;
 }
+#endif /* CONFIG_MEMORY_HOTREMOVE */
 static struct dax_device_driver device_dax_kmem_driver = {
        .drv = {
diff --git a/drivers/fpga/dfl-afu-dma-region.c b/drivers/fpga/dfl-afu-dma-region.c
index dcd80b088c7b..62f924489db5 100644
--- a/drivers/fpga/dfl-afu-dma-region.c
+++ b/drivers/fpga/dfl-afu-dma-region.c
@@ -12,6 +12,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/sched/signal.h>
 #include <linux/uaccess.h>
+#include <linux/mm.h>
 #include "dfl-afu.h"
@@ -32,52 +33,6 @@ void afu_dma_region_init(struct dfl_feature_platform_data *pdata)
 }
 /**
- * afu_dma_adjust_locked_vm - adjust locked memory
- * @dev: port device
- * @npages: number of pages
- * @incr: increase or decrease locked memory
- *
- * Increase or decrease the locked memory size with npages input.
- *
- * Return 0 on success.
- * Return -ENOMEM if locked memory size is over the limit and no CAP_IPC_LOCK.
- */
-static int afu_dma_adjust_locked_vm(struct device *dev, long npages, bool incr)
-{
-        unsigned long locked, lock_limit;
-        int ret = 0;
-        /* the task is exiting. */
-        if (!current->mm)
-                return 0;
-        down_write(&current->mm->mmap_sem);
-        if (incr) {
-                locked = current->mm->locked_vm + npages;
-                lock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
-                if (locked > lock_limit && !capable(CAP_IPC_LOCK))
-                        ret = -ENOMEM;
-                else
-                        current->mm->locked_vm += npages;
-        } else {
-                if (WARN_ON_ONCE(npages > current->mm->locked_vm))
-                        npages = current->mm->locked_vm;
-                current->mm->locked_vm -= npages;
-        }
-        dev_dbg(dev, "[%d] RLIMIT_MEMLOCK %c%ld %ld/%ld%s\n", current->pid,
-                incr ? '+' : '-', npages << PAGE_SHIFT,
-                current->mm->locked_vm << PAGE_SHIFT, rlimit(RLIMIT_MEMLOCK),
-                ret ? "- exceeded" : "");
-        up_write(&current->mm->mmap_sem);
-        return ret;
-}
-/**
 * afu_dma_pin_pages - pin pages of given dma memory region
 * @pdata: feature device platform data
 * @region: dma memory region to be pinned
@@ -92,7 +47,7 @@ static int afu_dma_pin_pages(struct dfl_feature_platform_data *pdata,
        struct device *dev = &pdata->dev->dev;
        int ret, pinned;
-        ret = afu_dma_adjust_locked_vm(dev, npages, true);
+        ret = account_locked_vm(current->mm, npages, true);
        if (ret)
                return ret;
@@ -121,7 +76,7 @@ put_pages:
 free_pages:
        kfree(region->pages);
 unlock_vm:
-        afu_dma_adjust_locked_vm(dev, npages, false);
+        account_locked_vm(current->mm, npages, false);
        return ret;
 }
@@ -141,7 +96,7 @@ static void afu_dma_unpin_pages(struct dfl_feature_platform_data *pdata,
        put_all_pages(region->pages, npages);
        kfree(region->pages);
-        afu_dma_adjust_locked_vm(dev, npages, false);
+        account_locked_vm(current->mm, npages, false);
        dev_dbg(dev, "%ld pages unpinned\n", npages);
 }
diff --git a/drivers/net/wireless/mediatek/mt76/mt76x02_usb_core.c b/drivers/net/wireless/mediatek/mt76/mt76x02_usb_core.c
index 5e4f3a8c5784..e4332d5a5757 100644
--- a/drivers/net/wireless/mediatek/mt76/mt76x02_usb_core.c
+++ b/drivers/net/wireless/mediatek/mt76/mt76x02_usb_core.c
@@ -53,7 +53,7 @@ int mt76x02u_skb_dma_info(struct sk_buff *skb, int port, u32 flags)
        pad = round_up(skb->len, 4) + 4 - skb->len;
        /* First packet of a A-MSDU burst keeps track of the whole burst
-         * length, need to update lenght of it and the last packet.
+         * length, need to update length of it and the last packet.
         */
        skb_walk_frags(skb, iter) {
                last = iter;
diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c
index 3a546ec10d90..22a65ad4e46e 100644
--- a/drivers/pps/pps.c
+++ b/drivers/pps/pps.c
@@ -152,6 +152,14 @@ static long pps_cdev_ioctl(struct file *file,
                        pps->params.mode |= PPS_CANWAIT;
                pps->params.api_version = PPS_API_VERS;
+                /*
+                 * Clear unused fields of pps_kparams to avoid leaking
+                 * uninitialized data of the PPS_SETPARAMS caller via
+                 * PPS_GETPARAMS
+                 */
+                pps->params.assert_off_tu.flags = 0;
+                pps->params.clear_off_tu.flags = 0;
                spin_unlock_irq(&pps->lock);
                break;
diff --git a/drivers/rapidio/devices/rio_mport_cdev.c b/drivers/rapidio/devices/rio_mport_cdev.c
index ce7a90e68042..8155f59ece38 100644
--- a/drivers/rapidio/devices/rio_mport_cdev.c
+++ b/drivers/rapidio/devices/rio_mport_cdev.c
@@ -1686,6 +1686,7 @@ static int rio_mport_add_riodev(struct mport_cdev_priv *priv,
        if (copy_from_user(&dev_info, arg, sizeof(dev_info)))
                return -EFAULT;
+        dev_info.name[sizeof(dev_info.name) - 1] = '\0';
        rmcd_debug(RDEV, "name:%s ct:0x%x did:0x%x hc:0x%x", dev_info.name,
                   dev_info.comptag, dev_info.destid, dev_info.hopcount);
@@ -1817,6 +1818,7 @@ static int rio_mport_del_riodev(struct mport_cdev_priv *priv, void __user *arg)
        if (copy_from_user(&dev_info, arg, sizeof(dev_info)))
                return -EFAULT;
+        dev_info.name[sizeof(dev_info.name) - 1] = '\0';
        mport = priv->md->mport;
diff --git a/drivers/vfio/vfio_iommu_spapr_tce.c b/drivers/vfio/vfio_iommu_spapr_tce.c
index 7048c9198c21..8ce9ad21129f 100644
--- a/drivers/vfio/vfio_iommu_spapr_tce.c
+++ b/drivers/vfio/vfio_iommu_spapr_tce.c
@@ -19,6 +19,7 @@
 #include <linux/vmalloc.h>
 #include <linux/sched/mm.h>
 #include <linux/sched/signal.h>
+#include <linux/mm.h>
 #include <asm/iommu.h>
 #include <asm/tce.h>
@@ -31,51 +32,6 @@
 static void tce_iommu_detach_group(void *iommu_data,
                struct iommu_group *iommu_group);
-static long try_increment_locked_vm(struct mm_struct *mm, long npages)
-{
-        long ret = 0, locked, lock_limit;
-        if (WARN_ON_ONCE(!mm))
-                return -EPERM;
-        if (!npages)
-                return 0;
-        down_write(&mm->mmap_sem);
-        locked = mm->locked_vm + npages;
-        lock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
-        if (locked > lock_limit && !capable(CAP_IPC_LOCK))
-                ret = -ENOMEM;
-        else
-                mm->locked_vm += npages;
-        pr_debug("[%d] RLIMIT_MEMLOCK +%ld %ld/%ld%s\n", current->pid,
-                        npages << PAGE_SHIFT,
-                        mm->locked_vm << PAGE_SHIFT,
-                        rlimit(RLIMIT_MEMLOCK),
-                        ret ? " - exceeded" : "");
-        up_write(&mm->mmap_sem);
-        return ret;
-}
-static void decrement_locked_vm(struct mm_struct *mm, long npages)
-{
-        if (!mm || !npages)
-                return;
-        down_write(&mm->mmap_sem);
-        if (WARN_ON_ONCE(npages > mm->locked_vm))
-                npages = mm->locked_vm;
-        mm->locked_vm -= npages;
-        pr_debug("[%d] RLIMIT_MEMLOCK -%ld %ld/%ld\n", current->pid,
-                        npages << PAGE_SHIFT,
-                        mm->locked_vm << PAGE_SHIFT,
-                        rlimit(RLIMIT_MEMLOCK));
-        up_write(&mm->mmap_sem);
-}
 /*
 * VFIO IOMMU fd for SPAPR_TCE IOMMU implementation
 *
@@ -333,7 +289,7 @@ static int tce_iommu_enable(struct tce_container *container)
                return ret;
        locked = table_group->tce32_size >> PAGE_SHIFT;
-        ret = try_increment_locked_vm(container->mm, locked);
+        ret = account_locked_vm(container->mm, locked, true);
        if (ret)
                return ret;
@@ -352,7 +308,7 @@ static void tce_iommu_disable(struct tce_container *container)
        container->enabled = false;
        BUG_ON(!container->mm);
-        decrement_locked_vm(container->mm, container->locked_pages);
+        account_locked_vm(container->mm, container->locked_pages, false);
 }
 static void *tce_iommu_open(unsigned long arg)
@@ -656,7 +612,7 @@ static long tce_iommu_create_table(struct tce_container *container,
        if (!table_size)
                return -EINVAL;
-        ret = try_increment_locked_vm(container->mm, table_size >> PAGE_SHIFT);
+        ret = account_locked_vm(container->mm, table_size >> PAGE_SHIFT, true);
        if (ret)
                return ret;
@@ -675,7 +631,7 @@ static void tce_iommu_free_table(struct tce_container *container,
        unsigned long pages = tbl->it_allocated_size >> PAGE_SHIFT;
        iommu_tce_table_put(tbl);
-        decrement_locked_vm(container->mm, pages);
+        account_locked_vm(container->mm, pages, false);
 }
 static long tce_iommu_create_window(struct tce_container *container,
diff --git a/drivers/vfio/vfio_iommu_type1.c b/drivers/vfio/vfio_iommu_type1.c
index add34adfadc7..054391f30fa8 100644
--- a/drivers/vfio/vfio_iommu_type1.c
+++ b/drivers/vfio/vfio_iommu_type1.c
@@ -272,21 +272,8 @@ static int vfio_lock_acct(struct vfio_dma *dma, long npage, bool async)
        ret = down_write_killable(&mm->mmap_sem);
        if (!ret) {
-                if (npage > 0) {
+                ret = __account_locked_vm(mm, abs(npage), npage > 0, dma->task,
-                        if (!dma->lock_cap) {
+                                          dma->lock_cap);
-                                unsigned long limit;
-                                limit = task_rlimit(dma->task,
-                                                RLIMIT_MEMLOCK) >> PAGE_SHIFT;
-                                if (mm->locked_vm + npage > limit)
-                                        ret = -ENOMEM;
-                        }
-                }
-                if (!ret)
-                        mm->locked_vm += npage;
                up_write(&mm->mmap_sem);
        }
diff --git a/fs/aio.c b/fs/aio.c
index 2d405733a8c6..8327db0c8e08 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -2094,7 +2094,6 @@ SYSCALL_DEFINE6(io_pgetevents,
                const struct __aio_sigset __user *, usig)
 {
        struct __aio_sigset     ksig = { NULL, };
-        sigset_t                ksigmask, sigsaved;
        struct timespec64       ts;
        bool interrupted;
        int ret;
@@ -2105,14 +2104,14 @@ SYSCALL_DEFINE6(io_pgetevents,
        if (usig && copy_from_user(&ksig, usig, sizeof(ksig)))
                return -EFAULT;
-        ret = set_user_sigmask(ksig.sigmask, &ksigmask, &sigsaved, ksig.sigsetsize);
+        ret = set_user_sigmask(ksig.sigmask, ksig.sigsetsize);
        if (ret)
                return ret;
        ret = do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &ts : NULL);
        interrupted = signal_pending(current);
-        restore_user_sigmask(ksig.sigmask, &sigsaved, interrupted);
+        restore_saved_sigmask_unless(interrupted);
        if (interrupted && !ret)
                ret = -ERESTARTNOHAND;
@@ -2130,7 +2129,6 @@ SYSCALL_DEFINE6(io_pgetevents_time32,
                const struct __aio_sigset __user *, usig)
 {
        struct __aio_sigset     ksig = { NULL, };
-        sigset_t                ksigmask, sigsaved;
        struct timespec64       ts;
        bool interrupted;
        int ret;
@@ -2142,14 +2140,14 @@ SYSCALL_DEFINE6(io_pgetevents_time32,
                return -EFAULT;
-        ret = set_user_sigmask(ksig.sigmask, &ksigmask, &sigsaved, ksig.sigsetsize);
+        ret = set_user_sigmask(ksig.sigmask, ksig.sigsetsize);
        if (ret)
                return ret;
        ret = do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &ts : NULL);
        interrupted = signal_pending(current);
-        restore_user_sigmask(ksig.sigmask, &sigsaved, interrupted);
+        restore_saved_sigmask_unless(interrupted);
        if (interrupted && !ret)
                ret = -ERESTARTNOHAND;
@@ -2198,7 +2196,6 @@ COMPAT_SYSCALL_DEFINE6(io_pgetevents,
                const struct __compat_aio_sigset __user *, usig)
 {
        struct __compat_aio_sigset ksig = { NULL, };
-        sigset_t ksigmask, sigsaved;
        struct timespec64 t;
        bool interrupted;
        int ret;
@@ -2209,14 +2206,14 @@ COMPAT_SYSCALL_DEFINE6(io_pgetevents,
        if (usig && copy_from_user(&ksig, usig, sizeof(ksig)))
                return -EFAULT;
-        ret = set_compat_user_sigmask(ksig.sigmask, &ksigmask, &sigsaved, ksig.sigsetsize);
+        ret = set_compat_user_sigmask(ksig.sigmask, ksig.sigsetsize);
        if (ret)
                return ret;
        ret = do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &t : NULL);
        interrupted = signal_pending(current);
-        restore_user_sigmask(ksig.sigmask, &sigsaved, interrupted);
+        restore_saved_sigmask_unless(interrupted);
        if (interrupted && !ret)
                ret = -ERESTARTNOHAND;
@@ -2234,7 +2231,6 @@ COMPAT_SYSCALL_DEFINE6(io_pgetevents_time64,
                const struct __compat_aio_sigset __user *, usig)
 {
        struct __compat_aio_sigset ksig = { NULL, };
-        sigset_t ksigmask, sigsaved;
        struct timespec64 t;
        bool interrupted;
        int ret;
@@ -2245,14 +2241,14 @@ COMPAT_SYSCALL_DEFINE6(io_pgetevents_time64,
        if (usig && copy_from_user(&ksig, usig, sizeof(ksig)))
                return -EFAULT;
-        ret = set_compat_user_sigmask(ksig.sigmask, &ksigmask, &sigsaved, ksig.sigsetsize);
+        ret = set_compat_user_sigmask(ksig.sigmask, ksig.sigsetsize);
        if (ret)
                return ret;
        ret = do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &t : NULL);
        interrupted = signal_pending(current);
-        restore_user_sigmask(ksig.sigmask, &sigsaved, interrupted);
+        restore_saved_sigmask_unless(interrupted);
        if (interrupted && !ret)
                ret = -ERESTARTNOHAND;
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index 8264b468f283..d4e11b2e04f6 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -1127,7 +1127,6 @@ out_free_interp:
                          load_addr, interp_load_addr);
        if (retval < 0)
                goto out;
-        /* N.B. passed_fileno might not be initialized? */
        current->mm->end_code = end_code;
        current->mm->start_code = start_code;
        current->mm->start_data = start_data;
diff --git a/fs/binfmt_flat.c b/fs/binfmt_flat.c
index 8c6b50f34466..831a2b25ba79 100644
--- a/fs/binfmt_flat.c
+++ b/fs/binfmt_flat.c
@@ -431,7 +431,6 @@ static int load_flat_file(struct linux_binprm *bprm,
        unsigned long len, memp, memp_size, extra, rlim;
        __be32 __user *reloc;
        u32 __user *rp;
-        struct inode *inode;
        int i, rev, relocs;
        loff_t fpos;
        unsigned long start_code, end_code;
@@ -439,7 +438,6 @@ static int load_flat_file(struct linux_binprm *bprm,
        int ret;
        hdr = ((struct flat_hdr *) bprm->buf);          /* exec-header */
-        inode = file_inode(bprm->file);
        text_len  = ntohl(hdr->data_start);
        data_len  = ntohl(hdr->data_end) - ntohl(hdr->data_start);
diff --git a/fs/coda/Makefile b/fs/coda/Makefile
index 1ce66819da2a..78befb8369c9 100644
--- a/fs/coda/Makefile
+++ b/fs/coda/Makefile
@@ -6,7 +6,8 @@
 obj-$(CONFIG_CODA_FS) += coda.o
 coda-objs := psdev.o cache.o cnode.o inode.o dir.o file.o upcall.o \
-             coda_linux.o symlink.o pioctl.o sysctl.o 
+             coda_linux.o symlink.o pioctl.o
+coda-$(CONFIG_SYSCTL) += sysctl.o
 # If you want debugging output, please uncomment the following line.
diff --git a/fs/coda/cache.c b/fs/coda/cache.c
index 201fc08a8b4f..3b8c4513118f 100644
--- a/fs/coda/cache.c
+++ b/fs/coda/cache.c
@@ -21,7 +21,7 @@
 #include <linux/spinlock.h>
 #include <linux/coda.h>
-#include <linux/coda_psdev.h>
+#include "coda_psdev.h"
 #include "coda_linux.h"
 #include "coda_cache.h"
diff --git a/fs/coda/cnode.c b/fs/coda/cnode.c
index 845b5a66952a..06855f6c7902 100644
--- a/fs/coda/cnode.c
+++ b/fs/coda/cnode.c
@@ -8,8 +8,8 @@
 #include <linux/time.h>
 #include <linux/coda.h>
-#include <linux/coda_psdev.h>
 #include <linux/pagemap.h>
+#include "coda_psdev.h"
 #include "coda_linux.h"
 static inline int coda_fideq(struct CodaFid *fid1, struct CodaFid *fid2)
@@ -137,11 +137,6 @@ struct inode *coda_fid_to_inode(struct CodaFid *fid, struct super_block *sb)
        struct inode *inode;
        unsigned long hash = coda_f2i(fid);
-        if ( !sb ) {
-                pr_warn("%s: no sb!\n", __func__);
-                return NULL;
-        }
        inode = ilookup5(sb, hash, coda_test_inode, fid);
        if ( !inode )
                return NULL;
@@ -153,6 +148,16 @@ struct inode *coda_fid_to_inode(struct CodaFid *fid, struct super_block *sb)
        return inode;
 }
+struct coda_file_info *coda_ftoc(struct file *file)
+{
+        struct coda_file_info *cfi = file->private_data;
+        BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
+        return cfi;
+}
 /* the CONTROL inode is made without asking attributes from Venus */
 struct inode *coda_cnode_makectl(struct super_block *sb)
 {
diff --git a/fs/coda/coda_fs_i.h b/fs/coda/coda_fs_i.h
index d702ba1a2bf9..1763ff95d865 100644
--- a/fs/coda/coda_fs_i.h
+++ b/fs/coda/coda_fs_i.h
@@ -40,10 +40,9 @@ struct coda_file_info {
        int                cfi_magic;     /* magic number */
        struct file       *cfi_container; /* container file for this cnode */
        unsigned int       cfi_mapcount;  /* nr of times this file is mapped */
+        bool               cfi_access_intent; /* is access intent supported */
 };
-#define CODA_FTOC(file) ((struct coda_file_info *)((file)->private_data))
 /* flags */
 #define C_VATTR       0x1   /* Validity of vattr in inode */
 #define C_FLUSH       0x2   /* used after a flush */
@@ -54,6 +53,7 @@ struct inode *coda_cnode_make(struct CodaFid *, struct super_block *);
 struct inode *coda_iget(struct super_block *sb, struct CodaFid *fid, struct coda_vattr *attr);
 struct inode *coda_cnode_makectl(struct super_block *sb);
 struct inode *coda_fid_to_inode(struct CodaFid *fid, struct super_block *sb);
+struct coda_file_info *coda_ftoc(struct file *file);
 void coda_replace_fid(struct inode *, struct CodaFid *, struct CodaFid *);
 #endif
diff --git a/fs/coda/coda_int.h b/fs/coda/coda_int.h
index bb0b3e0ed6c2..f82b59c9dd28 100644
--- a/fs/coda/coda_int.h
+++ b/fs/coda/coda_int.h
@@ -13,9 +13,19 @@ extern int coda_fake_statfs;
 void coda_destroy_inodecache(void);
 int __init coda_init_inodecache(void);
 int coda_fsync(struct file *coda_file, loff_t start, loff_t end, int datasync);
+#ifdef CONFIG_SYSCTL
 void coda_sysctl_init(void);
 void coda_sysctl_clean(void);
+#else
+static inline void coda_sysctl_init(void)
+{
+}
+static inline void coda_sysctl_clean(void)
+{
+}
+#endif
 #endif  /*  _CODA_INT_  */
diff --git a/fs/coda/coda_linux.c b/fs/coda/coda_linux.c
index f3d543dd9a98..2e1a5a192074 100644
--- a/fs/coda/coda_linux.c
+++ b/fs/coda/coda_linux.c
@@ -18,7 +18,7 @@
 #include <linux/string.h>
 #include <linux/coda.h>
-#include <linux/coda_psdev.h>
+#include "coda_psdev.h"
 #include "coda_linux.h"
 /* initialize the debugging variables */
@@ -66,6 +66,25 @@ unsigned short coda_flags_to_cflags(unsigned short flags)
        return coda_flags;
 }
+static struct timespec64 coda_to_timespec64(struct coda_timespec ts)
+{
+        struct timespec64 ts64 = {
+                .tv_sec = ts.tv_sec,
+                .tv_nsec = ts.tv_nsec,
+        };
+        return ts64;
+}
+static struct coda_timespec timespec64_to_coda(struct timespec64 ts64)
+{
+        struct coda_timespec ts = {
+                .tv_sec = ts64.tv_sec,
+                .tv_nsec = ts64.tv_nsec,
+        };
+        return ts;
+}
 /* utility functions below */
 void coda_vattr_to_iattr(struct inode *inode, struct coda_vattr *attr)
@@ -105,11 +124,11 @@ void coda_vattr_to_iattr(struct inode *inode, struct coda_vattr *attr)
        if (attr->va_size != -1)
                inode->i_blocks = (attr->va_size + 511) >> 9;
        if (attr->va_atime.tv_sec != -1) 
-                inode->i_atime = timespec_to_timespec64(attr->va_atime);
+                inode->i_atime = coda_to_timespec64(attr->va_atime);
        if (attr->va_mtime.tv_sec != -1)
-                inode->i_mtime = timespec_to_timespec64(attr->va_mtime);
+                inode->i_mtime = coda_to_timespec64(attr->va_mtime);
        if (attr->va_ctime.tv_sec != -1)
-                inode->i_ctime = timespec_to_timespec64(attr->va_ctime);
+                inode->i_ctime = coda_to_timespec64(attr->va_ctime);
 }
@@ -130,12 +149,12 @@ void coda_iattr_to_vattr(struct iattr *iattr, struct coda_vattr *vattr)
        vattr->va_uid = (vuid_t) -1; 
        vattr->va_gid = (vgid_t) -1;
        vattr->va_size = (off_t) -1;
-        vattr->va_atime.tv_sec = (time_t) -1;
+        vattr->va_atime.tv_sec = (int64_t) -1;
-        vattr->va_atime.tv_nsec =  (time_t) -1;
+        vattr->va_atime.tv_nsec = (long) -1;
-        vattr->va_mtime.tv_sec = (time_t) -1;
+        vattr->va_mtime.tv_sec = (int64_t) -1;
-        vattr->va_mtime.tv_nsec = (time_t) -1;
+        vattr->va_mtime.tv_nsec = (long) -1;
-        vattr->va_ctime.tv_sec = (time_t) -1;
+        vattr->va_ctime.tv_sec = (int64_t) -1;
-        vattr->va_ctime.tv_nsec = (time_t) -1;
+        vattr->va_ctime.tv_nsec = (long) -1;
        vattr->va_type = C_VNON;
        vattr->va_fileid = -1;
        vattr->va_gen = -1;
@@ -175,13 +194,13 @@ void coda_iattr_to_vattr(struct iattr *iattr, struct coda_vattr *vattr)
                vattr->va_size = iattr->ia_size;
        }
        if ( valid & ATTR_ATIME ) {
-                vattr->va_atime = timespec64_to_timespec(iattr->ia_atime);
+                vattr->va_atime = timespec64_to_coda(iattr->ia_atime);
        }
        if ( valid & ATTR_MTIME ) {
-                vattr->va_mtime = timespec64_to_timespec(iattr->ia_mtime);
+                vattr->va_mtime = timespec64_to_coda(iattr->ia_mtime);
        }
        if ( valid & ATTR_CTIME ) {
-                vattr->va_ctime = timespec64_to_timespec(iattr->ia_ctime);
+                vattr->va_ctime = timespec64_to_coda(iattr->ia_ctime);
        }
 }
diff --git a/fs/coda/coda_linux.h b/fs/coda/coda_linux.h
index 126155cadfa9..d5ebd36fb2cc 100644
--- a/fs/coda/coda_linux.h
+++ b/fs/coda/coda_linux.h
@@ -59,22 +59,6 @@ void coda_vattr_to_iattr(struct inode *, struct coda_vattr *);
 void coda_iattr_to_vattr(struct iattr *, struct coda_vattr *);
 unsigned short coda_flags_to_cflags(unsigned short);
-/* sysctl.h */
-void coda_sysctl_init(void);
-void coda_sysctl_clean(void);
-#define CODA_ALLOC(ptr, cast, size) do { \
-    if (size < PAGE_SIZE) \
-        ptr = kzalloc((unsigned long) size, GFP_KERNEL); \
-    else \
-        ptr = (cast)vzalloc((unsigned long) size); \
-    if (!ptr) \
-        pr_warn("kernel malloc returns 0 at %s:%d\n", __FILE__, __LINE__); \
-} while (0)
-#define CODA_FREE(ptr, size) kvfree((ptr))
 /* inode to cnode access functions */
 static inline struct coda_inode_info *ITOC(struct inode *inode)
diff --git a/include/linux/coda_psdev.h b/fs/coda/coda_psdev.h
index 15170954aa2b..52da08c770b0 100644
--- a/include/linux/coda_psdev.h
+++ b/fs/coda/coda_psdev.h
@@ -3,11 +3,31 @@
 #define __CODA_PSDEV_H
 #include <linux/backing-dev.h>
+#include <linux/magic.h>
 #include <linux/mutex.h>
-#include <uapi/linux/coda_psdev.h>
+#define CODA_PSDEV_MAJOR 67
+#define MAX_CODADEVS  5    /* how many do we allow */
 struct kstatfs;
+/* messages between coda filesystem in kernel and Venus */
+struct upc_req {
+        struct list_head        uc_chain;
+        caddr_t                 uc_data;
+        u_short                 uc_flags;
+        u_short                 uc_inSize;  /* Size is at most 5000 bytes */
+        u_short                 uc_outSize;
+        u_short                 uc_opcode;  /* copied from data to save lookup */
+        int                     uc_unique;
+        wait_queue_head_t       uc_sleep;   /* process' wait queue */
+};
+#define CODA_REQ_ASYNC  0x1
+#define CODA_REQ_READ   0x2
+#define CODA_REQ_WRITE  0x4
+#define CODA_REQ_ABORT  0x8
 /* communication pending/processing queues */
 struct venus_comm {
        u_long              vc_seq;
@@ -19,7 +39,6 @@ struct venus_comm {
        struct mutex        vc_mutex;
 };
 static inline struct venus_comm *coda_vcp(struct super_block *sb)
 {
        return (struct venus_comm *)((sb)->s_fs_info);
@@ -30,39 +49,43 @@ int venus_rootfid(struct super_block *sb, struct CodaFid *fidp);
 int venus_getattr(struct super_block *sb, struct CodaFid *fid,
                  struct coda_vattr *attr);
 int venus_setattr(struct super_block *, struct CodaFid *, struct coda_vattr *);
-int venus_lookup(struct super_block *sb, struct CodaFid *fid, 
+int venus_lookup(struct super_block *sb, struct CodaFid *fid,
-                 const char *name, int length, int *type, 
+                 const char *name, int length, int *type,
                 struct CodaFid *resfid);
 int venus_close(struct super_block *sb, struct CodaFid *fid, int flags,
                kuid_t uid);
 int venus_open(struct super_block *sb, struct CodaFid *fid, int flags,
               struct file **f);
-int venus_mkdir(struct super_block *sb, struct CodaFid *dirfid, 
+int venus_mkdir(struct super_block *sb, struct CodaFid *dirfid,
-                const char *name, int length, 
+                const char *name, int length,
                struct CodaFid *newfid, struct coda_vattr *attrs);
-int venus_create(struct super_block *sb, struct CodaFid *dirfid, 
+int venus_create(struct super_block *sb, struct CodaFid *dirfid,
                 const char *name, int length, int excl, int mode,
-                 struct CodaFid *newfid, struct coda_vattr *attrs) ;
+                 struct CodaFid *newfid, struct coda_vattr *attrs);
-int venus_rmdir(struct super_block *sb, struct CodaFid *dirfid, 
+int venus_rmdir(struct super_block *sb, struct CodaFid *dirfid,
                const char *name, int length);
-int venus_remove(struct super_block *sb, struct CodaFid *dirfid, 
+int venus_remove(struct super_block *sb, struct CodaFid *dirfid,
                 const char *name, int length);
-int venus_readlink(struct super_block *sb, struct CodaFid *fid, 
+int venus_readlink(struct super_block *sb, struct CodaFid *fid,
                   char *buffer, int *length);
-int venus_rename(struct super_block *, struct CodaFid *new_fid, 
+int venus_rename(struct super_block *sb, struct CodaFid *new_fid,
-                 struct CodaFid *old_fid, size_t old_length, 
+                 struct CodaFid *old_fid, size_t old_length,
-                 size_t new_length, const char *old_name, 
+                 size_t new_length, const char *old_name,
                 const char *new_name);
-int venus_link(struct super_block *sb, struct CodaFid *fid, 
+int venus_link(struct super_block *sb, struct CodaFid *fid,
                  struct CodaFid *dirfid, const char *name, int len );
 int venus_symlink(struct super_block *sb, struct CodaFid *fid,
                  const char *name, int len, const char *symname, int symlen);
 int venus_access(struct super_block *sb, struct CodaFid *fid, int mask);
 int venus_pioctl(struct super_block *sb, struct CodaFid *fid,
                 unsigned int cmd, struct PioctlData *data);
-int coda_downcall(struct venus_comm *vcp, int opcode, union outputArgs *out);
+int coda_downcall(struct venus_comm *vcp, int opcode, union outputArgs *out,
+                  size_t nbytes);
 int venus_fsync(struct super_block *sb, struct CodaFid *fid);
 int venus_statfs(struct dentry *dentry, struct kstatfs *sfs);
+int venus_access_intent(struct super_block *sb, struct CodaFid *fid,
+                        bool *access_intent_supported,
+                        size_t count, loff_t ppos, int type);
 /*
 * Statistics
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 00876ddadb43..ca40c2556ba6 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -23,7 +23,7 @@
 #include <linux/uaccess.h>
 #include <linux/coda.h>
-#include <linux/coda_psdev.h>
+#include "coda_psdev.h"
 #include "coda_linux.h"
 #include "coda_cache.h"
@@ -47,8 +47,8 @@ static struct dentry *coda_lookup(struct inode *dir, struct dentry *entry, unsig
        int type = 0;
        if (length > CODA_MAXNAMLEN) {
-                pr_err("name too long: lookup, %s (%*s)\n",
+                pr_err("name too long: lookup, %s %zu\n",
-                       coda_i2s(dir), (int)length, name);
+                       coda_i2s(dir), length);
                return ERR_PTR(-ENAMETOOLONG);
        }
@@ -356,8 +356,7 @@ static int coda_venus_readdir(struct file *coda_file, struct dir_context *ctx)
        ino_t ino;
        int ret;
-        cfi = CODA_FTOC(coda_file);
+        cfi = coda_ftoc(coda_file);
-        BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
        host_file = cfi->cfi_container;
        cii = ITOC(file_inode(coda_file));
@@ -426,8 +425,7 @@ static int coda_readdir(struct file *coda_file, struct dir_context *ctx)
        struct file *host_file;
        int ret;
-        cfi = CODA_FTOC(coda_file);
+        cfi = coda_ftoc(coda_file);
-        BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
        host_file = cfi->cfi_container;
        if (host_file->f_op->iterate || host_file->f_op->iterate_shared) {
diff --git a/fs/coda/file.c b/fs/coda/file.c
index 1cbc1f2298ee..128d63df5bfb 100644
--- a/fs/coda/file.c
+++ b/fs/coda/file.c
@@ -20,22 +20,43 @@
 #include <linux/string.h>
 #include <linux/slab.h>
 #include <linux/uaccess.h>
+#include <linux/uio.h>
 #include <linux/coda.h>
-#include <linux/coda_psdev.h>
+#include "coda_psdev.h"
 #include "coda_linux.h"
 #include "coda_int.h"
+struct coda_vm_ops {
+        atomic_t refcnt;
+        struct file *coda_file;
+        const struct vm_operations_struct *host_vm_ops;
+        struct vm_operations_struct vm_ops;
+};
 static ssize_t
 coda_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
 {
        struct file *coda_file = iocb->ki_filp;
-        struct coda_file_info *cfi = CODA_FTOC(coda_file);
+        struct inode *coda_inode = file_inode(coda_file);
+        struct coda_file_info *cfi = coda_ftoc(coda_file);
+        loff_t ki_pos = iocb->ki_pos;
+        size_t count = iov_iter_count(to);
+        ssize_t ret;
-        BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
+        ret = venus_access_intent(coda_inode->i_sb, coda_i2f(coda_inode),
+                                  &cfi->cfi_access_intent,
+                                  count, ki_pos, CODA_ACCESS_TYPE_READ);
+        if (ret)
+                goto finish_read;
-        return vfs_iter_read(cfi->cfi_container, to, &iocb->ki_pos, 0);
+        ret = vfs_iter_read(cfi->cfi_container, to, &iocb->ki_pos, 0);
+finish_read:
+        venus_access_intent(coda_inode->i_sb, coda_i2f(coda_inode),
+                            &cfi->cfi_access_intent,
+                            count, ki_pos, CODA_ACCESS_TYPE_READ_FINISH);
+        return ret;
 }
 static ssize_t
@@ -43,13 +64,18 @@ coda_file_write_iter(struct kiocb *iocb, struct iov_iter *to)
 {
        struct file *coda_file = iocb->ki_filp;
        struct inode *coda_inode = file_inode(coda_file);
-        struct coda_file_info *cfi = CODA_FTOC(coda_file);
+        struct coda_file_info *cfi = coda_ftoc(coda_file);
-        struct file *host_file;
+        struct file *host_file = cfi->cfi_container;
+        loff_t ki_pos = iocb->ki_pos;
+        size_t count = iov_iter_count(to);
        ssize_t ret;
-        BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
+        ret = venus_access_intent(coda_inode->i_sb, coda_i2f(coda_inode),
+                                  &cfi->cfi_access_intent,
+                                  count, ki_pos, CODA_ACCESS_TYPE_WRITE);
+        if (ret)
+                goto finish_write;
-        host_file = cfi->cfi_container;
        file_start_write(host_file);
        inode_lock(coda_inode);
        ret = vfs_iter_write(cfi->cfi_container, to, &iocb->ki_pos, 0);
@@ -58,26 +84,73 @@ coda_file_write_iter(struct kiocb *iocb, struct iov_iter *to)
        coda_inode->i_mtime = coda_inode->i_ctime = current_time(coda_inode);
        inode_unlock(coda_inode);
        file_end_write(host_file);
+finish_write:
+        venus_access_intent(coda_inode->i_sb, coda_i2f(coda_inode),
+                            &cfi->cfi_access_intent,
+                            count, ki_pos, CODA_ACCESS_TYPE_WRITE_FINISH);
        return ret;
 }
+static void
+coda_vm_open(struct vm_area_struct *vma)
+{
+        struct coda_vm_ops *cvm_ops =
+                container_of(vma->vm_ops, struct coda_vm_ops, vm_ops);
+        atomic_inc(&cvm_ops->refcnt);
+        if (cvm_ops->host_vm_ops && cvm_ops->host_vm_ops->open)
+                cvm_ops->host_vm_ops->open(vma);
+}
+static void
+coda_vm_close(struct vm_area_struct *vma)
+{
+        struct coda_vm_ops *cvm_ops =
+                container_of(vma->vm_ops, struct coda_vm_ops, vm_ops);
+        if (cvm_ops->host_vm_ops && cvm_ops->host_vm_ops->close)
+                cvm_ops->host_vm_ops->close(vma);
+        if (atomic_dec_and_test(&cvm_ops->refcnt)) {
+                vma->vm_ops = cvm_ops->host_vm_ops;
+                fput(cvm_ops->coda_file);
+                kfree(cvm_ops);
+        }
+}
 static int
 coda_file_mmap(struct file *coda_file, struct vm_area_struct *vma)
 {
-        struct coda_file_info *cfi;
+        struct inode *coda_inode = file_inode(coda_file);
+        struct coda_file_info *cfi = coda_ftoc(coda_file);
+        struct file *host_file = cfi->cfi_container;
+        struct inode *host_inode = file_inode(host_file);
        struct coda_inode_info *cii;
-        struct file *host_file;
+        struct coda_vm_ops *cvm_ops;
-        struct inode *coda_inode, *host_inode;
+        loff_t ppos;
+        size_t count;
-        cfi = CODA_FTOC(coda_file);
+        int ret;
-        BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
-        host_file = cfi->cfi_container;
        if (!host_file->f_op->mmap)
                return -ENODEV;
-        coda_inode = file_inode(coda_file);
+        if (WARN_ON(coda_file != vma->vm_file))
-        host_inode = file_inode(host_file);
+                return -EIO;
+        count = vma->vm_end - vma->vm_start;
+        ppos = vma->vm_pgoff * PAGE_SIZE;
+        ret = venus_access_intent(coda_inode->i_sb, coda_i2f(coda_inode),
+                                  &cfi->cfi_access_intent,
+                                  count, ppos, CODA_ACCESS_TYPE_MMAP);
+        if (ret)
+                return ret;
+        cvm_ops = kmalloc(sizeof(struct coda_vm_ops), GFP_KERNEL);
+        if (!cvm_ops)
+                return -ENOMEM;
        cii = ITOC(coda_inode);
        spin_lock(&cii->c_lock);
@@ -89,6 +162,7 @@ coda_file_mmap(struct file *coda_file, struct vm_area_struct *vma)
         * the container file on us! */
        else if (coda_inode->i_mapping != host_inode->i_mapping) {
                spin_unlock(&cii->c_lock);
+                kfree(cvm_ops);
                return -EBUSY;
        }
@@ -97,7 +171,29 @@ coda_file_mmap(struct file *coda_file, struct vm_area_struct *vma)
        cfi->cfi_mapcount++;
        spin_unlock(&cii->c_lock);
-        return call_mmap(host_file, vma);
+        vma->vm_file = get_file(host_file);
+        ret = call_mmap(vma->vm_file, vma);
+        if (ret) {
+                /* if call_mmap fails, our caller will put coda_file so we
+                 * should drop the reference to the host_file that we got.
+                 */
+                fput(host_file);
+                kfree(cvm_ops);
+        } else {
+                /* here we add redirects for the open/close vm_operations */
+                cvm_ops->host_vm_ops = vma->vm_ops;
+                if (vma->vm_ops)
+                        cvm_ops->vm_ops = *vma->vm_ops;
+                cvm_ops->vm_ops.open = coda_vm_open;
+                cvm_ops->vm_ops.close = coda_vm_close;
+                cvm_ops->coda_file = coda_file;
+                atomic_set(&cvm_ops->refcnt, 1);
+                vma->vm_ops = &cvm_ops->vm_ops;
+        }
+        return ret;
 }
 int coda_open(struct inode *coda_inode, struct file *coda_file)
@@ -127,6 +223,8 @@ int coda_open(struct inode *coda_inode, struct file *coda_file)
        cfi->cfi_magic = CODA_MAGIC;
        cfi->cfi_mapcount = 0;
        cfi->cfi_container = host_file;
+        /* assume access intents are supported unless we hear otherwise */
+        cfi->cfi_access_intent = true;
        BUG_ON(coda_file->private_data != NULL);
        coda_file->private_data = cfi;
@@ -142,8 +240,7 @@ int coda_release(struct inode *coda_inode, struct file *coda_file)
        struct inode *host_inode;
        int err;
-        cfi = CODA_FTOC(coda_file);
+        cfi = coda_ftoc(coda_file);
-        BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
        err = venus_close(coda_inode->i_sb, coda_i2f(coda_inode),
                          coda_flags, coda_file->f_cred->fsuid);
@@ -185,8 +282,7 @@ int coda_fsync(struct file *coda_file, loff_t start, loff_t end, int datasync)
                return err;
        inode_lock(coda_inode);
-        cfi = CODA_FTOC(coda_file);
+        cfi = coda_ftoc(coda_file);
-        BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
        host_file = cfi->cfi_container;
        err = vfs_fsync(host_file, datasync);
@@ -207,4 +303,3 @@ const struct file_operations coda_file_operations = {
        .fsync          = coda_fsync,
        .splice_read    = generic_file_splice_read,
 };
diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index 23f6ebd08e80..321f56e487cb 100644
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -27,7 +27,7 @@
 #include <linux/vmalloc.h>
 #include <linux/coda.h>
-#include <linux/coda_psdev.h>
+#include "coda_psdev.h"
 #include "coda_linux.h"
 #include "coda_cache.h"
@@ -236,6 +236,7 @@ static void coda_put_super(struct super_block *sb)
        vcp->vc_sb = NULL;
        sb->s_fs_info = NULL;
        mutex_unlock(&vcp->vc_mutex);
+        mutex_destroy(&vcp->vc_mutex);
        pr_info("Bye bye.\n");
 }
diff --git a/fs/coda/pioctl.c b/fs/coda/pioctl.c
index e0c17b7dccce..644d48c12ce8 100644
--- a/fs/coda/pioctl.c
+++ b/fs/coda/pioctl.c
@@ -20,8 +20,7 @@
 #include <linux/uaccess.h>
 #include <linux/coda.h>
-#include <linux/coda_psdev.h>
+#include "coda_psdev.h"
 #include "coda_linux.h"
 /* pioctl ops */
diff --git a/fs/coda/psdev.c b/fs/coda/psdev.c
index 0ceef32e6fae..240669f51eac 100644
--- a/fs/coda/psdev.c
+++ b/fs/coda/psdev.c
@@ -38,8 +38,7 @@
 #include <linux/uaccess.h>
 #include <linux/coda.h>
-#include <linux/coda_psdev.h>
+#include "coda_psdev.h"
 #include "coda_linux.h"
 #include "coda_int.h"
@@ -100,8 +99,12 @@ static ssize_t coda_psdev_write(struct file *file, const char __user *buf,
        ssize_t retval = 0, count = 0;
        int error;
+        /* make sure there is enough to copy out the (opcode, unique) values */
+        if (nbytes < (2 * sizeof(u_int32_t)))
+                return -EINVAL;
        /* Peek at the opcode, uniquefier */
-        if (copy_from_user(&hdr, buf, 2 * sizeof(u_long)))
+        if (copy_from_user(&hdr, buf, 2 * sizeof(u_int32_t)))
                return -EFAULT;
        if (DOWNCALL(hdr.opcode)) {
@@ -119,17 +122,21 @@ static ssize_t coda_psdev_write(struct file *file, const char __user *buf,
                                hdr.opcode, hdr.unique);
                        nbytes = size;
                }
-                CODA_ALLOC(dcbuf, union outputArgs *, nbytes);
+                dcbuf = kvmalloc(nbytes, GFP_KERNEL);
+                if (!dcbuf) {
+                        retval = -ENOMEM;
+                        goto out;
+                }
                if (copy_from_user(dcbuf, buf, nbytes)) {
-                        CODA_FREE(dcbuf, nbytes);
+                        kvfree(dcbuf);
                        retval = -EFAULT;
                        goto out;
                }
                /* what downcall errors does Venus handle ? */
-                error = coda_downcall(vcp, hdr.opcode, dcbuf);
+                error = coda_downcall(vcp, hdr.opcode, dcbuf, nbytes);
-                CODA_FREE(dcbuf, nbytes);
+                kvfree(dcbuf);
                if (error) {
                        pr_warn("%s: coda_downcall error: %d\n",
                                __func__, error);
@@ -182,8 +189,11 @@ static ssize_t coda_psdev_write(struct file *file, const char __user *buf,
        if (req->uc_opcode == CODA_OPEN_BY_FD) {
                struct coda_open_by_fd_out *outp =
                        (struct coda_open_by_fd_out *)req->uc_data;
-                if (!outp->oh.result)
+                if (!outp->oh.result) {
                        outp->fh = fget(outp->fd);
+                        if (!outp->fh)
+                                return -EBADF;
+                }
        }
        wake_up(&req->uc_sleep);
@@ -252,7 +262,7 @@ static ssize_t coda_psdev_read(struct file * file, char __user * buf,
                goto out;
        }
-        CODA_FREE(req->uc_data, sizeof(struct coda_in_hdr));
+        kvfree(req->uc_data);
        kfree(req);
 out:
        mutex_unlock(&vcp->vc_mutex);
@@ -314,7 +324,7 @@ static int coda_psdev_release(struct inode * inode, struct file * file)
                /* Async requests need to be freed here */
                if (req->uc_flags & CODA_REQ_ASYNC) {
-                        CODA_FREE(req->uc_data, sizeof(struct coda_in_hdr));
+                        kvfree(req->uc_data);
                        kfree(req);
                        continue;
                }
@@ -347,13 +357,13 @@ static const struct file_operations coda_psdev_fops = {
        .llseek         = noop_llseek,
 };
-static int init_coda_psdev(void)
+static int __init init_coda_psdev(void)
 {
        int i, err = 0;
        if (register_chrdev(CODA_PSDEV_MAJOR, "coda", &coda_psdev_fops)) {
                pr_err("%s: unable to get major %d\n",
                       __func__, CODA_PSDEV_MAJOR);
-              return -EIO;
+                return -EIO;
        }
        coda_psdev_class = class_create(THIS_MODULE, "coda");
        if (IS_ERR(coda_psdev_class)) {
@@ -378,7 +388,7 @@ MODULE_AUTHOR("Jan Harkes, Peter J. Braam");
 MODULE_DESCRIPTION("Coda Distributed File System VFS interface");
 MODULE_ALIAS_CHARDEV_MAJOR(CODA_PSDEV_MAJOR);
 MODULE_LICENSE("GPL");
-MODULE_VERSION("6.6");
+MODULE_VERSION("7.0");
 static int __init init_coda(void)
 {
diff --git a/fs/coda/symlink.c b/fs/coda/symlink.c
index 202297d156df..8907d0508198 100644
--- a/fs/coda/symlink.c
+++ b/fs/coda/symlink.c
@@ -17,8 +17,7 @@
 #include <linux/pagemap.h>
 #include <linux/coda.h>
-#include <linux/coda_psdev.h>
+#include "coda_psdev.h"
 #include "coda_linux.h"
 static int coda_symlink_filler(struct file *file, struct page *page)
diff --git a/fs/coda/sysctl.c b/fs/coda/sysctl.c
index 0301d45000a8..fda3b702b1c5 100644
--- a/fs/coda/sysctl.c
+++ b/fs/coda/sysctl.c
@@ -12,7 +12,6 @@
 #include "coda_int.h"
-#ifdef CONFIG_SYSCTL
 static struct ctl_table_header *fs_table_header;
 static struct ctl_table coda_table[] = {
@@ -62,13 +61,3 @@ void coda_sysctl_clean(void)
                fs_table_header = NULL;
        }
 }
-#else
-void coda_sysctl_init(void)
-{
-}
-void coda_sysctl_clean(void)
-{
-}
-#endif
diff --git a/fs/coda/upcall.c b/fs/coda/upcall.c
index 1175a1722411..eb3b1898da46 100644
--- a/fs/coda/upcall.c
+++ b/fs/coda/upcall.c
@@ -33,7 +33,7 @@
 #include <linux/vfs.h>
 #include <linux/coda.h>
-#include <linux/coda_psdev.h>
+#include "coda_psdev.h"
 #include "coda_linux.h"
 #include "coda_cache.h"
@@ -46,7 +46,7 @@ static void *alloc_upcall(int opcode, int size)
 {
        union inputArgs *inp;
-        CODA_ALLOC(inp, union inputArgs *, size);
+        inp = kvzalloc(size, GFP_KERNEL);
        if (!inp)
                return ERR_PTR(-ENOMEM);
@@ -85,7 +85,7 @@ int venus_rootfid(struct super_block *sb, struct CodaFid *fidp)
        if (!error)
                *fidp = outp->coda_root.VFid;
-        CODA_FREE(inp, insize);
+        kvfree(inp);
        return error;
 }
@@ -104,7 +104,7 @@ int venus_getattr(struct super_block *sb, struct CodaFid *fid,
        if (!error)
                *attr = outp->coda_getattr.attr;
-        CODA_FREE(inp, insize);
+        kvfree(inp);
        return error;
 }
@@ -123,7 +123,7 @@ int venus_setattr(struct super_block *sb, struct CodaFid *fid,
        error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
-        CODA_FREE(inp, insize);
+        kvfree(inp);
        return error;
 }
@@ -153,7 +153,7 @@ int venus_lookup(struct super_block *sb, struct CodaFid *fid,
                *type = outp->coda_lookup.vtype;
        }
-        CODA_FREE(inp, insize);
+        kvfree(inp);
        return error;
 }
@@ -173,7 +173,7 @@ int venus_close(struct super_block *sb, struct CodaFid *fid, int flags,
        error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
-        CODA_FREE(inp, insize);
+        kvfree(inp);
        return error;
 }
@@ -194,7 +194,7 @@ int venus_open(struct super_block *sb, struct CodaFid *fid,
        if (!error)
                *fh = outp->coda_open_by_fd.fh;
-        CODA_FREE(inp, insize);
+        kvfree(inp);
        return error;
 }       
@@ -224,7 +224,7 @@ int venus_mkdir(struct super_block *sb, struct CodaFid *dirfid,
                *newfid = outp->coda_mkdir.VFid;
        }
-        CODA_FREE(inp, insize);
+        kvfree(inp);
        return error;        
 }
@@ -262,7 +262,7 @@ int venus_rename(struct super_block *sb, struct CodaFid *old_fid,
        error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
-        CODA_FREE(inp, insize);
+        kvfree(inp);
        return error;
 }
@@ -295,7 +295,7 @@ int venus_create(struct super_block *sb, struct CodaFid *dirfid,
                *newfid = outp->coda_create.VFid;
        }
-        CODA_FREE(inp, insize);
+        kvfree(inp);
        return error;        
 }
@@ -318,7 +318,7 @@ int venus_rmdir(struct super_block *sb, struct CodaFid *dirfid,
        error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
-        CODA_FREE(inp, insize);
+        kvfree(inp);
        return error;
 }
@@ -340,7 +340,7 @@ int venus_remove(struct super_block *sb, struct CodaFid *dirfid,
        error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
-        CODA_FREE(inp, insize);
+        kvfree(inp);
        return error;
 }
@@ -370,7 +370,7 @@ int venus_readlink(struct super_block *sb, struct CodaFid *fid,
                *(buffer + retlen) = '\0';
        }
-        CODA_FREE(inp, insize);
+        kvfree(inp);
        return error;
 }
@@ -398,7 +398,7 @@ int venus_link(struct super_block *sb, struct CodaFid *fid,
        error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
-        CODA_FREE(inp, insize);
+        kvfree(inp);
        return error;
 }
@@ -433,7 +433,7 @@ int venus_symlink(struct super_block *sb, struct CodaFid *fid,
        error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
-        CODA_FREE(inp, insize);
+        kvfree(inp);
        return error;
 }
@@ -449,7 +449,7 @@ int venus_fsync(struct super_block *sb, struct CodaFid *fid)
        inp->coda_fsync.VFid = *fid;
        error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
-        CODA_FREE(inp, insize);
+        kvfree(inp);
        return error;
 }
@@ -467,7 +467,7 @@ int venus_access(struct super_block *sb, struct CodaFid *fid, int mask)
        error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
-        CODA_FREE(inp, insize);
+        kvfree(inp);
        return error;
 }
@@ -543,7 +543,7 @@ int venus_pioctl(struct super_block *sb, struct CodaFid *fid,
        }
 exit:
-        CODA_FREE(inp, insize);
+        kvfree(inp);
        return error;
 }
@@ -553,7 +553,7 @@ int venus_statfs(struct dentry *dentry, struct kstatfs *sfs)
        union outputArgs *outp;
        int insize, outsize, error;
        
-        insize = max_t(unsigned int, INSIZE(statfs), OUTSIZE(statfs));
+        insize = SIZE(statfs);
        UPARG(CODA_STATFS);
        error = coda_upcall(coda_vcp(dentry->d_sb), insize, &outsize, inp);
@@ -565,10 +565,51 @@ int venus_statfs(struct dentry *dentry, struct kstatfs *sfs)
                sfs->f_ffree  = outp->coda_statfs.stat.f_ffree;
        }
-        CODA_FREE(inp, insize);
+        kvfree(inp);
        return error;
 }
+int venus_access_intent(struct super_block *sb, struct CodaFid *fid,
+                        bool *access_intent_supported,
+                        size_t count, loff_t ppos, int type)
+{
+        union inputArgs *inp;
+        union outputArgs *outp;
+        int insize, outsize, error;
+        bool finalizer =
+                type == CODA_ACCESS_TYPE_READ_FINISH ||
+                type == CODA_ACCESS_TYPE_WRITE_FINISH;
+        if (!*access_intent_supported && !finalizer)
+                return 0;
+        insize = SIZE(access_intent);
+        UPARG(CODA_ACCESS_INTENT);
+        inp->coda_access_intent.VFid = *fid;
+        inp->coda_access_intent.count = count;
+        inp->coda_access_intent.pos = ppos;
+        inp->coda_access_intent.type = type;
+        error = coda_upcall(coda_vcp(sb), insize,
+                            finalizer ? NULL : &outsize, inp);
+        /*
+         * we have to free the request buffer for synchronous upcalls
+         * or when asynchronous upcalls fail, but not when asynchronous
+         * upcalls succeed
+         */
+        if (!finalizer || error)
+                kvfree(inp);
+        /* Chunked access is not supported or an old Coda client */
+        if (error == -EOPNOTSUPP) {
+                *access_intent_supported = false;
+                error = 0;
+        }
+        return error;
+}
 /*
 * coda_upcall and coda_downcall routines.
 */
@@ -598,10 +639,12 @@ static void coda_unblock_signals(sigset_t *old)
 * has seen them,
 * - CODA_CLOSE or CODA_RELEASE upcall  (to avoid reference count problems)
 * - CODA_STORE                         (to avoid data loss)
+ * - CODA_ACCESS_INTENT                 (to avoid reference count problems)
 */
 #define CODA_INTERRUPTIBLE(r) (!coda_hard && \
                               (((r)->uc_opcode != CODA_CLOSE && \
                                 (r)->uc_opcode != CODA_STORE && \
+                                 (r)->uc_opcode != CODA_ACCESS_INTENT && \
                                 (r)->uc_opcode != CODA_RELEASE) || \
                                (r)->uc_flags & CODA_REQ_READ))
@@ -687,21 +730,25 @@ static int coda_upcall(struct venus_comm *vcp,
                goto exit;
        }
+        buffer->ih.unique = ++vcp->vc_seq;
        req->uc_data = (void *)buffer;
-        req->uc_flags = 0;
+        req->uc_flags = outSize ? 0 : CODA_REQ_ASYNC;
        req->uc_inSize = inSize;
-        req->uc_outSize = *outSize ? *outSize : inSize;
+        req->uc_outSize = (outSize && *outSize) ? *outSize : inSize;
-        req->uc_opcode = ((union inputArgs *)buffer)->ih.opcode;
+        req->uc_opcode = buffer->ih.opcode;
-        req->uc_unique = ++vcp->vc_seq;
+        req->uc_unique = buffer->ih.unique;
        init_waitqueue_head(&req->uc_sleep);
-        /* Fill in the common input args. */
-        ((union inputArgs *)buffer)->ih.unique = req->uc_unique;
        /* Append msg to pending queue and poke Venus. */
        list_add_tail(&req->uc_chain, &vcp->vc_pending);
        wake_up_interruptible(&vcp->vc_waitq);
+        if (req->uc_flags & CODA_REQ_ASYNC) {
+                mutex_unlock(&vcp->vc_mutex);
+                return 0;
+        }
        /* We can be interrupted while we wait for Venus to process
         * our request.  If the interrupt occurs before Venus has read
         * the request, we dequeue and return. If it occurs after the
@@ -743,20 +790,20 @@ static int coda_upcall(struct venus_comm *vcp,
        sig_req = kmalloc(sizeof(struct upc_req), GFP_KERNEL);
        if (!sig_req) goto exit;
-        CODA_ALLOC((sig_req->uc_data), char *, sizeof(struct coda_in_hdr));
+        sig_inputArgs = kvzalloc(sizeof(struct coda_in_hdr), GFP_KERNEL);
-        if (!sig_req->uc_data) {
+        if (!sig_inputArgs) {
                kfree(sig_req);
                goto exit;
        }
        error = -EINTR;
-        sig_inputArgs = (union inputArgs *)sig_req->uc_data;
        sig_inputArgs->ih.opcode = CODA_SIGNAL;
        sig_inputArgs->ih.unique = req->uc_unique;
        sig_req->uc_flags = CODA_REQ_ASYNC;
        sig_req->uc_opcode = sig_inputArgs->ih.opcode;
        sig_req->uc_unique = sig_inputArgs->ih.unique;
+        sig_req->uc_data = (void *)sig_inputArgs;
        sig_req->uc_inSize = sizeof(struct coda_in_hdr);
        sig_req->uc_outSize = sizeof(struct coda_in_hdr);
@@ -804,12 +851,44 @@ exit:
 *
 * CODA_REPLACE -- replace one CodaFid with another throughout the name cache */
-int coda_downcall(struct venus_comm *vcp, int opcode, union outputArgs *out)
+int coda_downcall(struct venus_comm *vcp, int opcode, union outputArgs *out,
+                  size_t nbytes)
 {
        struct inode *inode = NULL;
        struct CodaFid *fid = NULL, *newfid;
        struct super_block *sb;
+        /*
+         * Make sure we have received enough data from the cache
+         * manager to populate the necessary fields in the buffer
+         */
+        switch (opcode) {
+        case CODA_PURGEUSER:
+                if (nbytes < sizeof(struct coda_purgeuser_out))
+                        return -EINVAL;
+                break;
+        case CODA_ZAPDIR:
+                if (nbytes < sizeof(struct coda_zapdir_out))
+                        return -EINVAL;
+                break;
+        case CODA_ZAPFILE:
+                if (nbytes < sizeof(struct coda_zapfile_out))
+                        return -EINVAL;
+                break;
+        case CODA_PURGEFID:
+                if (nbytes < sizeof(struct coda_purgefid_out))
+                        return -EINVAL;
+                break;
+        case CODA_REPLACE:
+                if (nbytes < sizeof(struct coda_replace_out))
+                        return -EINVAL;
+                break;
+        }
        /* Handle invalidation requests. */
        mutex_lock(&vcp->vc_mutex);
        sb = vcp->vc_sb;
@@ -879,4 +958,3 @@ unlock_out:
        iput(inode);
        return 0;
 }
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index 4c74c768ae43..0f9c073d78d5 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -2313,19 +2313,17 @@ SYSCALL_DEFINE6(epoll_pwait, int, epfd, struct epoll_event __user *, events,
                size_t, sigsetsize)
 {
        int error;
-        sigset_t ksigmask, sigsaved;
        /*
         * If the caller wants a certain signal mask to be set during the wait,
         * we apply it here.
         */
-        error = set_user_sigmask(sigmask, &ksigmask, &sigsaved, sigsetsize);
+        error = set_user_sigmask(sigmask, sigsetsize);
        if (error)
                return error;
        error = do_epoll_wait(epfd, events, maxevents, timeout);
+        restore_saved_sigmask_unless(error == -EINTR);
-        restore_user_sigmask(sigmask, &sigsaved, error == -EINTR);
        return error;
 }
@@ -2338,19 +2336,17 @@ COMPAT_SYSCALL_DEFINE6(epoll_pwait, int, epfd,
                        compat_size_t, sigsetsize)
 {
        long err;
-        sigset_t ksigmask, sigsaved;
        /*
         * If the caller wants a certain signal mask to be set during the wait,
         * we apply it here.
         */
-        err = set_compat_user_sigmask(sigmask, &ksigmask, &sigsaved, sigsetsize);
+        err = set_compat_user_sigmask(sigmask, sigsetsize);
        if (err)
                return err;
        err = do_epoll_wait(epfd, events, maxevents, timeout);
+        restore_saved_sigmask_unless(err == -EINTR);
-        restore_user_sigmask(sigmask, &sigsaved, err == -EINTR);
        return err;
 }
diff --git a/fs/hfsplus/xattr.c b/fs/hfsplus/xattr.c
index d5403b4004c9..bb0b27d88e50 100644
--- a/fs/hfsplus/xattr.c
+++ b/fs/hfsplus/xattr.c
@@ -407,7 +407,7 @@ static int copy_name(char *buffer, const char *xattr_name, int name_len)
        int offset = 0;
        if (!is_known_namespace(xattr_name)) {
-                strncpy(buffer, XATTR_MAC_OSX_PREFIX, XATTR_MAC_OSX_PREFIX_LEN);
+                memcpy(buffer, XATTR_MAC_OSX_PREFIX, XATTR_MAC_OSX_PREFIX_LEN);
                offset += XATTR_MAC_OSX_PREFIX_LEN;
                len += XATTR_MAC_OSX_PREFIX_LEN;
        }
diff --git a/fs/io_uring.c b/fs/io_uring.c
index d682049c07b2..e2a66e12fbc6 100644
--- a/fs/io_uring.c
+++ b/fs/io_uring.c
@@ -2400,7 +2400,6 @@ static int io_cqring_wait(struct io_ring_ctx *ctx, int min_events,
                          const sigset_t __user *sig, size_t sigsz)
 {
        struct io_cq_ring *ring = ctx->cq_ring;
-        sigset_t ksigmask, sigsaved;
        int ret;
        if (io_cqring_events(ring) >= min_events)
@@ -2410,21 +2409,17 @@ static int io_cqring_wait(struct io_ring_ctx *ctx, int min_events,
 #ifdef CONFIG_COMPAT
                if (in_compat_syscall())
                        ret = set_compat_user_sigmask((const compat_sigset_t __user *)sig,
-                                                      &ksigmask, &sigsaved, sigsz);
+                                                      sigsz);
                else
 #endif
-                        ret = set_user_sigmask(sig, &ksigmask,
+                        ret = set_user_sigmask(sig, sigsz);
-                                               &sigsaved, sigsz);
                if (ret)
                        return ret;
        }
        ret = wait_event_interruptible(ctx->wait, io_cqring_events(ring) >= min_events);
+        restore_saved_sigmask_unless(ret == -ERESTARTSYS);
-        if (sig)
-                restore_user_sigmask(sig, &sigsaved, ret == -ERESTARTSYS);
        if (ret == -ERESTARTSYS)
                ret = -EINTR;
diff --git a/fs/proc/Kconfig b/fs/proc/Kconfig
index 47d2651fd9dc..cb5629bd5fff 100644
--- a/fs/proc/Kconfig
+++ b/fs/proc/Kconfig
@@ -58,7 +58,8 @@ config PROC_VMCORE_DEVICE_DUMP
          snapshot.
          If you say Y here, the collected device dumps will be added
-          as ELF notes to /proc/vmcore.
+          as ELF notes to /proc/vmcore. You can still disable device
+          dump using the kernel command line option 'novmcoredd'.
 config PROC_SYSCTL
        bool "Sysctl support (/proc/sys)" if EXPERT
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 5f8d215b3fd0..dbe43a50caf2 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -200,7 +200,8 @@ static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence)
        struct proc_dir_entry *pde = PDE(file_inode(file));
        loff_t rv = -EINVAL;
        if (use_pde(pde)) {
-                loff_t (*llseek)(struct file *, loff_t, int);
+                typeof_member(struct file_operations, llseek) llseek;
                llseek = pde->proc_fops->llseek;
                if (!llseek)
                        llseek = default_llseek;
@@ -212,10 +213,11 @@ static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence)
 static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 {
-        ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
        struct proc_dir_entry *pde = PDE(file_inode(file));
        ssize_t rv = -EIO;
        if (use_pde(pde)) {
+                typeof_member(struct file_operations, read) read;
                read = pde->proc_fops->read;
                if (read)
                        rv = read(file, buf, count, ppos);
@@ -226,10 +228,11 @@ static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count,
 static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 {
-        ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
        struct proc_dir_entry *pde = PDE(file_inode(file));
        ssize_t rv = -EIO;
        if (use_pde(pde)) {
+                typeof_member(struct file_operations, write) write;
                write = pde->proc_fops->write;
                if (write)
                        rv = write(file, buf, count, ppos);
@@ -242,8 +245,9 @@ static __poll_t proc_reg_poll(struct file *file, struct poll_table_struct *pts)
 {
        struct proc_dir_entry *pde = PDE(file_inode(file));
        __poll_t rv = DEFAULT_POLLMASK;
-        __poll_t (*poll)(struct file *, struct poll_table_struct *);
        if (use_pde(pde)) {
+                typeof_member(struct file_operations, poll) poll;
                poll = pde->proc_fops->poll;
                if (poll)
                        rv = poll(file, pts);
@@ -256,8 +260,9 @@ static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigne
 {
        struct proc_dir_entry *pde = PDE(file_inode(file));
        long rv = -ENOTTY;
-        long (*ioctl)(struct file *, unsigned int, unsigned long);
        if (use_pde(pde)) {
+                typeof_member(struct file_operations, unlocked_ioctl) ioctl;
                ioctl = pde->proc_fops->unlocked_ioctl;
                if (ioctl)
                        rv = ioctl(file, cmd, arg);
@@ -271,8 +276,9 @@ static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned
 {
        struct proc_dir_entry *pde = PDE(file_inode(file));
        long rv = -ENOTTY;
-        long (*compat_ioctl)(struct file *, unsigned int, unsigned long);
        if (use_pde(pde)) {
+                typeof_member(struct file_operations, compat_ioctl) compat_ioctl;
                compat_ioctl = pde->proc_fops->compat_ioctl;
                if (compat_ioctl)
                        rv = compat_ioctl(file, cmd, arg);
@@ -286,8 +292,9 @@ static int proc_reg_mmap(struct file *file, struct vm_area_struct *vma)
 {
        struct proc_dir_entry *pde = PDE(file_inode(file));
        int rv = -EIO;
-        int (*mmap)(struct file *, struct vm_area_struct *);
        if (use_pde(pde)) {
+                typeof_member(struct file_operations, mmap) mmap;
                mmap = pde->proc_fops->mmap;
                if (mmap)
                        rv = mmap(file, vma);
@@ -305,7 +312,7 @@ proc_reg_get_unmapped_area(struct file *file, unsigned long orig_addr,
        unsigned long rv = -EIO;
        if (use_pde(pde)) {
-                typeof(proc_reg_get_unmapped_area) *get_area;
+                typeof_member(struct file_operations, get_unmapped_area) get_area;
                get_area = pde->proc_fops->get_unmapped_area;
 #ifdef CONFIG_MMU
@@ -326,8 +333,8 @@ static int proc_reg_open(struct inode *inode, struct file *file)
 {
        struct proc_dir_entry *pde = PDE(inode);
        int rv = 0;
-        int (*open)(struct inode *, struct file *);
+        typeof_member(struct file_operations, open) open;
-        int (*release)(struct inode *, struct file *);
+        typeof_member(struct file_operations, release) release;
        struct pde_opener *pdeo;
        /*
diff --git a/fs/proc/proc_sysctl.c b/fs/proc/proc_sysctl.c
index c74570736b24..36ad1b0d6259 100644
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -499,6 +499,10 @@ static struct inode *proc_sys_make_inode(struct super_block *sb,
        if (root->set_ownership)
                root->set_ownership(head, table, &inode->i_uid, &inode->i_gid);
+        else {
+                inode->i_uid = GLOBAL_ROOT_UID;
+                inode->i_gid = GLOBAL_ROOT_GID;
+        }
        return inode;
 }
diff --git a/fs/proc/vmcore.c b/fs/proc/vmcore.c
index 57957c91c6df..7bcc92add72c 100644
--- a/fs/proc/vmcore.c
+++ b/fs/proc/vmcore.c
@@ -21,6 +21,7 @@
 #include <linux/init.h>
 #include <linux/crash_dump.h>
 #include <linux/list.h>
+#include <linux/moduleparam.h>
 #include <linux/mutex.h>
 #include <linux/vmalloc.h>
 #include <linux/pagemap.h>
@@ -54,6 +55,9 @@ static struct proc_dir_entry *proc_vmcore;
 /* Device Dump list and mutex to synchronize access to list */
 static LIST_HEAD(vmcoredd_list);
 static DEFINE_MUTEX(vmcoredd_mutex);
+static bool vmcoredd_disabled;
+core_param(novmcoredd, vmcoredd_disabled, bool, 0);
 #endif /* CONFIG_PROC_VMCORE_DEVICE_DUMP */
 /* Device Dump Size */
@@ -1452,6 +1456,11 @@ int vmcore_add_device_dump(struct vmcoredd_data *data)
        size_t data_size;
        int ret;
+        if (vmcoredd_disabled) {
+                pr_err_once("Device dump is disabled\n");
+                return -EINVAL;
+        }
        if (!data || !strlen(data->dump_name) ||
            !data->vmcoredd_callback || !data->size)
                return -EINVAL;
diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c
index 36346dc4cec0..4517a1394c6f 100644
--- a/fs/reiserfs/journal.c
+++ b/fs/reiserfs/journal.c
@@ -94,7 +94,7 @@ static int journal_join(struct reiserfs_transaction_handle *th,
                        struct super_block *sb);
 static void release_journal_dev(struct super_block *super,
                               struct reiserfs_journal *journal);
-static int dirty_one_transaction(struct super_block *s,
+static void dirty_one_transaction(struct super_block *s,
                                 struct reiserfs_journal_list *jl);
 static void flush_async_commits(struct work_struct *work);
 static void queue_log_writer(struct super_block *s);
@@ -1682,12 +1682,11 @@ next:
 }
 /* used by flush_commit_list */
-static int dirty_one_transaction(struct super_block *s,
+static void dirty_one_transaction(struct super_block *s,
                                 struct reiserfs_journal_list *jl)
 {
        struct reiserfs_journal_cnode *cn;
        struct reiserfs_journal_list *pjl;
-        int ret = 0;
        jl->j_state |= LIST_DIRTY;
        cn = jl->j_realblock;
@@ -1716,7 +1715,6 @@ static int dirty_one_transaction(struct super_block *s,
                }
                cn = cn->next;
        }
-        return ret;
 }
 static int kupdate_transactions(struct super_block *s,
diff --git a/fs/select.c b/fs/select.c
index a4d8f6e8b63c..53a0c149f528 100644
--- a/fs/select.c
+++ b/fs/select.c
@@ -294,12 +294,14 @@ enum poll_time_type {
        PT_OLD_TIMESPEC = 3,
 };
-static int poll_select_copy_remaining(struct timespec64 *end_time,
+static int poll_select_finish(struct timespec64 *end_time,
-                                      void __user *p,
+                              void __user *p,
-                                      enum poll_time_type pt_type, int ret)
+                              enum poll_time_type pt_type, int ret)
 {
        struct timespec64 rts;
+        restore_saved_sigmask_unless(ret == -ERESTARTNOHAND);
        if (!p)
                return ret;
@@ -714,9 +716,7 @@ static int kern_select(int n, fd_set __user *inp, fd_set __user *outp,
        }
        ret = core_sys_select(n, inp, outp, exp, to);
-        ret = poll_select_copy_remaining(&end_time, tvp, PT_TIMEVAL, ret);
+        return poll_select_finish(&end_time, tvp, PT_TIMEVAL, ret);
-        return ret;
 }
 SYSCALL_DEFINE5(select, int, n, fd_set __user *, inp, fd_set __user *, outp,
@@ -730,7 +730,6 @@ static long do_pselect(int n, fd_set __user *inp, fd_set __user *outp,
                       const sigset_t __user *sigmask, size_t sigsetsize,
                       enum poll_time_type type)
 {
-        sigset_t ksigmask, sigsaved;
        struct timespec64 ts, end_time, *to = NULL;
        int ret;
@@ -753,15 +752,12 @@ static long do_pselect(int n, fd_set __user *inp, fd_set __user *outp,
                        return -EINVAL;
        }
-        ret = set_user_sigmask(sigmask, &ksigmask, &sigsaved, sigsetsize);
+        ret = set_user_sigmask(sigmask, sigsetsize);
        if (ret)
                return ret;
        ret = core_sys_select(n, inp, outp, exp, to);
-        restore_user_sigmask(sigmask, &sigsaved, ret == -ERESTARTNOHAND);
+        return poll_select_finish(&end_time, tsp, type, ret);
-        ret = poll_select_copy_remaining(&end_time, tsp, type, ret);
-        return ret;
 }
 /*
@@ -926,7 +922,7 @@ static int do_poll(struct poll_list *list, struct poll_wqueues *wait,
                if (!count) {
                        count = wait->error;
                        if (signal_pending(current))
-                                count = -EINTR;
+                                count = -ERESTARTNOHAND;
                }
                if (count || timed_out)
                        break;
@@ -965,7 +961,7 @@ static int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds,
                struct timespec64 *end_time)
 {
        struct poll_wqueues table;
-        int err = -EFAULT, fdcount, len, size;
+        int err = -EFAULT, fdcount, len;
        /* Allocate small arguments on the stack to save memory and be
           faster - use long to make sure the buffer is aligned properly
           on 64 bit archs to avoid unaligned access */
@@ -993,8 +989,8 @@ static int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds,
                        break;
                len = min(todo, POLLFD_PER_PAGE);
-                size = sizeof(struct poll_list) + sizeof(struct pollfd) * len;
+                walk = walk->next = kmalloc(struct_size(walk, entries, len),
-                walk = walk->next = kmalloc(size, GFP_KERNEL);
+                                            GFP_KERNEL);
                if (!walk) {
                        err = -ENOMEM;
                        goto out_fds;
@@ -1041,7 +1037,7 @@ static long do_restart_poll(struct restart_block *restart_block)
        ret = do_sys_poll(ufds, nfds, to);
-        if (ret == -EINTR) {
+        if (ret == -ERESTARTNOHAND) {
                restart_block->fn = do_restart_poll;
                ret = -ERESTART_RESTARTBLOCK;
        }
@@ -1062,7 +1058,7 @@ SYSCALL_DEFINE3(poll, struct pollfd __user *, ufds, unsigned int, nfds,
        ret = do_sys_poll(ufds, nfds, to);
-        if (ret == -EINTR) {
+        if (ret == -ERESTARTNOHAND) {
                struct restart_block *restart_block;
                restart_block = &current->restart_block;
@@ -1086,7 +1082,6 @@ SYSCALL_DEFINE5(ppoll, struct pollfd __user *, ufds, unsigned int, nfds,
                struct __kernel_timespec __user *, tsp, const sigset_t __user *, sigmask,
                size_t, sigsetsize)
 {
-        sigset_t ksigmask, sigsaved;
        struct timespec64 ts, end_time, *to = NULL;
        int ret;
@@ -1099,20 +1094,12 @@ SYSCALL_DEFINE5(ppoll, struct pollfd __user *, ufds, unsigned int, nfds,
                        return -EINVAL;
        }
-        ret = set_user_sigmask(sigmask, &ksigmask, &sigsaved, sigsetsize);
+        ret = set_user_sigmask(sigmask, sigsetsize);
        if (ret)
                return ret;
        ret = do_sys_poll(ufds, nfds, to);
+        return poll_select_finish(&end_time, tsp, PT_TIMESPEC, ret);
-        restore_user_sigmask(sigmask, &sigsaved, ret == -EINTR);
-        /* We can restart this syscall, usually */
-        if (ret == -EINTR)
-                ret = -ERESTARTNOHAND;
-        ret = poll_select_copy_remaining(&end_time, tsp, PT_TIMESPEC, ret);
-        return ret;
 }
 #if defined(CONFIG_COMPAT_32BIT_TIME) && !defined(CONFIG_64BIT)
@@ -1121,7 +1108,6 @@ SYSCALL_DEFINE5(ppoll_time32, struct pollfd __user *, ufds, unsigned int, nfds,
                struct old_timespec32 __user *, tsp, const sigset_t __user *, sigmask,
                size_t, sigsetsize)
 {
-        sigset_t ksigmask, sigsaved;
        struct timespec64 ts, end_time, *to = NULL;
        int ret;
@@ -1134,20 +1120,12 @@ SYSCALL_DEFINE5(ppoll_time32, struct pollfd __user *, ufds, unsigned int, nfds,
                        return -EINVAL;
        }
-        ret = set_user_sigmask(sigmask, &ksigmask, &sigsaved, sigsetsize);
+        ret = set_user_sigmask(sigmask, sigsetsize);
        if (ret)
                return ret;
        ret = do_sys_poll(ufds, nfds, to);
+        return poll_select_finish(&end_time, tsp, PT_OLD_TIMESPEC, ret);
-        restore_user_sigmask(sigmask, &sigsaved, ret == -EINTR);
-        /* We can restart this syscall, usually */
-        if (ret == -EINTR)
-                ret = -ERESTARTNOHAND;
-        ret = poll_select_copy_remaining(&end_time, tsp, PT_OLD_TIMESPEC, ret);
-        return ret;
 }
 #endif
@@ -1284,9 +1262,7 @@ static int do_compat_select(int n, compat_ulong_t __user *inp,
        }
        ret = compat_core_sys_select(n, inp, outp, exp, to);
-        ret = poll_select_copy_remaining(&end_time, tvp, PT_OLD_TIMEVAL, ret);
+        return poll_select_finish(&end_time, tvp, PT_OLD_TIMEVAL, ret);
-        return ret;
 }
 COMPAT_SYSCALL_DEFINE5(select, int, n, compat_ulong_t __user *, inp,
@@ -1319,7 +1295,6 @@ static long do_compat_pselect(int n, compat_ulong_t __user *inp,
        void __user *tsp, compat_sigset_t __user *sigmask,
        compat_size_t sigsetsize, enum poll_time_type type)
 {
-        sigset_t ksigmask, sigsaved;
        struct timespec64 ts, end_time, *to = NULL;
        int ret;
@@ -1342,15 +1317,12 @@ static long do_compat_pselect(int n, compat_ulong_t __user *inp,
                        return -EINVAL;
        }
-        ret = set_compat_user_sigmask(sigmask, &ksigmask, &sigsaved, sigsetsize);
+        ret = set_compat_user_sigmask(sigmask, sigsetsize);
        if (ret)
                return ret;
        ret = compat_core_sys_select(n, inp, outp, exp, to);
-        restore_user_sigmask(sigmask, &sigsaved, ret == -ERESTARTNOHAND);
+        return poll_select_finish(&end_time, tsp, type, ret);
-        ret = poll_select_copy_remaining(&end_time, tsp, type, ret);
-        return ret;
 }
 COMPAT_SYSCALL_DEFINE6(pselect6_time64, int, n, compat_ulong_t __user *, inp,
@@ -1402,7 +1374,6 @@ COMPAT_SYSCALL_DEFINE5(ppoll_time32, struct pollfd __user *, ufds,
        unsigned int,  nfds, struct old_timespec32 __user *, tsp,
        const compat_sigset_t __user *, sigmask, compat_size_t, sigsetsize)
 {
-        sigset_t ksigmask, sigsaved;
        struct timespec64 ts, end_time, *to = NULL;
        int ret;
@@ -1415,20 +1386,12 @@ COMPAT_SYSCALL_DEFINE5(ppoll_time32, struct pollfd __user *, ufds,
                        return -EINVAL;
        }
-        ret = set_compat_user_sigmask(sigmask, &ksigmask, &sigsaved, sigsetsize);
+        ret = set_compat_user_sigmask(sigmask, sigsetsize);
        if (ret)
                return ret;
        ret = do_sys_poll(ufds, nfds, to);
+        return poll_select_finish(&end_time, tsp, PT_OLD_TIMESPEC, ret);
-        restore_user_sigmask(sigmask, &sigsaved, ret == -EINTR);
-        /* We can restart this syscall, usually */
-        if (ret == -EINTR)
-                ret = -ERESTARTNOHAND;
-        ret = poll_select_copy_remaining(&end_time, tsp, PT_OLD_TIMESPEC, ret);
-        return ret;
 }
 #endif
@@ -1437,7 +1400,6 @@ COMPAT_SYSCALL_DEFINE5(ppoll_time64, struct pollfd __user *, ufds,
        unsigned int,  nfds, struct __kernel_timespec __user *, tsp,
        const compat_sigset_t __user *, sigmask, compat_size_t, sigsetsize)
 {
-        sigset_t ksigmask, sigsaved;
        struct timespec64 ts, end_time, *to = NULL;
        int ret;
@@ -1450,20 +1412,12 @@ COMPAT_SYSCALL_DEFINE5(ppoll_time64, struct pollfd __user *, ufds,
                        return -EINVAL;
        }
-        ret = set_compat_user_sigmask(sigmask, &ksigmask, &sigsaved, sigsetsize);
+        ret = set_compat_user_sigmask(sigmask, sigsetsize);
        if (ret)
                return ret;
        ret = do_sys_poll(ufds, nfds, to);
+        return poll_select_finish(&end_time, tsp, PT_TIMESPEC, ret);
-        restore_user_sigmask(sigmask, &sigsaved, ret == -EINTR);
-        /* We can restart this syscall, usually */
-        if (ret == -EINTR)
-                ret = -ERESTARTNOHAND;
-        ret = poll_select_copy_remaining(&end_time, tsp, PT_TIMESPEC, ret);
-        return ret;
 }
 #endif
diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index 3d247c0d92aa..4ed0dca52ec8 100644
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -1407,11 +1407,9 @@ static int ufs_statfs(struct dentry *dentry, struct kstatfs *buf)
        struct super_block *sb = dentry->d_sb;
        struct ufs_sb_private_info *uspi= UFS_SB(sb)->s_uspi;
        unsigned  flags = UFS_SB(sb)->s_flags;
-        struct ufs_super_block_third *usb3;
        u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
        mutex_lock(&UFS_SB(sb)->s_lock);
-        usb3 = ubh_get_usb_third(uspi);
        
        if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
                buf->f_type = UFS2_MAGIC;
diff --git a/include/asm-generic/bug.h b/include/asm-generic/bug.h
index 0e9bd9c83870..aa6c093d9ce9 100644
--- a/include/asm-generic/bug.h
+++ b/include/asm-generic/bug.h
@@ -104,8 +104,10 @@ extern void warn_slowpath_null(const char *file, const int line);
        warn_slowpath_fmt_taint(__FILE__, __LINE__, taint, arg)
 #else
 extern __printf(1, 2) void __warn_printk(const char *fmt, ...);
-#define __WARN()                __WARN_TAINT(TAINT_WARN)
+#define __WARN() do { \
-#define __WARN_printf(arg...)   do { __warn_printk(arg); __WARN(); } while (0)
+        printk(KERN_WARNING CUT_HERE); __WARN_TAINT(TAINT_WARN); \
+} while (0)
+#define __WARN_printf(arg...)   __WARN_printf_taint(TAINT_WARN, arg)
 #define __WARN_printf_taint(taint, arg...)                              \
        do { __warn_printk(arg); __WARN_TAINT(taint); } while (0)
 #endif
diff --git a/include/asm-generic/cacheflush.h b/include/asm-generic/cacheflush.h
index 0dd47a6db2cf..a950a22c4890 100644
--- a/include/asm-generic/cacheflush.h
+++ b/include/asm-generic/cacheflush.h
@@ -5,24 +5,70 @@
 /* Keep includes the same across arches.  */
 #include <linux/mm.h>
+#define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE 0
 /*
 * The cache doesn't need to be flushed when TLB entries change when
 * the cache is mapped to physical memory, not virtual memory
 */
-#define flush_cache_all()                       do { } while (0)
+static inline void flush_cache_all(void)
-#define flush_cache_mm(mm)                      do { } while (0)
+{
-#define flush_cache_dup_mm(mm)                  do { } while (0)
+}
-#define flush_cache_range(vma, start, end)      do { } while (0)
-#define flush_cache_page(vma, vmaddr, pfn)      do { } while (0)
+static inline void flush_cache_mm(struct mm_struct *mm)
-#define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE 0
+{
-#define flush_dcache_page(page)                 do { } while (0)
+}
-#define flush_dcache_mmap_lock(mapping)         do { } while (0)
-#define flush_dcache_mmap_unlock(mapping)       do { } while (0)
+static inline void flush_cache_dup_mm(struct mm_struct *mm)
-#define flush_icache_range(start, end)          do { } while (0)
+{
-#define flush_icache_page(vma,pg)               do { } while (0)
+}
-#define flush_icache_user_range(vma,pg,adr,len) do { } while (0)
-#define flush_cache_vmap(start, end)            do { } while (0)
+static inline void flush_cache_range(struct vm_area_struct *vma,
-#define flush_cache_vunmap(start, end)          do { } while (0)
+                                     unsigned long start,
+                                     unsigned long end)
+{
+}
+static inline void flush_cache_page(struct vm_area_struct *vma,
+                                    unsigned long vmaddr,
+                                    unsigned long pfn)
+{
+}
+static inline void flush_dcache_page(struct page *page)
+{
+}
+static inline void flush_dcache_mmap_lock(struct address_space *mapping)
+{
+}
+static inline void flush_dcache_mmap_unlock(struct address_space *mapping)
+{
+}
+static inline void flush_icache_range(unsigned long start, unsigned long end)
+{
+}
+static inline void flush_icache_page(struct vm_area_struct *vma,
+                                     struct page *page)
+{
+}
+static inline void flush_icache_user_range(struct vm_area_struct *vma,
+                                           struct page *page,
+                                           unsigned long addr, int len)
+{
+}
+static inline void flush_cache_vmap(unsigned long start, unsigned long end)
+{
+}
+static inline void flush_cache_vunmap(unsigned long start, unsigned long end)
+{
+}
 #define copy_to_user_page(vma, page, vaddr, dst, src, len) \
        do { \
diff --git a/include/linux/bits.h b/include/linux/bits.h
index 2b7b532c1d51..669d69441a62 100644
--- a/include/linux/bits.h
+++ b/include/linux/bits.h
@@ -1,13 +1,15 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 #ifndef __LINUX_BITS_H
 #define __LINUX_BITS_H
+#include <linux/const.h>
 #include <asm/bitsperlong.h>
-#define BIT(nr)                 (1UL << (nr))
+#define BIT(nr)                 (UL(1) << (nr))
-#define BIT_ULL(nr)             (1ULL << (nr))
+#define BIT_ULL(nr)             (ULL(1) << (nr))
-#define BIT_MASK(nr)            (1UL << ((nr) % BITS_PER_LONG))
+#define BIT_MASK(nr)            (UL(1) << ((nr) % BITS_PER_LONG))
 #define BIT_WORD(nr)            ((nr) / BITS_PER_LONG)
-#define BIT_ULL_MASK(nr)        (1ULL << ((nr) % BITS_PER_LONG_LONG))
+#define BIT_ULL_MASK(nr)        (ULL(1) << ((nr) % BITS_PER_LONG_LONG))
 #define BIT_ULL_WORD(nr)        ((nr) / BITS_PER_LONG_LONG)
 #define BITS_PER_BYTE           8
@@ -17,10 +19,11 @@
 * GENMASK_ULL(39, 21) gives us the 64bit vector 0x000000ffffe00000.
 */
 #define GENMASK(h, l) \
-        (((~0UL) - (1UL << (l)) + 1) & (~0UL >> (BITS_PER_LONG - 1 - (h))))
+        (((~UL(0)) - (UL(1) << (l)) + 1) & \
+         (~UL(0) >> (BITS_PER_LONG - 1 - (h))))
 #define GENMASK_ULL(h, l) \
-        (((~0ULL) - (1ULL << (l)) + 1) & \
+        (((~ULL(0)) - (ULL(1) << (l)) + 1) & \
-         (~0ULL >> (BITS_PER_LONG_LONG - 1 - (h))))
+         (~ULL(0) >> (BITS_PER_LONG_LONG - 1 - (h))))
 #endif  /* __LINUX_BITS_H */
diff --git a/include/linux/coda.h b/include/linux/coda.h
index d30209b9cef8..0ca0c83fdb1c 100644
--- a/include/linux/coda.h
+++ b/include/linux/coda.h
@@ -58,8 +58,7 @@ Mellon the rights to redistribute these changes without encumbrance.
 #ifndef _CODA_HEADER_
 #define _CODA_HEADER_
-#if defined(__linux__)
 typedef unsigned long long u_quad_t;
-#endif
 #include <uapi/linux/coda.h>
 #endif 
diff --git a/include/linux/compat.h b/include/linux/compat.h
index ebddcb6cfcf8..16dafd9f4b86 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -138,8 +138,7 @@ typedef struct {
        compat_sigset_word      sig[_COMPAT_NSIG_WORDS];
 } compat_sigset_t;
-int set_compat_user_sigmask(const compat_sigset_t __user *usigmask,
+int set_compat_user_sigmask(const compat_sigset_t __user *umask,
-                            sigset_t *set, sigset_t *oldset,
                            size_t sigsetsize);
 struct compat_sigaction {
diff --git a/include/linux/io.h b/include/linux/io.h
index 9876e5801a9d..accac822336a 100644
--- a/include/linux/io.h
+++ b/include/linux/io.h
@@ -33,6 +33,7 @@ static inline int ioremap_page_range(unsigned long addr, unsigned long end,
 #ifdef CONFIG_HAVE_ARCH_HUGE_VMAP
 void __init ioremap_huge_init(void);
+int arch_ioremap_p4d_supported(void);
 int arch_ioremap_pud_supported(void);
 int arch_ioremap_pmd_supported(void);
 #else
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 0c9bc231107f..4fa360a13c1e 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -88,6 +88,8 @@
 */
 #define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
+#define typeof_member(T, m)     typeof(((T*)0)->m)
 #define DIV_ROUND_UP __KERNEL_DIV_ROUND_UP
 #define DIV_ROUND_DOWN_ULL(ll, d) \
diff --git a/include/linux/kprobes.h b/include/linux/kprobes.h
index 443d9800ca3f..04bdaf01112c 100644
--- a/include/linux/kprobes.h
+++ b/include/linux/kprobes.h
@@ -458,4 +458,23 @@ static inline bool is_kprobe_optinsn_slot(unsigned long addr)
 }
 #endif
+/* Returns true if kprobes handled the fault */
+static nokprobe_inline bool kprobe_page_fault(struct pt_regs *regs,
+                                              unsigned int trap)
+{
+        if (!kprobes_built_in())
+                return false;
+        if (user_mode(regs))
+                return false;
+        /*
+         * To be potentially processing a kprobe fault and to be allowed
+         * to call kprobe_running(), we have to be non-preemptible.
+         */
+        if (preemptible())
+                return false;
+        if (!kprobe_running())
+                return false;
+        return kprobe_fault_handler(regs, trap);
+}
 #endif /* _LINUX_KPROBES_H */
diff --git a/include/linux/lz4.h b/include/linux/lz4.h
index 394e3d9213b8..b16e15b9587a 100644
--- a/include/linux/lz4.h
+++ b/include/linux/lz4.h
@@ -278,7 +278,7 @@ int LZ4_decompress_fast(const char *source, char *dest, int originalSize);
 * @compressedSize: is the precise full size of the compressed block
 * @maxDecompressedSize: is the size of 'dest' buffer
 *
- * Decompresses data fom 'source' into 'dest'.
+ * Decompresses data from 'source' into 'dest'.
 * If the source stream is detected malformed, the function will
 * stop decoding and return a negative result.
 * This function is protected against buffer overflow exploits,
@@ -522,7 +522,7 @@ int LZ4_setStreamDecode(LZ4_streamDecode_t *LZ4_streamDecode,
        const char *dictionary, int dictSize);
 /**
- * LZ4_decompress_fast_continue() - Decompress blocks in streaming mode
+ * LZ4_decompress_safe_continue() - Decompress blocks in streaming mode
 * @LZ4_streamDecode: the 'LZ4_streamDecode_t' structure
 * @source: source address of the compressed data
 * @dest: output buffer address of the uncompressed data
@@ -530,7 +530,7 @@ int LZ4_setStreamDecode(LZ4_streamDecode_t *LZ4_streamDecode,
 * @compressedSize: is the precise full size of the compressed block
 * @maxDecompressedSize: is the size of 'dest' buffer
 *
- * These decoding function allows decompression of multiple blocks
+ * This decoding function allows decompression of multiple blocks
 * in "streaming" mode.
 * Previously decoded blocks *must* remain available at the memory position
 * where they were decoded (up to 64 KB)
@@ -569,7 +569,7 @@ int LZ4_decompress_safe_continue(LZ4_streamDecode_t *LZ4_streamDecode,
 *      which must be already allocated with 'originalSize' bytes
 * @originalSize: is the original and therefore uncompressed size
 *
- * These decoding function allows decompression of multiple blocks
+ * This decoding function allows decompression of multiple blocks
 * in "streaming" mode.
 * Previously decoded blocks *must* remain available at the memory position
 * where they were decoded (up to 64 KB)
@@ -610,10 +610,10 @@ int LZ4_decompress_fast_continue(LZ4_streamDecode_t *LZ4_streamDecode,
 * @dictStart: pointer to the start of the dictionary in memory
 * @dictSize: size of dictionary
 *
- * These decoding function works the same as
+ * This decoding function works the same as
 * a combination of LZ4_setStreamDecode() followed by
 * LZ4_decompress_safe_continue()
- * It is stand-alone, and don'tn eed a LZ4_streamDecode_t structure.
+ * It is stand-alone, and doesn't need an LZ4_streamDecode_t structure.
 *
 * Return: number of bytes decompressed into destination buffer
 *      (necessarily <= maxDecompressedSize)
@@ -633,10 +633,10 @@ int LZ4_decompress_safe_usingDict(const char *source, char *dest,
 * @dictStart: pointer to the start of the dictionary in memory
 * @dictSize: size of dictionary
 *
- * These decoding function works the same as
+ * This decoding function works the same as
 * a combination of LZ4_setStreamDecode() followed by
- * LZ4_decompress_safe_continue()
+ * LZ4_decompress_fast_continue()
- * It is stand-alone, and don'tn eed a LZ4_streamDecode_t structure.
+ * It is stand-alone, and doesn't need an LZ4_streamDecode_t structure.
 *
 * Return: number of bytes decompressed into destination buffer
 *      (necessarily <= maxDecompressedSize)
diff --git a/include/linux/memory_hotplug.h b/include/linux/memory_hotplug.h
index ae892eef8b82..988fde33cd7f 100644
--- a/include/linux/memory_hotplug.h
+++ b/include/linux/memory_hotplug.h
@@ -324,7 +324,7 @@ static inline void pgdat_resize_init(struct pglist_data *pgdat) {}
 extern bool is_mem_section_removable(unsigned long pfn, unsigned long nr_pages);
 extern void try_offline_node(int nid);
 extern int offline_pages(unsigned long start_pfn, unsigned long nr_pages);
-extern void remove_memory(int nid, u64 start, u64 size);
+extern int remove_memory(int nid, u64 start, u64 size);
 extern void __remove_memory(int nid, u64 start, u64 size);
 #else
@@ -341,7 +341,11 @@ static inline int offline_pages(unsigned long start_pfn, unsigned long nr_pages)
        return -EINVAL;
 }
-static inline void remove_memory(int nid, u64 start, u64 size) {}
+static inline int remove_memory(int nid, u64 start, u64 size)
+{
+        return -EBUSY;
+}
 static inline void __remove_memory(int nid, u64 start, u64 size) {}
 #endif /* CONFIG_MEMORY_HOTREMOVE */
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 0389c34ac529..bd6512559bed 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -547,7 +547,7 @@ static inline void vma_set_anonymous(struct vm_area_struct *vma)
 struct mmu_gather;
 struct inode;
-#if !defined(__HAVE_ARCH_PTE_DEVMAP) || !defined(CONFIG_TRANSPARENT_HUGEPAGE)
+#if !defined(CONFIG_ARCH_HAS_PTE_DEVMAP) || !defined(CONFIG_TRANSPARENT_HUGEPAGE)
 static inline int pmd_devmap(pmd_t pmd)
 {
        return 0;
@@ -956,41 +956,28 @@ static inline bool put_devmap_managed_page(struct page *page)
        return false;
 }
-static inline bool is_device_private_page(const struct page *page)
-{
-        return is_zone_device_page(page) &&
-                page->pgmap->type == MEMORY_DEVICE_PRIVATE;
-}
-#ifdef CONFIG_PCI_P2PDMA
-static inline bool is_pci_p2pdma_page(const struct page *page)
-{
-        return is_zone_device_page(page) &&
-                page->pgmap->type == MEMORY_DEVICE_PCI_P2PDMA;
-}
-#else /* CONFIG_PCI_P2PDMA */
-static inline bool is_pci_p2pdma_page(const struct page *page)
-{
-        return false;
-}
-#endif /* CONFIG_PCI_P2PDMA */
 #else /* CONFIG_DEV_PAGEMAP_OPS */
 static inline bool put_devmap_managed_page(struct page *page)
 {
        return false;
 }
+#endif /* CONFIG_DEV_PAGEMAP_OPS */
 static inline bool is_device_private_page(const struct page *page)
 {
-        return false;
+        return IS_ENABLED(CONFIG_DEV_PAGEMAP_OPS) &&
+                IS_ENABLED(CONFIG_DEVICE_PRIVATE) &&
+                is_zone_device_page(page) &&
+                page->pgmap->type == MEMORY_DEVICE_PRIVATE;
 }
 static inline bool is_pci_p2pdma_page(const struct page *page)
 {
-        return false;
+        return IS_ENABLED(CONFIG_DEV_PAGEMAP_OPS) &&
+                IS_ENABLED(CONFIG_PCI_P2PDMA) &&
+                is_zone_device_page(page) &&
+                page->pgmap->type == MEMORY_DEVICE_PCI_P2PDMA;
 }
-#endif /* CONFIG_DEV_PAGEMAP_OPS */
 /* 127: arbitrary random number, small enough to assemble well */
 #define page_ref_zero_or_close_to_overflow(page) \
@@ -1556,6 +1543,10 @@ long get_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
 int get_user_pages_fast(unsigned long start, int nr_pages,
                        unsigned int gup_flags, struct page **pages);
+int account_locked_vm(struct mm_struct *mm, unsigned long pages, bool inc);
+int __account_locked_vm(struct mm_struct *mm, unsigned long pages, bool inc,
+                        struct task_struct *task, bool bypass_rlim);
 /* Container for pinned pfns / pages */
 struct frame_vector {
        unsigned int nr_allocated;      /* Number of frames we have space for */
@@ -1763,7 +1754,7 @@ static inline void sync_mm_rss(struct mm_struct *mm)
 }
 #endif
-#ifndef __HAVE_ARCH_PTE_DEVMAP
+#ifndef CONFIG_ARCH_HAS_PTE_DEVMAP
 static inline int pte_devmap(pte_t pte)
 {
        return 0;
@@ -2767,7 +2758,13 @@ extern int randomize_va_space;
 #endif
 const char * arch_vma_name(struct vm_area_struct *vma);
+#ifdef CONFIG_MMU
 void print_vma_addr(char *prefix, unsigned long rip);
+#else
+static inline void print_vma_addr(char *prefix, unsigned long rip)
+{
+}
+#endif
 void *sparse_buffer_alloc(unsigned long size);
 struct page *sparse_mem_map_populate(unsigned long pnum, int nid,
diff --git a/include/linux/pfn_t.h b/include/linux/pfn_t.h
index 01e8037023f7..2d9148221e9a 100644
--- a/include/linux/pfn_t.h
+++ b/include/linux/pfn_t.h
@@ -97,7 +97,7 @@ static inline pud_t pfn_t_pud(pfn_t pfn, pgprot_t pgprot)
 #endif
 #endif
-#ifdef __HAVE_ARCH_PTE_DEVMAP
+#ifdef CONFIG_ARCH_HAS_PTE_DEVMAP
 static inline bool pfn_t_devmap(pfn_t pfn)
 {
        const u64 flags = PFN_DEV|PFN_MAP;
@@ -115,7 +115,7 @@ pmd_t pmd_mkdevmap(pmd_t pmd);
        defined(CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD)
 pud_t pud_mkdevmap(pud_t pud);
 #endif
-#endif /* __HAVE_ARCH_PTE_DEVMAP */
+#endif /* CONFIG_ARCH_HAS_PTE_DEVMAP */
 #ifdef CONFIG_ARCH_HAS_PTE_SPECIAL
 static inline bool pfn_t_special(pfn_t pfn)
diff --git a/include/linux/pid.h b/include/linux/pid.h
index 1484db6ca8d1..2a83e434db9d 100644
--- a/include/linux/pid.h
+++ b/include/linux/pid.h
@@ -4,6 +4,7 @@
 #include <linux/rculist.h>
 #include <linux/wait.h>
+#include <linux/refcount.h>
 enum pid_type
 {
@@ -57,7 +58,7 @@ struct upid {
 struct pid
 {
-        atomic_t count;
+        refcount_t count;
        unsigned int level;
        /* lists of tasks that use this pid */
        struct hlist_head tasks[PIDTYPE_MAX];
@@ -74,7 +75,7 @@ extern const struct file_operations pidfd_fops;
 static inline struct pid *get_pid(struct pid *pid)
 {
        if (pid)
-                atomic_inc(&pid->count);
+                refcount_inc(&pid->count);
        return pid;
 }
diff --git a/include/linux/poison.h b/include/linux/poison.h
index d6d980a681c7..df34330b4e34 100644
--- a/include/linux/poison.h
+++ b/include/linux/poison.h
@@ -21,7 +21,7 @@
 * non-initialized list entries.
 */
 #define LIST_POISON1  ((void *) 0x100 + POISON_POINTER_DELTA)
-#define LIST_POISON2  ((void *) 0x200 + POISON_POINTER_DELTA)
+#define LIST_POISON2  ((void *) 0x122 + POISON_POINTER_DELTA)
 /********** include/linux/timer.h **********/
 /*
diff --git a/include/linux/rbtree.h b/include/linux/rbtree.h
index e6337fce08f2..1fd61a9af45c 100644
--- a/include/linux/rbtree.h
+++ b/include/linux/rbtree.h
@@ -32,25 +32,9 @@ struct rb_root {
        struct rb_node *rb_node;
 };
-/*
- * Leftmost-cached rbtrees.
- *
- * We do not cache the rightmost node based on footprint
- * size vs number of potential users that could benefit
- * from O(1) rb_last(). Just not worth it, users that want
- * this feature can always implement the logic explicitly.
- * Furthermore, users that want to cache both pointers may
- * find it a bit asymmetric, but that's ok.
- */
-struct rb_root_cached {
-        struct rb_root rb_root;
-        struct rb_node *rb_leftmost;
-};
 #define rb_parent(r)   ((struct rb_node *)((r)->__rb_parent_color & ~3))
 #define RB_ROOT (struct rb_root) { NULL, }
-#define RB_ROOT_CACHED (struct rb_root_cached) { {NULL, }, NULL }
 #define rb_entry(ptr, type, member) container_of(ptr, type, member)
 #define RB_EMPTY_ROOT(root)  (READ_ONCE((root)->rb_node) == NULL)
@@ -72,12 +56,6 @@ extern struct rb_node *rb_prev(const struct rb_node *);
 extern struct rb_node *rb_first(const struct rb_root *);
 extern struct rb_node *rb_last(const struct rb_root *);
-extern void rb_insert_color_cached(struct rb_node *,
-                                   struct rb_root_cached *, bool);
-extern void rb_erase_cached(struct rb_node *node, struct rb_root_cached *);
-/* Same as rb_first(), but O(1) */
-#define rb_first_cached(root) (root)->rb_leftmost
 /* Postorder iteration - always visit the parent after its children */
 extern struct rb_node *rb_first_postorder(const struct rb_root *);
 extern struct rb_node *rb_next_postorder(const struct rb_node *);
@@ -87,8 +65,6 @@ extern void rb_replace_node(struct rb_node *victim, struct rb_node *new,
                            struct rb_root *root);
 extern void rb_replace_node_rcu(struct rb_node *victim, struct rb_node *new,
                                struct rb_root *root);
-extern void rb_replace_node_cached(struct rb_node *victim, struct rb_node *new,
-                                   struct rb_root_cached *root);
 static inline void rb_link_node(struct rb_node *node, struct rb_node *parent,
                                struct rb_node **rb_link)
@@ -136,4 +112,50 @@ static inline void rb_link_node_rcu(struct rb_node *node, struct rb_node *parent
                        typeof(*pos), field); 1; }); \
             pos = n)
+/*
+ * Leftmost-cached rbtrees.
+ *
+ * We do not cache the rightmost node based on footprint
+ * size vs number of potential users that could benefit
+ * from O(1) rb_last(). Just not worth it, users that want
+ * this feature can always implement the logic explicitly.
+ * Furthermore, users that want to cache both pointers may
+ * find it a bit asymmetric, but that's ok.
+ */
+struct rb_root_cached {
+        struct rb_root rb_root;
+        struct rb_node *rb_leftmost;
+};
+#define RB_ROOT_CACHED (struct rb_root_cached) { {NULL, }, NULL }
+/* Same as rb_first(), but O(1) */
+#define rb_first_cached(root) (root)->rb_leftmost
+static inline void rb_insert_color_cached(struct rb_node *node,
+                                          struct rb_root_cached *root,
+                                          bool leftmost)
+{
+        if (leftmost)
+                root->rb_leftmost = node;
+        rb_insert_color(node, &root->rb_root);
+}
+static inline void rb_erase_cached(struct rb_node *node,
+                                   struct rb_root_cached *root)
+{
+        if (root->rb_leftmost == node)
+                root->rb_leftmost = rb_next(node);
+        rb_erase(node, &root->rb_root);
+}
+static inline void rb_replace_node_cached(struct rb_node *victim,
+                                          struct rb_node *new,
+                                          struct rb_root_cached *root)
+{
+        if (root->rb_leftmost == victim)
+                root->rb_leftmost = new;
+        rb_replace_node(victim, new, &root->rb_root);
+}
 #endif  /* _LINUX_RBTREE_H */
diff --git a/include/linux/rbtree_augmented.h b/include/linux/rbtree_augmented.h
index 0f902ccb48b0..179faab29f52 100644
--- a/include/linux/rbtree_augmented.h
+++ b/include/linux/rbtree_augmented.h
@@ -30,10 +30,9 @@ struct rb_augment_callbacks {
        void (*rotate)(struct rb_node *old, struct rb_node *new);
 };
-extern void __rb_insert_augmented(struct rb_node *node,
+extern void __rb_insert_augmented(struct rb_node *node, struct rb_root *root,
-                                  struct rb_root *root,
-                                  bool newleft, struct rb_node **leftmost,
        void (*augment_rotate)(struct rb_node *old, struct rb_node *new));
 /*
 * Fixup the rbtree and update the augmented information when rebalancing.
 *
@@ -48,7 +47,7 @@ static inline void
 rb_insert_augmented(struct rb_node *node, struct rb_root *root,
                    const struct rb_augment_callbacks *augment)
 {
-        __rb_insert_augmented(node, root, false, NULL, augment->rotate);
+        __rb_insert_augmented(node, root, augment->rotate);
 }
 static inline void
@@ -56,8 +55,9 @@ rb_insert_augmented_cached(struct rb_node *node,
                           struct rb_root_cached *root, bool newleft,
                           const struct rb_augment_callbacks *augment)
 {
-        __rb_insert_augmented(node, &root->rb_root,
+        if (newleft)
-                              newleft, &root->rb_leftmost, augment->rotate);
+                root->rb_leftmost = node;
+        rb_insert_augmented(node, &root->rb_root, augment);
 }
 #define RB_DECLARE_CALLBACKS(rbstatic, rbname, rbstruct, rbfield,       \
@@ -150,7 +150,6 @@ extern void __rb_erase_color(struct rb_node *parent, struct rb_root *root,
 static __always_inline struct rb_node *
 __rb_erase_augmented(struct rb_node *node, struct rb_root *root,
-                     struct rb_node **leftmost,
                     const struct rb_augment_callbacks *augment)
 {
        struct rb_node *child = node->rb_right;
@@ -158,9 +157,6 @@ __rb_erase_augmented(struct rb_node *node, struct rb_root *root,
        struct rb_node *parent, *rebalance;
        unsigned long pc;
-        if (leftmost && node == *leftmost)
-                *leftmost = rb_next(node);
        if (!tmp) {
                /*
                 * Case 1: node to erase has no more than 1 child (easy!)
@@ -260,8 +256,7 @@ static __always_inline void
 rb_erase_augmented(struct rb_node *node, struct rb_root *root,
                   const struct rb_augment_callbacks *augment)
 {
-        struct rb_node *rebalance = __rb_erase_augmented(node, root,
+        struct rb_node *rebalance = __rb_erase_augmented(node, root, augment);
-                                                         NULL, augment);
        if (rebalance)
                __rb_erase_color(rebalance, root, augment->rotate);
 }
@@ -270,11 +265,9 @@ static __always_inline void
 rb_erase_augmented_cached(struct rb_node *node, struct rb_root_cached *root,
                          const struct rb_augment_callbacks *augment)
 {
-        struct rb_node *rebalance = __rb_erase_augmented(node, &root->rb_root,
+        if (root->rb_leftmost == node)
-                                                         &root->rb_leftmost,
+                root->rb_leftmost = rb_next(node);
-                                                         augment);
+        rb_erase_augmented(node, &root->rb_root, augment);
-        if (rebalance)
-                __rb_erase_color(rebalance, &root->rb_root, augment->rotate);
 }
 #endif  /* _LINUX_RBTREE_AUGMENTED_H */
diff --git a/include/linux/sched/signal.h b/include/linux/sched/signal.h
index 532458698bde..efd8ce7675ed 100644
--- a/include/linux/sched/signal.h
+++ b/include/linux/sched/signal.h
@@ -15,10 +15,10 @@
 */
 struct sighand_struct {
-        refcount_t              count;
-        struct k_sigaction      action[_NSIG];
        spinlock_t              siglock;
+        refcount_t              count;
        wait_queue_head_t       signalfd_wqh;
+        struct k_sigaction      action[_NSIG];
 };
 /*
@@ -420,7 +420,6 @@ void task_join_group_stop(struct task_struct *task);
 static inline void set_restore_sigmask(void)
 {
        set_thread_flag(TIF_RESTORE_SIGMASK);
-        WARN_ON(!test_thread_flag(TIF_SIGPENDING));
 }
 static inline void clear_tsk_restore_sigmask(struct task_struct *task)
@@ -451,7 +450,6 @@ static inline bool test_and_clear_restore_sigmask(void)
 static inline void set_restore_sigmask(void)
 {
        current->restore_sigmask = true;
-        WARN_ON(!test_thread_flag(TIF_SIGPENDING));
 }
 static inline void clear_tsk_restore_sigmask(struct task_struct *task)
 {
@@ -484,6 +482,16 @@ static inline void restore_saved_sigmask(void)
                __set_current_blocked(&current->saved_sigmask);
 }
+extern int set_user_sigmask(const sigset_t __user *umask, size_t sigsetsize);
+static inline void restore_saved_sigmask_unless(bool interrupted)
+{
+        if (interrupted)
+                WARN_ON(!test_thread_flag(TIF_SIGPENDING));
+        else
+                restore_saved_sigmask();
+}
 static inline sigset_t *sigmask_to_save(void)
 {
        sigset_t *res = &current->blocked;
diff --git a/include/linux/signal.h b/include/linux/signal.h
index 78c2bb376954..b5d99482d3fe 100644
--- a/include/linux/signal.h
+++ b/include/linux/signal.h
@@ -273,10 +273,6 @@ extern int group_send_sig_info(int sig, struct kernel_siginfo *info,
                               struct task_struct *p, enum pid_type type);
 extern int __group_send_sig_info(int, struct kernel_siginfo *, struct task_struct *);
 extern int sigprocmask(int, sigset_t *, sigset_t *);
-extern int set_user_sigmask(const sigset_t __user *usigmask, sigset_t *set,
-        sigset_t *oldset, size_t sigsetsize);
-extern void restore_user_sigmask(const void __user *usigmask,
-                                 sigset_t *sigsaved, bool interrupted);
 extern void set_current_blocked(sigset_t *);
 extern void __set_current_blocked(const sigset_t *);
 extern int show_unhandled_signals;
diff --git a/include/linux/swapops.h b/include/linux/swapops.h
index 15bdb6fe71e5..877fd239b6ff 100644
--- a/include/linux/swapops.h
+++ b/include/linux/swapops.h
@@ -6,6 +6,8 @@
 #include <linux/bug.h>
 #include <linux/mm_types.h>
+#ifdef CONFIG_MMU
 /*
 * swapcache pages are stored in the swapper_space radix tree.  We want to
 * get good packing density in that tree, so the index should be dense in
@@ -50,13 +52,11 @@ static inline pgoff_t swp_offset(swp_entry_t entry)
        return entry.val & SWP_OFFSET_MASK;
 }
-#ifdef CONFIG_MMU
 /* check whether a pte points to a swap entry */
 static inline int is_swap_pte(pte_t pte)
 {
        return !pte_none(pte) && !pte_present(pte);
 }
-#endif
 /*
 * Convert the arch-dependent pte representation of a swp_entry_t into an
@@ -360,4 +360,5 @@ static inline int non_swap_entry(swp_entry_t entry)
 }
 #endif
+#endif /* CONFIG_MMU */
 #endif /* _LINUX_SWAPOPS_H */
diff --git a/include/linux/tracehook.h b/include/linux/tracehook.h
index 8446573cc682..36fb3bbed6b2 100644
--- a/include/linux/tracehook.h
+++ b/include/linux/tracehook.h
@@ -54,13 +54,15 @@ struct linux_binprm;
 /*
 * ptrace report for syscall entry and exit looks identical.
 */
-static inline int ptrace_report_syscall(struct pt_regs *regs)
+static inline int ptrace_report_syscall(struct pt_regs *regs,
+                                        unsigned long message)
 {
        int ptrace = current->ptrace;
        if (!(ptrace & PT_PTRACED))
                return 0;
+        current->ptrace_message = message;
        ptrace_notify(SIGTRAP | ((ptrace & PT_TRACESYSGOOD) ? 0x80 : 0));
        /*
@@ -73,6 +75,7 @@ static inline int ptrace_report_syscall(struct pt_regs *regs)
                current->exit_code = 0;
        }
+        current->ptrace_message = 0;
        return fatal_signal_pending(current);
 }
@@ -98,7 +101,7 @@ static inline int ptrace_report_syscall(struct pt_regs *regs)
 static inline __must_check int tracehook_report_syscall_entry(
        struct pt_regs *regs)
 {
-        return ptrace_report_syscall(regs);
+        return ptrace_report_syscall(regs, PTRACE_EVENTMSG_SYSCALL_ENTRY);
 }
 /**
@@ -123,7 +126,7 @@ static inline void tracehook_report_syscall_exit(struct pt_regs *regs, int step)
        if (step)
                user_single_step_report(regs);
        else
-                ptrace_report_syscall(regs);
+                ptrace_report_syscall(regs, PTRACE_EVENTMSG_SYSCALL_EXIT);
 }
 /**
diff --git a/include/uapi/asm-generic/mman-common.h b/include/uapi/asm-generic/mman-common.h
index abd238d0f7a4..63b1f506ea67 100644
--- a/include/uapi/asm-generic/mman-common.h
+++ b/include/uapi/asm-generic/mman-common.h
@@ -19,15 +19,18 @@
 #define MAP_TYPE        0x0f            /* Mask for type of mapping */
 #define MAP_FIXED       0x10            /* Interpret addr exactly */
 #define MAP_ANONYMOUS   0x20            /* don't use a file */
-#ifdef CONFIG_MMAP_ALLOW_UNINITIALIZED
-# define MAP_UNINITIALIZED 0x4000000    /* For anonymous mmap, memory could be uninitialized */
-#else
-# define MAP_UNINITIALIZED 0x0          /* Don't support this flag */
-#endif
-/* 0x0100 - 0x80000 flags are defined in asm-generic/mman.h */
+/* 0x0100 - 0x4000 flags are defined in asm-generic/mman.h */
+#define MAP_POPULATE            0x008000        /* populate (prefault) pagetables */
+#define MAP_NONBLOCK            0x010000        /* do not block on IO */
+#define MAP_STACK               0x020000        /* give out an address that is best suited for process/thread stacks */
+#define MAP_HUGETLB             0x040000        /* create a huge page mapping */
+#define MAP_SYNC                0x080000 /* perform synchronous page faults for the mapping */
 #define MAP_FIXED_NOREPLACE     0x100000        /* MAP_FIXED which doesn't unmap underlying mapping */
+#define MAP_UNINITIALIZED 0x4000000     /* For anonymous mmap, memory could be
+                                         * uninitialized */
 /*
 * Flags for mlock
 */
diff --git a/include/uapi/asm-generic/mman.h b/include/uapi/asm-generic/mman.h
index 653687d9771b..57e8195d0b53 100644
--- a/include/uapi/asm-generic/mman.h
+++ b/include/uapi/asm-generic/mman.h
@@ -9,13 +9,11 @@
 #define MAP_EXECUTABLE  0x1000          /* mark it as an executable */
 #define MAP_LOCKED      0x2000          /* pages are locked */
 #define MAP_NORESERVE   0x4000          /* don't check for reservations */
-#define MAP_POPULATE    0x8000          /* populate (prefault) pagetables */
-#define MAP_NONBLOCK    0x10000         /* do not block on IO */
-#define MAP_STACK       0x20000         /* give out an address that is best suited for process/thread stacks */
-#define MAP_HUGETLB     0x40000         /* create a huge page mapping */
-#define MAP_SYNC        0x80000         /* perform synchronous page faults for the mapping */
-/* Bits [26:31] are reserved, see mman-common.h for MAP_HUGETLB usage */
+/*
+ * Bits [26:31] are reserved, see asm-generic/hugetlb_encode.h
+ * for MAP_HUGETLB usage
+ */
 #define MCL_CURRENT     1               /* lock all current mappings */
 #define MCL_FUTURE      2               /* lock all future mappings */
diff --git a/include/uapi/linux/coda.h b/include/uapi/linux/coda.h
index 695fade33c64..aa34c2dcae8d 100644
--- a/include/uapi/linux/coda.h
+++ b/include/uapi/linux/coda.h
@@ -86,10 +86,6 @@ typedef unsigned long long u_quad_t;
 #define inline
-struct timespec {
-        long       ts_sec;
-        long       ts_nsec;
-};
 #else  /* DJGPP but not KERNEL */
 #include <sys/time.h>
 typedef unsigned long long u_quad_t;
@@ -110,13 +106,6 @@ typedef unsigned long long u_quad_t;
 #define cdev_t dev_t
 #endif
-#ifdef __CYGWIN32__
-struct timespec {
-        time_t  tv_sec;         /* seconds */
-        long    tv_nsec;        /* nanoseconds */
-};
-#endif
 #ifndef __BIT_TYPES_DEFINED__
 #define __BIT_TYPES_DEFINED__
 typedef signed char           int8_t;
@@ -211,6 +200,11 @@ struct CodaFid {
 */
 enum coda_vtype { C_VNON, C_VREG, C_VDIR, C_VBLK, C_VCHR, C_VLNK, C_VSOCK, C_VFIFO, C_VBAD };
+struct coda_timespec {
+        int64_t         tv_sec;         /* seconds */
+        long            tv_nsec;        /* nanoseconds */
+};
 struct coda_vattr {
        long            va_type;        /* vnode type (for create) */
        u_short         va_mode;        /* files access mode and type */
@@ -220,9 +214,9 @@ struct coda_vattr {
        long            va_fileid;      /* file id */
        u_quad_t        va_size;        /* file size in bytes */
        long            va_blocksize;   /* blocksize preferred for i/o */
-        struct timespec va_atime;       /* time of last access */
+        struct coda_timespec va_atime;  /* time of last access */
-        struct timespec va_mtime;       /* time of last modification */
+        struct coda_timespec va_mtime;  /* time of last modification */
-        struct timespec va_ctime;       /* time file changed */
+        struct coda_timespec va_ctime;  /* time file changed */
        u_long          va_gen;         /* generation number of file */
        u_long          va_flags;       /* flags defined for file */
        cdev_t          va_rdev;        /* device special file represents */
@@ -277,7 +271,8 @@ struct coda_statfs {
 #define CODA_STATFS      34
 #define CODA_STORE       35
 #define CODA_RELEASE     36
-#define CODA_NCALLS 37
+#define CODA_ACCESS_INTENT 37
+#define CODA_NCALLS 38
 #define DOWNCALL(opcode) (opcode >= CODA_REPLACE && opcode <= CODA_PURGEFID)
@@ -287,7 +282,12 @@ struct coda_statfs {
 #define CIOC_KERNEL_VERSION _IOWR('c', 10, size_t)
-#define CODA_KERNEL_VERSION 3 /* 128-bit file identifiers */
+//      CODA_KERNEL_VERSION 0 /* don't care about kernel version number */
+//      CODA_KERNEL_VERSION 1 /* The old venus 4.6 compatible interface */
+//      CODA_KERNEL_VERSION 2 /* venus_lookup gets an extra parameter */
+//      CODA_KERNEL_VERSION 3 /* 128-bit file identifiers */
+//      CODA_KERNEL_VERSION 4 /* 64-bit timespec */
+#define CODA_KERNEL_VERSION 5 /* access intent support */
 /*
 *        Venus <-> Coda  RPC arguments
@@ -295,8 +295,8 @@ struct coda_statfs {
 struct coda_in_hdr {
    u_int32_t opcode;
    u_int32_t unique;       /* Keep multiple outstanding msgs distinct */
-    pid_t pid;
+    __kernel_pid_t pid;
-    pid_t pgid;
+    __kernel_pid_t pgid;
    vuid_t uid;
 };
@@ -642,6 +642,25 @@ struct coda_statfs_out {
    struct coda_statfs stat;
 };
+#define CODA_ACCESS_TYPE_READ           1
+#define CODA_ACCESS_TYPE_WRITE          2
+#define CODA_ACCESS_TYPE_MMAP           3
+#define CODA_ACCESS_TYPE_READ_FINISH    4
+#define CODA_ACCESS_TYPE_WRITE_FINISH   5
+/* coda_access_intent: NO_OUT */
+struct coda_access_intent_in {
+        struct coda_in_hdr ih;
+        struct CodaFid VFid;
+        int count;
+        int pos;
+        int type;
+};
+struct coda_access_intent_out {
+        struct coda_out_hdr out;
+};
 /* 
 * Occasionally, we don't cache the fid returned by CODA_LOOKUP. 
 * For instance, if the fid is inconsistent. 
@@ -673,6 +692,7 @@ union inputArgs {
    struct coda_open_by_fd_in coda_open_by_fd;
    struct coda_open_by_path_in coda_open_by_path;
    struct coda_statfs_in coda_statfs;
+    struct coda_access_intent_in coda_access_intent;
 };
 union outputArgs {
diff --git a/include/uapi/linux/coda_psdev.h b/include/uapi/linux/coda_psdev.h
deleted file mode 100644
index aa6623efd2dd..000000000000
--- a/include/uapi/linux/coda_psdev.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
-#ifndef _UAPI__CODA_PSDEV_H
-#define _UAPI__CODA_PSDEV_H
-#include <linux/magic.h>
-#define CODA_PSDEV_MAJOR 67
-#define MAX_CODADEVS  5    /* how many do we allow */
-/* messages between coda filesystem in kernel and Venus */
-struct upc_req {
-        struct list_head    uc_chain;
-        caddr_t             uc_data;
-        u_short             uc_flags;
-        u_short             uc_inSize;  /* Size is at most 5000 bytes */
-        u_short             uc_outSize;
-        u_short             uc_opcode;  /* copied from data to save lookup */
-        int                 uc_unique;
-        wait_queue_head_t   uc_sleep;   /* process' wait queue */
-};
-#define CODA_REQ_ASYNC  0x1
-#define CODA_REQ_READ   0x2
-#define CODA_REQ_WRITE  0x4
-#define CODA_REQ_ABORT  0x8
-#endif /* _UAPI__CODA_PSDEV_H */
diff --git a/include/uapi/linux/ptrace.h b/include/uapi/linux/ptrace.h
index d5a1b8a492b9..a71b6e3b03eb 100644
--- a/include/uapi/linux/ptrace.h
+++ b/include/uapi/linux/ptrace.h
@@ -73,6 +73,41 @@ struct seccomp_metadata {
        __u64 flags;            /* Output: filter's flags */
 };
+#define PTRACE_GET_SYSCALL_INFO         0x420e
+#define PTRACE_SYSCALL_INFO_NONE        0
+#define PTRACE_SYSCALL_INFO_ENTRY       1
+#define PTRACE_SYSCALL_INFO_EXIT        2
+#define PTRACE_SYSCALL_INFO_SECCOMP     3
+struct ptrace_syscall_info {
+        __u8 op;        /* PTRACE_SYSCALL_INFO_* */
+        __u32 arch __attribute__((__aligned__(sizeof(__u32))));
+        __u64 instruction_pointer;
+        __u64 stack_pointer;
+        union {
+                struct {
+                        __u64 nr;
+                        __u64 args[6];
+                } entry;
+                struct {
+                        __s64 rval;
+                        __u8 is_error;
+                } exit;
+                struct {
+                        __u64 nr;
+                        __u64 args[6];
+                        __u32 ret_data;
+                } seccomp;
+        };
+};
+/*
+ * These values are stored in task->ptrace_message
+ * by tracehook_report_syscall_* to describe the current syscall-stop.
+ */
+#define PTRACE_EVENTMSG_SYSCALL_ENTRY   1
+#define PTRACE_EVENTMSG_SYSCALL_EXIT    2
 /* Read signals from a shared (process wide) queue */
 #define PTRACE_PEEKSIGINFO_SHARED       (1 << 0)
diff --git a/init/Kconfig b/init/Kconfig
index 381cdfee6e0e..bd7d650d4a99 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -1827,7 +1827,7 @@ config SLAB_FREELIST_HARDENED
        help
          Many kernel heap attacks try to target slab cache metadata and
          other infrastructure. This options makes minor performance
-          sacrifies to harden the kernel slab allocator against common
+          sacrifices to harden the kernel slab allocator against common
          freelist exploit methods.
 config SHUFFLE_PAGE_ALLOCATOR
@@ -1859,7 +1859,7 @@ config SLUB_CPU_PARTIAL
        depends on SLUB && SMP
        bool "SLUB per cpu partial cache"
        help
-          Per cpu partial caches accellerate objects allocation and freeing
+          Per cpu partial caches accelerate objects allocation and freeing
          that is local to a processor at the price of more indeterminism
          in the latency of the free. On overflow these caches will be cleared
          which requires the taking of locks that may cause latency spikes.
diff --git a/ipc/mqueue.c b/ipc/mqueue.c
index 216cad1ff0d0..65c351564ad0 100644
--- a/ipc/mqueue.c
+++ b/ipc/mqueue.c
@@ -438,7 +438,6 @@ static void mqueue_evict_inode(struct inode *inode)
 {
        struct mqueue_inode_info *info;
        struct user_struct *user;
-        unsigned long mq_bytes, mq_treesize;
        struct ipc_namespace *ipc_ns;
        struct msg_msg *msg, *nmsg;
        LIST_HEAD(tmp_msg);
@@ -461,16 +460,18 @@ static void mqueue_evict_inode(struct inode *inode)
                free_msg(msg);
        }
-        /* Total amount of bytes accounted for the mqueue */
-        mq_treesize = info->attr.mq_maxmsg * sizeof(struct msg_msg) +
-                min_t(unsigned int, info->attr.mq_maxmsg, MQ_PRIO_MAX) *
-                sizeof(struct posix_msg_tree_node);
-        mq_bytes = mq_treesize + (info->attr.mq_maxmsg *
-                                  info->attr.mq_msgsize);
        user = info->user;
        if (user) {
+                unsigned long mq_bytes, mq_treesize;
+                /* Total amount of bytes accounted for the mqueue */
+                mq_treesize = info->attr.mq_maxmsg * sizeof(struct msg_msg) +
+                        min_t(unsigned int, info->attr.mq_maxmsg, MQ_PRIO_MAX) *
+                        sizeof(struct posix_msg_tree_node);
+                mq_bytes = mq_treesize + (info->attr.mq_maxmsg *
+                                          info->attr.mq_msgsize);
                spin_lock(&mq_lock);
                user->mq_bytes -= mq_bytes;
                /*
diff --git a/kernel/pid.c b/kernel/pid.c
index 16263b526560..0a9f2e437217 100644
--- a/kernel/pid.c
+++ b/kernel/pid.c
@@ -37,14 +37,14 @@
 #include <linux/init_task.h>
 #include <linux/syscalls.h>
 #include <linux/proc_ns.h>
-#include <linux/proc_fs.h>
+#include <linux/refcount.h>
 #include <linux/anon_inodes.h>
 #include <linux/sched/signal.h>
 #include <linux/sched/task.h>
 #include <linux/idr.h>
 struct pid init_struct_pid = {
-        .count          = ATOMIC_INIT(1),
+        .count          = REFCOUNT_INIT(1),
        .tasks          = {
                { .first = NULL },
                { .first = NULL },
@@ -108,8 +108,7 @@ void put_pid(struct pid *pid)
                return;
        ns = pid->numbers[pid->level].ns;
-        if ((atomic_read(&pid->count) == 1) ||
+        if (refcount_dec_and_test(&pid->count)) {
-             atomic_dec_and_test(&pid->count)) {
                kmem_cache_free(ns->pid_cachep, pid);
                put_pid_ns(ns);
        }
@@ -212,7 +211,7 @@ struct pid *alloc_pid(struct pid_namespace *ns)
        }
        get_pid_ns(ns);
-        atomic_set(&pid->count, 1);
+        refcount_set(&pid->count, 1);
        for (type = 0; type < PIDTYPE_MAX; ++type)
                INIT_HLIST_HEAD(&pid->tasks[type]);
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index 83a531cea2f3..cb9ddcc08119 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -32,6 +32,8 @@
 #include <linux/compat.h>
 #include <linux/sched/signal.h>
+#include <asm/syscall.h>        /* for syscall_get_* */
 /*
 * Access another process' address space via ptrace.
 * Source/target buffer must be kernel space,
@@ -897,7 +899,100 @@ static int ptrace_regset(struct task_struct *task, int req, unsigned int type,
 * to ensure no machine forgets it.
 */
 EXPORT_SYMBOL_GPL(task_user_regset_view);
-#endif
+static unsigned long
+ptrace_get_syscall_info_entry(struct task_struct *child, struct pt_regs *regs,
+                              struct ptrace_syscall_info *info)
+{
+        unsigned long args[ARRAY_SIZE(info->entry.args)];
+        int i;
+        info->op = PTRACE_SYSCALL_INFO_ENTRY;
+        info->entry.nr = syscall_get_nr(child, regs);
+        syscall_get_arguments(child, regs, args);
+        for (i = 0; i < ARRAY_SIZE(args); i++)
+                info->entry.args[i] = args[i];
+        /* args is the last field in struct ptrace_syscall_info.entry */
+        return offsetofend(struct ptrace_syscall_info, entry.args);
+}
+static unsigned long
+ptrace_get_syscall_info_seccomp(struct task_struct *child, struct pt_regs *regs,
+                                struct ptrace_syscall_info *info)
+{
+        /*
+         * As struct ptrace_syscall_info.entry is currently a subset
+         * of struct ptrace_syscall_info.seccomp, it makes sense to
+         * initialize that subset using ptrace_get_syscall_info_entry().
+         * This can be reconsidered in the future if these structures
+         * diverge significantly enough.
+         */
+        ptrace_get_syscall_info_entry(child, regs, info);
+        info->op = PTRACE_SYSCALL_INFO_SECCOMP;
+        info->seccomp.ret_data = child->ptrace_message;
+        /* ret_data is the last field in struct ptrace_syscall_info.seccomp */
+        return offsetofend(struct ptrace_syscall_info, seccomp.ret_data);
+}
+static unsigned long
+ptrace_get_syscall_info_exit(struct task_struct *child, struct pt_regs *regs,
+                             struct ptrace_syscall_info *info)
+{
+        info->op = PTRACE_SYSCALL_INFO_EXIT;
+        info->exit.rval = syscall_get_error(child, regs);
+        info->exit.is_error = !!info->exit.rval;
+        if (!info->exit.is_error)
+                info->exit.rval = syscall_get_return_value(child, regs);
+        /* is_error is the last field in struct ptrace_syscall_info.exit */
+        return offsetofend(struct ptrace_syscall_info, exit.is_error);
+}
+static int
+ptrace_get_syscall_info(struct task_struct *child, unsigned long user_size,
+                        void __user *datavp)
+{
+        struct pt_regs *regs = task_pt_regs(child);
+        struct ptrace_syscall_info info = {
+                .op = PTRACE_SYSCALL_INFO_NONE,
+                .arch = syscall_get_arch(child),
+                .instruction_pointer = instruction_pointer(regs),
+                .stack_pointer = user_stack_pointer(regs),
+        };
+        unsigned long actual_size = offsetof(struct ptrace_syscall_info, entry);
+        unsigned long write_size;
+        /*
+         * This does not need lock_task_sighand() to access
+         * child->last_siginfo because ptrace_freeze_traced()
+         * called earlier by ptrace_check_attach() ensures that
+         * the tracee cannot go away and clear its last_siginfo.
+         */
+        switch (child->last_siginfo ? child->last_siginfo->si_code : 0) {
+        case SIGTRAP | 0x80:
+                switch (child->ptrace_message) {
+                case PTRACE_EVENTMSG_SYSCALL_ENTRY:
+                        actual_size = ptrace_get_syscall_info_entry(child, regs,
+                                                                    &info);
+                        break;
+                case PTRACE_EVENTMSG_SYSCALL_EXIT:
+                        actual_size = ptrace_get_syscall_info_exit(child, regs,
+                                                                   &info);
+                        break;
+                }
+                break;
+        case SIGTRAP | (PTRACE_EVENT_SECCOMP << 8):
+                actual_size = ptrace_get_syscall_info_seccomp(child, regs,
+                                                              &info);
+                break;
+        }
+        write_size = min(actual_size, user_size);
+        return copy_to_user(datavp, &info, write_size) ? -EFAULT : actual_size;
+}
+#endif /* CONFIG_HAVE_ARCH_TRACEHOOK */
 int ptrace_request(struct task_struct *child, long request,
                   unsigned long addr, unsigned long data)
@@ -1114,6 +1209,10 @@ int ptrace_request(struct task_struct *child, long request,
                        ret = __put_user(kiov.iov_len, &uiov->iov_len);
                break;
        }
+        case PTRACE_GET_SYSCALL_INFO:
+                ret = ptrace_get_syscall_info(child, addr, datavp);
+                break;
 #endif
        case PTRACE_SECCOMP_GET_FILTER:
diff --git a/kernel/signal.c b/kernel/signal.c
index dabe100d2091..91b789dd6e72 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -2951,80 +2951,49 @@ EXPORT_SYMBOL(sigprocmask);
 *
 * This is useful for syscalls such as ppoll, pselect, io_pgetevents and
 * epoll_pwait where a new sigmask is passed from userland for the syscalls.
+ *
+ * Note that it does set_restore_sigmask() in advance, so it must be always
+ * paired with restore_saved_sigmask_unless() before return from syscall.
 */
-int set_user_sigmask(const sigset_t __user *usigmask, sigset_t *set,
+int set_user_sigmask(const sigset_t __user *umask, size_t sigsetsize)
-                     sigset_t *oldset, size_t sigsetsize)
 {
-        if (!usigmask)
+        sigset_t kmask;
-                return 0;
+        if (!umask)
+                return 0;
        if (sigsetsize != sizeof(sigset_t))
                return -EINVAL;
-        if (copy_from_user(set, usigmask, sizeof(sigset_t)))
+        if (copy_from_user(&kmask, umask, sizeof(sigset_t)))
                return -EFAULT;
-        *oldset = current->blocked;
+        set_restore_sigmask();
-        set_current_blocked(set);
+        current->saved_sigmask = current->blocked;
+        set_current_blocked(&kmask);
        return 0;
 }
-EXPORT_SYMBOL(set_user_sigmask);
 #ifdef CONFIG_COMPAT
-int set_compat_user_sigmask(const compat_sigset_t __user *usigmask,
+int set_compat_user_sigmask(const compat_sigset_t __user *umask,
-                            sigset_t *set, sigset_t *oldset,
                            size_t sigsetsize)
 {
-        if (!usigmask)
+        sigset_t kmask;
-                return 0;
+        if (!umask)
+                return 0;
        if (sigsetsize != sizeof(compat_sigset_t))
                return -EINVAL;
-        if (get_compat_sigset(set, usigmask))
+        if (get_compat_sigset(&kmask, umask))
                return -EFAULT;
-        *oldset = current->blocked;
+        set_restore_sigmask();
-        set_current_blocked(set);
+        current->saved_sigmask = current->blocked;
+        set_current_blocked(&kmask);
        return 0;
 }
-EXPORT_SYMBOL(set_compat_user_sigmask);
 #endif
-/*
- * restore_user_sigmask:
- * usigmask: sigmask passed in from userland.
- * sigsaved: saved sigmask when the syscall started and changed the sigmask to
- *           usigmask.
- *
- * This is useful for syscalls such as ppoll, pselect, io_pgetevents and
- * epoll_pwait where a new sigmask is passed in from userland for the syscalls.
- */
-void restore_user_sigmask(const void __user *usigmask, sigset_t *sigsaved,
-                                bool interrupted)
-{
-        if (!usigmask)
-                return;
-        /*
-         * When signals are pending, do not restore them here.
-         * Restoring sigmask here can lead to delivering signals that the above
-         * syscalls are intended to block because of the sigmask passed in.
-         */
-        if (interrupted) {
-                current->saved_sigmask = *sigsaved;
-                set_restore_sigmask();
-                return;
-        }
-        /*
-         * This is needed because the fast syscall return path does not restore
-         * saved_sigmask when signals are not pending.
-         */
-        set_current_blocked(sigsaved);
-}
-EXPORT_SYMBOL(restore_user_sigmask);
 /**
 *  sys_rt_sigprocmask - change the list of currently blocked signals
 *  @how: whether to add, remove, or set signals
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 1c1ad1e14f21..43186ccfa139 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -188,17 +188,17 @@ extern int no_unaligned_warning;
 * enum sysctl_writes_mode - supported sysctl write modes
 *
 * @SYSCTL_WRITES_LEGACY: each write syscall must fully contain the sysctl value
- *      to be written, and multiple writes on the same sysctl file descriptor
+ *      to be written, and multiple writes on the same sysctl file descriptor
- *      will rewrite the sysctl value, regardless of file position. No warning
+ *      will rewrite the sysctl value, regardless of file position. No warning
- *      is issued when the initial position is not 0.
+ *      is issued when the initial position is not 0.
 * @SYSCTL_WRITES_WARN: same as above but warn when the initial file position is
- *      not 0.
+ *      not 0.
 * @SYSCTL_WRITES_STRICT: writes to numeric sysctl entries must always be at
- *      file position 0 and the value must be fully contained in the buffer
+ *      file position 0 and the value must be fully contained in the buffer
- *      sent to the write syscall. If dealing with strings respect the file
+ *      sent to the write syscall. If dealing with strings respect the file
- *      position, but restrict this to the max length of the buffer, anything
+ *      position, but restrict this to the max length of the buffer, anything
- *      passed the max lenght will be ignored. Multiple writes will append
+ *      passed the max length will be ignored. Multiple writes will append
- *      to the buffer.
+ *      to the buffer.
 *
 * These write modes control how current file position affects the behavior of
 * updating sysctl values through the proc interface on each write.
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index a858b55e8ac7..bc6673ab3a08 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -2076,6 +2076,14 @@ config TEST_STACKINIT
          If unsure, say N.
+config TEST_MEMINIT
+        tristate "Test heap/page initialization"
+        help
+          Test if the kernel is zero-initializing heap and page allocations.
+          This can be useful to test init_on_alloc and init_on_free features.
+          If unsure, say N.
 endif # RUNTIME_TESTING_MENU
 config MEMTEST
diff --git a/lib/Makefile b/lib/Makefile
index fdd56bc219b8..59067f51f3ab 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -92,6 +92,7 @@ obj-$(CONFIG_TEST_MEMCAT_P) += test_memcat_p.o
 obj-$(CONFIG_TEST_OBJAGG) += test_objagg.o
 obj-$(CONFIG_TEST_STACKINIT) += test_stackinit.o
 obj-$(CONFIG_TEST_BLACKHOLE_DEV) += test_blackhole_dev.o
+obj-$(CONFIG_TEST_MEMINIT) += test_meminit.o
 obj-$(CONFIG_TEST_LIVEPATCH) += livepatch/
diff --git a/lib/ioremap.c b/lib/ioremap.c
index 063213685563..0a2ffadc6d71 100644
--- a/lib/ioremap.c
+++ b/lib/ioremap.c
@@ -30,6 +30,8 @@ early_param("nohugeiomap", set_nohugeiomap);
 void __init ioremap_huge_init(void)
 {
        if (!ioremap_huge_disabled) {
+                if (arch_ioremap_p4d_supported())
+                        ioremap_p4d_capable = 1;
                if (arch_ioremap_pud_supported())
                        ioremap_pud_capable = 1;
                if (arch_ioremap_pmd_supported())
@@ -86,6 +88,9 @@ static int ioremap_try_huge_pmd(pmd_t *pmd, unsigned long addr,
        if ((end - addr) != PMD_SIZE)
                return 0;
+        if (!IS_ALIGNED(addr, PMD_SIZE))
+                return 0;
        if (!IS_ALIGNED(phys_addr, PMD_SIZE))
                return 0;
@@ -126,6 +131,9 @@ static int ioremap_try_huge_pud(pud_t *pud, unsigned long addr,
        if ((end - addr) != PUD_SIZE)
                return 0;
+        if (!IS_ALIGNED(addr, PUD_SIZE))
+                return 0;
        if (!IS_ALIGNED(phys_addr, PUD_SIZE))
                return 0;
@@ -166,6 +174,9 @@ static int ioremap_try_huge_p4d(p4d_t *p4d, unsigned long addr,
        if ((end - addr) != P4D_SIZE)
                return 0;
+        if (!IS_ALIGNED(addr, P4D_SIZE))
+                return 0;
        if (!IS_ALIGNED(phys_addr, P4D_SIZE))
                return 0;
diff --git a/lib/mpi/longlong.h b/lib/mpi/longlong.h
index 08c60d10747f..3bb6260d8f42 100644
--- a/lib/mpi/longlong.h
+++ b/lib/mpi/longlong.h
@@ -397,8 +397,8 @@ do { \
 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
        __asm__ ("addl %5,%1\n" \
           "adcl %3,%0" \
-        : "=r" ((USItype)(sh)), \
+        : "=r" (sh), \
-             "=&r" ((USItype)(sl)) \
+             "=&r" (sl) \
        : "%0" ((USItype)(ah)), \
             "g" ((USItype)(bh)), \
             "%1" ((USItype)(al)), \
@@ -406,22 +406,22 @@ do { \
 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
        __asm__ ("subl %5,%1\n" \
           "sbbl %3,%0" \
-        : "=r" ((USItype)(sh)), \
+        : "=r" (sh), \
-             "=&r" ((USItype)(sl)) \
+             "=&r" (sl) \
        : "0" ((USItype)(ah)), \
             "g" ((USItype)(bh)), \
             "1" ((USItype)(al)), \
             "g" ((USItype)(bl)))
 #define umul_ppmm(w1, w0, u, v) \
        __asm__ ("mull %3" \
-        : "=a" ((USItype)(w0)), \
+        : "=a" (w0), \
-             "=d" ((USItype)(w1)) \
+             "=d" (w1) \
        : "%0" ((USItype)(u)), \
             "rm" ((USItype)(v)))
 #define udiv_qrnnd(q, r, n1, n0, d) \
        __asm__ ("divl %4" \
-        : "=a" ((USItype)(q)), \
+        : "=a" (q), \
-             "=d" ((USItype)(r)) \
+             "=d" (r) \
        : "0" ((USItype)(n0)), \
             "1" ((USItype)(n1)), \
             "rm" ((USItype)(d)))
diff --git a/lib/rbtree.c b/lib/rbtree.c
index 1ef6e25d031c..abc86c6a3177 100644
--- a/lib/rbtree.c
+++ b/lib/rbtree.c
@@ -83,14 +83,10 @@ __rb_rotate_set_parents(struct rb_node *old, struct rb_node *new,
 static __always_inline void
 __rb_insert(struct rb_node *node, struct rb_root *root,
-            bool newleft, struct rb_node **leftmost,
            void (*augment_rotate)(struct rb_node *old, struct rb_node *new))
 {
        struct rb_node *parent = rb_red_parent(node), *gparent, *tmp;
-        if (newleft)
-                *leftmost = node;
        while (true) {
                /*
                 * Loop invariant: node is red.
@@ -437,38 +433,19 @@ static const struct rb_augment_callbacks dummy_callbacks = {
 void rb_insert_color(struct rb_node *node, struct rb_root *root)
 {
-        __rb_insert(node, root, false, NULL, dummy_rotate);
+        __rb_insert(node, root, dummy_rotate);
 }
 EXPORT_SYMBOL(rb_insert_color);
 void rb_erase(struct rb_node *node, struct rb_root *root)
 {
        struct rb_node *rebalance;
-        rebalance = __rb_erase_augmented(node, root,
+        rebalance = __rb_erase_augmented(node, root, &dummy_callbacks);
-                                         NULL, &dummy_callbacks);
        if (rebalance)
                ____rb_erase_color(rebalance, root, dummy_rotate);
 }
 EXPORT_SYMBOL(rb_erase);
-void rb_insert_color_cached(struct rb_node *node,
-                            struct rb_root_cached *root, bool leftmost)
-{
-        __rb_insert(node, &root->rb_root, leftmost,
-                    &root->rb_leftmost, dummy_rotate);
-}
-EXPORT_SYMBOL(rb_insert_color_cached);
-void rb_erase_cached(struct rb_node *node, struct rb_root_cached *root)
-{
-        struct rb_node *rebalance;
-        rebalance = __rb_erase_augmented(node, &root->rb_root,
-                                         &root->rb_leftmost, &dummy_callbacks);
-        if (rebalance)
-                ____rb_erase_color(rebalance, &root->rb_root, dummy_rotate);
-}
-EXPORT_SYMBOL(rb_erase_cached);
 /*
 * Augmented rbtree manipulation functions.
 *
@@ -477,10 +454,9 @@ EXPORT_SYMBOL(rb_erase_cached);
 */
 void __rb_insert_augmented(struct rb_node *node, struct rb_root *root,
-                           bool newleft, struct rb_node **leftmost,
        void (*augment_rotate)(struct rb_node *old, struct rb_node *new))
 {
-        __rb_insert(node, root, newleft, leftmost, augment_rotate);
+        __rb_insert(node, root, augment_rotate);
 }
 EXPORT_SYMBOL(__rb_insert_augmented);
@@ -591,16 +567,6 @@ void rb_replace_node(struct rb_node *victim, struct rb_node *new,
 }
 EXPORT_SYMBOL(rb_replace_node);
-void rb_replace_node_cached(struct rb_node *victim, struct rb_node *new,
-                            struct rb_root_cached *root)
-{
-        rb_replace_node(victim, new, &root->rb_root);
-        if (root->rb_leftmost == victim)
-                root->rb_leftmost = new;
-}
-EXPORT_SYMBOL(rb_replace_node_cached);
 void rb_replace_node_rcu(struct rb_node *victim, struct rb_node *new,
                         struct rb_root *root)
 {
diff --git a/lib/string.c b/lib/string.c
index 6016eb3ac73d..461fb620f85f 100644
--- a/lib/string.c
+++ b/lib/string.c
@@ -400,6 +400,9 @@ EXPORT_SYMBOL(strncmp);
 * strchr - Find the first occurrence of a character in a string
 * @s: The string to be searched
 * @c: The character to search for
+ *
+ * Note that the %NUL-terminator is considered part of the string, and can
+ * be searched for.
 */
 char *strchr(const char *s, int c)
 {
@@ -453,12 +456,18 @@ EXPORT_SYMBOL(strrchr);
 * @s: The string to be searched
 * @count: The number of characters to be searched
 * @c: The character to search for
+ *
+ * Note that the %NUL-terminator is considered part of the string, and can
+ * be searched for.
 */
 char *strnchr(const char *s, size_t count, int c)
 {
-        for (; count-- && *s != '\0'; ++s)
+        while (count--) {
                if (*s == (char)c)
                        return (char *)s;
+                if (*s++ == '\0')
+                        break;
+        }
        return NULL;
 }
 EXPORT_SYMBOL(strnchr);
diff --git a/lib/string_helpers.c b/lib/string_helpers.c
index 3a90a9e2b94a..963050c0283e 100644
--- a/lib/string_helpers.c
+++ b/lib/string_helpers.c
@@ -231,35 +231,36 @@ static bool unescape_special(char **src, char **dst)
 * @src:        source buffer (escaped)
 * @dst:        destination buffer (unescaped)
 * @size:       size of the destination buffer (0 to unlimit)
- * @flags:      combination of the flags (bitwise OR):
+ * @flags:      combination of the flags.
- *      %UNESCAPE_SPACE:
+ *
+ * Description:
+ * The function unquotes characters in the given string.
+ *
+ * Because the size of the output will be the same as or less than the size of
+ * the input, the transformation may be performed in place.
+ *
+ * Caller must provide valid source and destination pointers. Be aware that
+ * destination buffer will always be NULL-terminated. Source string must be
+ * NULL-terminated as well.  The supported flags are::
+ *
+ *      UNESCAPE_SPACE:
 *              '\f' - form feed
 *              '\n' - new line
 *              '\r' - carriage return
 *              '\t' - horizontal tab
 *              '\v' - vertical tab
- *      %UNESCAPE_OCTAL:
+ *      UNESCAPE_OCTAL:
 *              '\NNN' - byte with octal value NNN (1 to 3 digits)
- *      %UNESCAPE_HEX:
+ *      UNESCAPE_HEX:
 *              '\xHH' - byte with hexadecimal value HH (1 to 2 digits)
- *      %UNESCAPE_SPECIAL:
+ *      UNESCAPE_SPECIAL:
 *              '\"' - double quote
 *              '\\' - backslash
 *              '\a' - alert (BEL)
 *              '\e' - escape
- *      %UNESCAPE_ANY:
+ *      UNESCAPE_ANY:
 *              all previous together
 *
- * Description:
- * The function unquotes characters in the given string.
- *
- * Because the size of the output will be the same as or less than the size of
- * the input, the transformation may be performed in place.
- *
- * Caller must provide valid source and destination pointers. Be aware that
- * destination buffer will always be NULL-terminated. Source string must be
- * NULL-terminated as well.
- *
 * Return:
 * The amount of the characters processed to the destination buffer excluding
 * trailing '\0' is returned.
@@ -441,7 +442,29 @@ static bool escape_hex(unsigned char c, char **dst, char *end)
 * @isz:        source buffer size
 * @dst:        destination buffer (escaped)
 * @osz:        destination buffer size
- * @flags:      combination of the flags (bitwise OR):
+ * @flags:      combination of the flags
+ * @only:       NULL-terminated string containing characters used to limit
+ *              the selected escape class. If characters are included in @only
+ *              that would not normally be escaped by the classes selected
+ *              in @flags, they will be copied to @dst unescaped.
+ *
+ * Description:
+ * The process of escaping byte buffer includes several parts. They are applied
+ * in the following sequence.
+ *
+ *      1. The character is matched to the printable class, if asked, and in
+ *         case of match it passes through to the output.
+ *      2. The character is not matched to the one from @only string and thus
+ *         must go as-is to the output.
+ *      3. The character is checked if it falls into the class given by @flags.
+ *         %ESCAPE_OCTAL and %ESCAPE_HEX are going last since they cover any
+ *         character. Note that they actually can't go together, otherwise
+ *         %ESCAPE_HEX will be ignored.
+ *
+ * Caller must provide valid source and destination pointers. Be aware that
+ * destination buffer will not be NULL-terminated, thus caller have to append
+ * it if needs.   The supported flags are::
+ *
 *      %ESCAPE_SPACE: (special white space, not space itself)
 *              '\f' - form feed
 *              '\n' - new line
@@ -464,26 +487,6 @@ static bool escape_hex(unsigned char c, char **dst, char *end)
 *              all previous together
 *      %ESCAPE_HEX:
 *              '\xHH' - byte with hexadecimal value HH (2 digits)
- * @only:       NULL-terminated string containing characters used to limit
- *              the selected escape class. If characters are included in @only
- *              that would not normally be escaped by the classes selected
- *              in @flags, they will be copied to @dst unescaped.
- *
- * Description:
- * The process of escaping byte buffer includes several parts. They are applied
- * in the following sequence.
- *      1. The character is matched to the printable class, if asked, and in
- *         case of match it passes through to the output.
- *      2. The character is not matched to the one from @only string and thus
- *         must go as-is to the output.
- *      3. The character is checked if it falls into the class given by @flags.
- *         %ESCAPE_OCTAL and %ESCAPE_HEX are going last since they cover any
- *         character. Note that they actually can't go together, otherwise
- *         %ESCAPE_HEX will be ignored.
- *
- * Caller must provide valid source and destination pointers. Be aware that
- * destination buffer will not be NULL-terminated, thus caller have to append
- * it if needs.
 *
 * Return:
 * The total size of the escaped output that would be generated for
diff --git a/lib/test_meminit.c b/lib/test_meminit.c
new file mode 100644
index 000000000000..62d19f270cad
--- /dev/null
+++ b/lib/test_meminit.c
@@ -0,0 +1,364 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Test cases for SL[AOU]B/page initialization at alloc/free time.
+ */
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/vmalloc.h>
+#define GARBAGE_INT (0x09A7BA9E)
+#define GARBAGE_BYTE (0x9E)
+#define REPORT_FAILURES_IN_FN() \
+        do {    \
+                if (failures)   \
+                        pr_info("%s failed %d out of %d times\n",       \
+                                __func__, failures, num_tests);         \
+                else            \
+                        pr_info("all %d tests in %s passed\n",          \
+                                num_tests, __func__);                   \
+        } while (0)
+/* Calculate the number of uninitialized bytes in the buffer. */
+static int __init count_nonzero_bytes(void *ptr, size_t size)
+{
+        int i, ret = 0;
+        unsigned char *p = (unsigned char *)ptr;
+        for (i = 0; i < size; i++)
+                if (p[i])
+                        ret++;
+        return ret;
+}
+/* Fill a buffer with garbage, skipping |skip| first bytes. */
+static void __init fill_with_garbage_skip(void *ptr, int size, size_t skip)
+{
+        unsigned int *p = (unsigned int *)((char *)ptr + skip);
+        int i = 0;
+        WARN_ON(skip > size);
+        size -= skip;
+        while (size >= sizeof(*p)) {
+                p[i] = GARBAGE_INT;
+                i++;
+                size -= sizeof(*p);
+        }
+        if (size)
+                memset(&p[i], GARBAGE_BYTE, size);
+}
+static void __init fill_with_garbage(void *ptr, size_t size)
+{
+        fill_with_garbage_skip(ptr, size, 0);
+}
+static int __init do_alloc_pages_order(int order, int *total_failures)
+{
+        struct page *page;
+        void *buf;
+        size_t size = PAGE_SIZE << order;
+        page = alloc_pages(GFP_KERNEL, order);
+        buf = page_address(page);
+        fill_with_garbage(buf, size);
+        __free_pages(page, order);
+        page = alloc_pages(GFP_KERNEL, order);
+        buf = page_address(page);
+        if (count_nonzero_bytes(buf, size))
+                (*total_failures)++;
+        fill_with_garbage(buf, size);
+        __free_pages(page, order);
+        return 1;
+}
+/* Test the page allocator by calling alloc_pages with different orders. */
+static int __init test_pages(int *total_failures)
+{
+        int failures = 0, num_tests = 0;
+        int i;
+        for (i = 0; i < 10; i++)
+                num_tests += do_alloc_pages_order(i, &failures);
+        REPORT_FAILURES_IN_FN();
+        *total_failures += failures;
+        return num_tests;
+}
+/* Test kmalloc() with given parameters. */
+static int __init do_kmalloc_size(size_t size, int *total_failures)
+{
+        void *buf;
+        buf = kmalloc(size, GFP_KERNEL);
+        fill_with_garbage(buf, size);
+        kfree(buf);
+        buf = kmalloc(size, GFP_KERNEL);
+        if (count_nonzero_bytes(buf, size))
+                (*total_failures)++;
+        fill_with_garbage(buf, size);
+        kfree(buf);
+        return 1;
+}
+/* Test vmalloc() with given parameters. */
+static int __init do_vmalloc_size(size_t size, int *total_failures)
+{
+        void *buf;
+        buf = vmalloc(size);
+        fill_with_garbage(buf, size);
+        vfree(buf);
+        buf = vmalloc(size);
+        if (count_nonzero_bytes(buf, size))
+                (*total_failures)++;
+        fill_with_garbage(buf, size);
+        vfree(buf);
+        return 1;
+}
+/* Test kmalloc()/vmalloc() by allocating objects of different sizes. */
+static int __init test_kvmalloc(int *total_failures)
+{
+        int failures = 0, num_tests = 0;
+        int i, size;
+        for (i = 0; i < 20; i++) {
+                size = 1 << i;
+                num_tests += do_kmalloc_size(size, &failures);
+                num_tests += do_vmalloc_size(size, &failures);
+        }
+        REPORT_FAILURES_IN_FN();
+        *total_failures += failures;
+        return num_tests;
+}
+#define CTOR_BYTES (sizeof(unsigned int))
+#define CTOR_PATTERN (0x41414141)
+/* Initialize the first 4 bytes of the object. */
+static void test_ctor(void *obj)
+{
+        *(unsigned int *)obj = CTOR_PATTERN;
+}
+/*
+ * Check the invariants for the buffer allocated from a slab cache.
+ * If the cache has a test constructor, the first 4 bytes of the object must
+ * always remain equal to CTOR_PATTERN.
+ * If the cache isn't an RCU-typesafe one, or if the allocation is done with
+ * __GFP_ZERO, then the object contents must be zeroed after allocation.
+ * If the cache is an RCU-typesafe one, the object contents must never be
+ * zeroed after the first use. This is checked by memcmp() in
+ * do_kmem_cache_size().
+ */
+static bool __init check_buf(void *buf, int size, bool want_ctor,
+                             bool want_rcu, bool want_zero)
+{
+        int bytes;
+        bool fail = false;
+        bytes = count_nonzero_bytes(buf, size);
+        WARN_ON(want_ctor && want_zero);
+        if (want_zero)
+                return bytes;
+        if (want_ctor) {
+                if (*(unsigned int *)buf != CTOR_PATTERN)
+                        fail = 1;
+        } else {
+                if (bytes)
+                        fail = !want_rcu;
+        }
+        return fail;
+}
+/*
+ * Test kmem_cache with given parameters:
+ *  want_ctor - use a constructor;
+ *  want_rcu - use SLAB_TYPESAFE_BY_RCU;
+ *  want_zero - use __GFP_ZERO.
+ */
+static int __init do_kmem_cache_size(size_t size, bool want_ctor,
+                                     bool want_rcu, bool want_zero,
+                                     int *total_failures)
+{
+        struct kmem_cache *c;
+        int iter;
+        bool fail = false;
+        gfp_t alloc_mask = GFP_KERNEL | (want_zero ? __GFP_ZERO : 0);
+        void *buf, *buf_copy;
+        c = kmem_cache_create("test_cache", size, 1,
+                              want_rcu ? SLAB_TYPESAFE_BY_RCU : 0,
+                              want_ctor ? test_ctor : NULL);
+        for (iter = 0; iter < 10; iter++) {
+                buf = kmem_cache_alloc(c, alloc_mask);
+                /* Check that buf is zeroed, if it must be. */
+                fail = check_buf(buf, size, want_ctor, want_rcu, want_zero);
+                fill_with_garbage_skip(buf, size, want_ctor ? CTOR_BYTES : 0);
+                if (!want_rcu) {
+                        kmem_cache_free(c, buf);
+                        continue;
+                }
+                /*
+                 * If this is an RCU cache, use a critical section to ensure we
+                 * can touch objects after they're freed.
+                 */
+                rcu_read_lock();
+                /*
+                 * Copy the buffer to check that it's not wiped on
+                 * free().
+                 */
+                buf_copy = kmalloc(size, GFP_KERNEL);
+                if (buf_copy)
+                        memcpy(buf_copy, buf, size);
+                kmem_cache_free(c, buf);
+                /*
+                 * Check that |buf| is intact after kmem_cache_free().
+                 * |want_zero| is false, because we wrote garbage to
+                 * the buffer already.
+                 */
+                fail |= check_buf(buf, size, want_ctor, want_rcu,
+                                  false);
+                if (buf_copy) {
+                        fail |= (bool)memcmp(buf, buf_copy, size);
+                        kfree(buf_copy);
+                }
+                rcu_read_unlock();
+        }
+        kmem_cache_destroy(c);
+        *total_failures += fail;
+        return 1;
+}
+/*
+ * Check that the data written to an RCU-allocated object survives
+ * reallocation.
+ */
+static int __init do_kmem_cache_rcu_persistent(int size, int *total_failures)
+{
+        struct kmem_cache *c;
+        void *buf, *buf_contents, *saved_ptr;
+        void **used_objects;
+        int i, iter, maxiter = 1024;
+        bool fail = false;
+        c = kmem_cache_create("test_cache", size, size, SLAB_TYPESAFE_BY_RCU,
+                              NULL);
+        buf = kmem_cache_alloc(c, GFP_KERNEL);
+        saved_ptr = buf;
+        fill_with_garbage(buf, size);
+        buf_contents = kmalloc(size, GFP_KERNEL);
+        if (!buf_contents)
+                goto out;
+        used_objects = kmalloc_array(maxiter, sizeof(void *), GFP_KERNEL);
+        if (!used_objects) {
+                kfree(buf_contents);
+                goto out;
+        }
+        memcpy(buf_contents, buf, size);
+        kmem_cache_free(c, buf);
+        /*
+         * Run for a fixed number of iterations. If we never hit saved_ptr,
+         * assume the test passes.
+         */
+        for (iter = 0; iter < maxiter; iter++) {
+                buf = kmem_cache_alloc(c, GFP_KERNEL);
+                used_objects[iter] = buf;
+                if (buf == saved_ptr) {
+                        fail = memcmp(buf_contents, buf, size);
+                        for (i = 0; i <= iter; i++)
+                                kmem_cache_free(c, used_objects[i]);
+                        goto free_out;
+                }
+        }
+free_out:
+        kmem_cache_destroy(c);
+        kfree(buf_contents);
+        kfree(used_objects);
+out:
+        *total_failures += fail;
+        return 1;
+}
+/*
+ * Test kmem_cache allocation by creating caches of different sizes, with and
+ * without constructors, with and without SLAB_TYPESAFE_BY_RCU.
+ */
+static int __init test_kmemcache(int *total_failures)
+{
+        int failures = 0, num_tests = 0;
+        int i, flags, size;
+        bool ctor, rcu, zero;
+        for (i = 0; i < 10; i++) {
+                size = 8 << i;
+                for (flags = 0; flags < 8; flags++) {
+                        ctor = flags & 1;
+                        rcu = flags & 2;
+                        zero = flags & 4;
+                        if (ctor & zero)
+                                continue;
+                        num_tests += do_kmem_cache_size(size, ctor, rcu, zero,
+                                                        &failures);
+                }
+        }
+        REPORT_FAILURES_IN_FN();
+        *total_failures += failures;
+        return num_tests;
+}
+/* Test the behavior of SLAB_TYPESAFE_BY_RCU caches of different sizes. */
+static int __init test_rcu_persistent(int *total_failures)
+{
+        int failures = 0, num_tests = 0;
+        int i, size;
+        for (i = 0; i < 10; i++) {
+                size = 8 << i;
+                num_tests += do_kmem_cache_rcu_persistent(size, &failures);
+        }
+        REPORT_FAILURES_IN_FN();
+        *total_failures += failures;
+        return num_tests;
+}
+/*
+ * Run the tests. Each test function returns the number of executed tests and
+ * updates |failures| with the number of failed tests.
+ */
+static int __init test_meminit_init(void)
+{
+        int failures = 0, num_tests = 0;
+        num_tests += test_pages(&failures);
+        num_tests += test_kvmalloc(&failures);
+        num_tests += test_kmemcache(&failures);
+        num_tests += test_rcu_persistent(&failures);
+        if (failures == 0)
+                pr_info("all %d tests passed!\n", num_tests);
+        else
+                pr_info("failures: %d out of %d\n", failures, num_tests);
+        return failures ? -EINVAL : 0;
+}
+module_init(test_meminit_init);
+MODULE_LICENSE("GPL");
diff --git a/lib/test_overflow.c b/lib/test_overflow.c
index fc680562d8b6..7a4b6f6c5473 100644
--- a/lib/test_overflow.c
+++ b/lib/test_overflow.c
@@ -486,16 +486,17 @@ static int __init test_overflow_shift(void)
 * Deal with the various forms of allocator arguments. See comments above
 * the DEFINE_TEST_ALLOC() instances for mapping of the "bits".
 */
-#define alloc010(alloc, arg, sz) alloc(sz, GFP_KERNEL)
+#define alloc_GFP                (GFP_KERNEL | __GFP_NOWARN)
-#define alloc011(alloc, arg, sz) alloc(sz, GFP_KERNEL, NUMA_NO_NODE)
+#define alloc010(alloc, arg, sz) alloc(sz, alloc_GFP)
+#define alloc011(alloc, arg, sz) alloc(sz, alloc_GFP, NUMA_NO_NODE)
 #define alloc000(alloc, arg, sz) alloc(sz)
 #define alloc001(alloc, arg, sz) alloc(sz, NUMA_NO_NODE)
-#define alloc110(alloc, arg, sz) alloc(arg, sz, GFP_KERNEL)
+#define alloc110(alloc, arg, sz) alloc(arg, sz, alloc_GFP)
 #define free0(free, arg, ptr)    free(ptr)
 #define free1(free, arg, ptr)    free(arg, ptr)
-/* Wrap around to 8K */
+/* Wrap around to 16K */
-#define TEST_SIZE               (9 << PAGE_SHIFT)
+#define TEST_SIZE               (5 * 4096)
 #define DEFINE_TEST_ALLOC(func, free_func, want_arg, want_gfp, want_node)\
 static int __init test_ ## func (void *arg)                             \
diff --git a/lib/test_string.c b/lib/test_string.c
index bf8def01ed20..7b31f4a505bf 100644
--- a/lib/test_string.c
+++ b/lib/test_string.c
@@ -36,7 +36,7 @@ static __init int memset16_selftest(void)
 fail:
        kfree(p);
        if (i < 256)
-                return (i << 24) | (j << 16) | k;
+                return (i << 24) | (j << 16) | k | 0x8000;
        return 0;
 }
@@ -72,7 +72,7 @@ static __init int memset32_selftest(void)
 fail:
        kfree(p);
        if (i < 256)
-                return (i << 24) | (j << 16) | k;
+                return (i << 24) | (j << 16) | k | 0x8000;
        return 0;
 }
@@ -108,7 +108,74 @@ static __init int memset64_selftest(void)
 fail:
        kfree(p);
        if (i < 256)
-                return (i << 24) | (j << 16) | k;
+                return (i << 24) | (j << 16) | k | 0x8000;
+        return 0;
+}
+static __init int strchr_selftest(void)
+{
+        const char *test_string = "abcdefghijkl";
+        const char *empty_string = "";
+        char *result;
+        int i;
+        for (i = 0; i < strlen(test_string) + 1; i++) {
+                result = strchr(test_string, test_string[i]);
+                if (result - test_string != i)
+                        return i + 'a';
+        }
+        result = strchr(empty_string, '\0');
+        if (result != empty_string)
+                return 0x101;
+        result = strchr(empty_string, 'a');
+        if (result)
+                return 0x102;
+        result = strchr(test_string, 'z');
+        if (result)
+                return 0x103;
+        return 0;
+}
+static __init int strnchr_selftest(void)
+{
+        const char *test_string = "abcdefghijkl";
+        const char *empty_string = "";
+        char *result;
+        int i, j;
+        for (i = 0; i < strlen(test_string) + 1; i++) {
+                for (j = 0; j < strlen(test_string) + 2; j++) {
+                        result = strnchr(test_string, j, test_string[i]);
+                        if (j <= i) {
+                                if (!result)
+                                        continue;
+                                return ((i + 'a') << 8) | j;
+                        }
+                        if (result - test_string != i)
+                                return ((i + 'a') << 8) | j;
+                }
+        }
+        result = strnchr(empty_string, 0, '\0');
+        if (result)
+                return 0x10001;
+        result = strnchr(empty_string, 1, '\0');
+        if (result != empty_string)
+                return 0x10002;
+        result = strnchr(empty_string, 1, 'a');
+        if (result)
+                return 0x10003;
+        result = strnchr(NULL, 0, '\0');
+        if (result)
+                return 0x10004;
        return 0;
 }
@@ -131,6 +198,16 @@ static __init int string_selftest_init(void)
        if (subtest)
                goto fail;
+        test = 4;
+        subtest = strchr_selftest();
+        if (subtest)
+                goto fail;
+        test = 5;
+        subtest = strnchr_selftest();
+        if (subtest)
+                goto fail;
        pr_info("String selftests succeeded\n");
        return 0;
 fail:
diff --git a/mm/Kconfig b/mm/Kconfig
index 495d7368ced8..56cec636a1fc 100644
--- a/mm/Kconfig
+++ b/mm/Kconfig
@@ -649,8 +649,7 @@ config IDLE_PAGE_TRACKING
          See Documentation/admin-guide/mm/idle_page_tracking.rst for
          more details.
-# arch_add_memory() comprehends device memory
+config ARCH_HAS_PTE_DEVMAP
-config ARCH_HAS_ZONE_DEVICE
        bool
 config ZONE_DEVICE
@@ -658,7 +657,7 @@ config ZONE_DEVICE
        depends on MEMORY_HOTPLUG
        depends on MEMORY_HOTREMOVE
        depends on SPARSEMEM_VMEMMAP
-        depends on ARCH_HAS_ZONE_DEVICE
+        depends on ARCH_HAS_PTE_DEVMAP
        select XARRAY_MULTI
        help
diff --git a/mm/cma.c b/mm/cma.c
index 3340ef34c154..7fe0b8356775 100644
--- a/mm/cma.c
+++ b/mm/cma.c
@@ -278,6 +278,12 @@ int __init cma_declare_contiguous(phys_addr_t base,
         */
        alignment = max(alignment,  (phys_addr_t)PAGE_SIZE <<
                          max_t(unsigned long, MAX_ORDER - 1, pageblock_order));
+        if (fixed && base & (alignment - 1)) {
+                ret = -EINVAL;
+                pr_err("Region at %pa must be aligned to %pa bytes\n",
+                        &base, &alignment);
+                goto err;
+        }
        base = ALIGN(base, alignment);
        size = ALIGN(size, alignment);
        limit &= ~(alignment - 1);
@@ -308,6 +314,13 @@ int __init cma_declare_contiguous(phys_addr_t base,
        if (limit == 0 || limit > memblock_end)
                limit = memblock_end;
+        if (base + size > limit) {
+                ret = -EINVAL;
+                pr_err("Size (%pa) of region at %pa exceeds limit (%pa)\n",
+                        &size, &base, &limit);
+                goto err;
+        }
        /* Reserve memory */
        if (fixed) {
                if (memblock_is_region_reserved(base, size) ||
@@ -494,7 +507,7 @@ struct page *cma_alloc(struct cma *cma, size_t count, unsigned int align,
 * @pages: Allocated pages.
 * @count: Number of allocated pages.
 *
- * This function releases memory allocated by alloc_cma().
+ * This function releases memory allocated by cma_alloc().
 * It returns false when provided pages do not belong to contiguous area and
 * true otherwise.
 */
diff --git a/mm/gup.c b/mm/gup.c
index 8bbaa5523116..98f13ab37bac 100644
--- a/mm/gup.c
+++ b/mm/gup.c
@@ -1895,7 +1895,7 @@ static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end,
 }
 #endif /* CONFIG_ARCH_HAS_PTE_SPECIAL */
-#if defined(__HAVE_ARCH_PTE_DEVMAP) && defined(CONFIG_TRANSPARENT_HUGEPAGE)
+#if defined(CONFIG_ARCH_HAS_PTE_DEVMAP) && defined(CONFIG_TRANSPARENT_HUGEPAGE)
 static int __gup_device_huge(unsigned long pfn, unsigned long addr,
                unsigned long end, struct page **pages, int *nr)
 {
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index 249671873aa9..cdbb7a84cb6e 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -695,12 +695,15 @@ void __mod_memcg_state(struct mem_cgroup *memcg, int idx, int val)
        if (mem_cgroup_disabled())
                return;
-        __this_cpu_add(memcg->vmstats_local->stat[idx], val);
        x = val + __this_cpu_read(memcg->vmstats_percpu->stat[idx]);
        if (unlikely(abs(x) > MEMCG_CHARGE_BATCH)) {
                struct mem_cgroup *mi;
+                /*
+                 * Batch local counters to keep them in sync with
+                 * the hierarchical ones.
+                 */
+                __this_cpu_add(memcg->vmstats_local->stat[idx], x);
                for (mi = memcg; mi; mi = parent_mem_cgroup(mi))
                        atomic_long_add(x, &mi->vmstats[idx]);
                x = 0;
@@ -749,13 +752,15 @@ void __mod_lruvec_state(struct lruvec *lruvec, enum node_stat_item idx,
        /* Update memcg */
        __mod_memcg_state(memcg, idx, val);
-        /* Update lruvec */
-        __this_cpu_add(pn->lruvec_stat_local->count[idx], val);
        x = val + __this_cpu_read(pn->lruvec_stat_cpu->count[idx]);
        if (unlikely(abs(x) > MEMCG_CHARGE_BATCH)) {
                struct mem_cgroup_per_node *pi;
+                /*
+                 * Batch local counters to keep them in sync with
+                 * the hierarchical ones.
+                 */
+                __this_cpu_add(pn->lruvec_stat_local->count[idx], x);
                for (pi = pn; pi; pi = parent_nodeinfo(pi, pgdat->node_id))
                        atomic_long_add(x, &pi->lruvec_stat[idx]);
                x = 0;
@@ -777,12 +782,15 @@ void __count_memcg_events(struct mem_cgroup *memcg, enum vm_event_item idx,
        if (mem_cgroup_disabled())
                return;
-        __this_cpu_add(memcg->vmstats_local->events[idx], count);
        x = count + __this_cpu_read(memcg->vmstats_percpu->events[idx]);
        if (unlikely(x > MEMCG_CHARGE_BATCH)) {
                struct mem_cgroup *mi;
+                /*
+                 * Batch local counters to keep them in sync with
+                 * the hierarchical ones.
+                 */
+                __this_cpu_add(memcg->vmstats_local->events[idx], x);
                for (mi = memcg; mi; mi = parent_mem_cgroup(mi))
                        atomic_long_add(x, &mi->vmevents[idx]);
                x = 0;
diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
index 6166ba5a15f3..4ebe696138e8 100644
--- a/mm/memory_hotplug.c
+++ b/mm/memory_hotplug.c
@@ -1734,9 +1734,10 @@ static int check_memblock_offlined_cb(struct memory_block *mem, void *arg)
                endpa = PFN_PHYS(section_nr_to_pfn(mem->end_section_nr + 1))-1;
                pr_warn("removing memory fails, because memory [%pa-%pa] is onlined\n",
                        &beginpa, &endpa);
-        }
-        return ret;
+                return -EBUSY;
+        }
+        return 0;
 }
 static int check_cpu_on_node(pg_data_t *pgdat)
@@ -1819,19 +1820,9 @@ static void __release_memory_resource(resource_size_t start,
        }
 }
-/**
+static int __ref try_remove_memory(int nid, u64 start, u64 size)
- * remove_memory
- * @nid: the node ID
- * @start: physical address of the region to remove
- * @size: size of the region to remove
- *
- * NOTE: The caller must call lock_device_hotplug() to serialize hotplug
- * and online/offline operations before this call, as required by
- * try_offline_node().
- */
-void __ref __remove_memory(int nid, u64 start, u64 size)
 {
-        int ret;
+        int rc = 0;
        BUG_ON(check_hotplug_memory_range(start, size));
@@ -1839,13 +1830,13 @@ void __ref __remove_memory(int nid, u64 start, u64 size)
        /*
         * All memory blocks must be offlined before removing memory.  Check
-         * whether all memory blocks in question are offline and trigger a BUG()
+         * whether all memory blocks in question are offline and return error
         * if this is not the case.
         */
-        ret = walk_memory_range(PFN_DOWN(start), PFN_UP(start + size - 1), NULL,
+        rc = walk_memory_range(PFN_DOWN(start), PFN_UP(start + size - 1), NULL,
-                                check_memblock_offlined_cb);
+                               check_memblock_offlined_cb);
-        if (ret)
+        if (rc)
-                BUG();
+                goto done;
        /* remove memmap entry */
        firmware_map_remove(start, start + size, "System RAM");
@@ -1857,14 +1848,45 @@ void __ref __remove_memory(int nid, u64 start, u64 size)
        try_offline_node(nid);
+done:
        mem_hotplug_done();
+        return rc;
 }
-void remove_memory(int nid, u64 start, u64 size)
+/**
+ * remove_memory
+ * @nid: the node ID
+ * @start: physical address of the region to remove
+ * @size: size of the region to remove
+ *
+ * NOTE: The caller must call lock_device_hotplug() to serialize hotplug
+ * and online/offline operations before this call, as required by
+ * try_offline_node().
+ */
+void __remove_memory(int nid, u64 start, u64 size)
+{
+        /*
+         * trigger BUG() is some memory is not offlined prior to calling this
+         * function
+         */
+        if (try_remove_memory(nid, start, size))
+                BUG();
+}
+/*
+ * Remove memory if every memory block is offline, otherwise return -EBUSY is
+ * some memory is not offline
+ */
+int remove_memory(int nid, u64 start, u64 size)
 {
+        int rc;
        lock_device_hotplug();
-        __remove_memory(nid, start, size);
+        rc  = try_remove_memory(nid, start, size);
        unlock_device_hotplug();
+        return rc;
 }
 EXPORT_SYMBOL_GPL(remove_memory);
 #endif /* CONFIG_MEMORY_HOTREMOVE */
diff --git a/mm/nommu.c b/mm/nommu.c
index eb3e2e558da1..fed1b6e9c89b 100644
--- a/mm/nommu.c
+++ b/mm/nommu.c
@@ -1261,7 +1261,9 @@ unsigned long do_mmap(struct file *file,
        add_nommu_region(region);
        /* clear anonymous mappings that don't ask for uninitialized data */
-        if (!vma->vm_file && !(flags & MAP_UNINITIALIZED))
+        if (!vma->vm_file &&
+            (!IS_ENABLED(CONFIG_MMAP_ALLOW_UNINITIALIZED) ||
+             !(flags & MAP_UNINITIALIZED)))
                memset((void *)region->vm_start, 0,
                       region->vm_end - region->vm_start);
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 8fd7f45a04eb..e515bfcf7f28 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -4102,7 +4102,6 @@ static int
 __perform_reclaim(gfp_t gfp_mask, unsigned int order,
                                        const struct alloc_context *ac)
 {
-        struct reclaim_state reclaim_state;
        int progress;
        unsigned int noreclaim_flag;
        unsigned long pflags;
@@ -4114,13 +4113,10 @@ __perform_reclaim(gfp_t gfp_mask, unsigned int order,
        psi_memstall_enter(&pflags);
        fs_reclaim_acquire(gfp_mask);
        noreclaim_flag = memalloc_noreclaim_save();
-        reclaim_state.reclaimed_slab = 0;
-        current->reclaim_state = &reclaim_state;
        progress = try_to_free_pages(ac->zonelist, order, gfp_mask,
                                                                ac->nodemask);
-        current->reclaim_state = NULL;
        memalloc_noreclaim_restore(noreclaim_flag);
        fs_reclaim_release(gfp_mask);
        psi_memstall_leave(&pflags);
diff --git a/mm/shmem.c b/mm/shmem.c
index f4dce9c8670d..99497cb32e71 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -400,7 +400,7 @@ static bool shmem_confirm_swap(struct address_space *mapping,
 static int shmem_huge __read_mostly;
-#if defined(CONFIG_SYSFS) || defined(CONFIG_TMPFS)
+#if defined(CONFIG_SYSFS)
 static int shmem_parse_huge(const char *str)
 {
        if (!strcmp(str, "never"))
@@ -417,7 +417,9 @@ static int shmem_parse_huge(const char *str)
                return SHMEM_HUGE_FORCE;
        return -EINVAL;
 }
+#endif
+#if defined(CONFIG_SYSFS) || defined(CONFIG_TMPFS)
 static const char *shmem_format_huge(int huge)
 {
        switch (huge) {
diff --git a/mm/slab_common.c b/mm/slab_common.c
index 6c49dbb3769e..807490fe217a 100644
--- a/mm/slab_common.c
+++ b/mm/slab_common.c
@@ -1028,7 +1028,8 @@ struct kmem_cache *__init create_kmalloc_cache(const char *name,
 }
 struct kmem_cache *
-kmalloc_caches[NR_KMALLOC_TYPES][KMALLOC_SHIFT_HIGH + 1] __ro_after_init;
+kmalloc_caches[NR_KMALLOC_TYPES][KMALLOC_SHIFT_HIGH + 1] __ro_after_init =
+{ /* initialization for https://bugs.llvm.org/show_bug.cgi?id=42570 */ };
 EXPORT_SYMBOL(kmalloc_caches);
 /*
diff --git a/mm/util.c b/mm/util.c
index 68575a315dc5..e6351a80f248 100644
--- a/mm/util.c
+++ b/mm/util.c
@@ -7,6 +7,7 @@
 #include <linux/err.h>
 #include <linux/sched.h>
 #include <linux/sched/mm.h>
+#include <linux/sched/signal.h>
 #include <linux/sched/task_stack.h>
 #include <linux/security.h>
 #include <linux/swap.h>
@@ -300,6 +301,80 @@ void arch_pick_mmap_layout(struct mm_struct *mm, struct rlimit *rlim_stack)
 }
 #endif
+/**
+ * __account_locked_vm - account locked pages to an mm's locked_vm
+ * @mm:          mm to account against
+ * @pages:       number of pages to account
+ * @inc:         %true if @pages should be considered positive, %false if not
+ * @task:        task used to check RLIMIT_MEMLOCK
+ * @bypass_rlim: %true if checking RLIMIT_MEMLOCK should be skipped
+ *
+ * Assumes @task and @mm are valid (i.e. at least one reference on each), and
+ * that mmap_sem is held as writer.
+ *
+ * Return:
+ * * 0       on success
+ * * -ENOMEM if RLIMIT_MEMLOCK would be exceeded.
+ */
+int __account_locked_vm(struct mm_struct *mm, unsigned long pages, bool inc,
+                        struct task_struct *task, bool bypass_rlim)
+{
+        unsigned long locked_vm, limit;
+        int ret = 0;
+        lockdep_assert_held_write(&mm->mmap_sem);
+        locked_vm = mm->locked_vm;
+        if (inc) {
+                if (!bypass_rlim) {
+                        limit = task_rlimit(task, RLIMIT_MEMLOCK) >> PAGE_SHIFT;
+                        if (locked_vm + pages > limit)
+                                ret = -ENOMEM;
+                }
+                if (!ret)
+                        mm->locked_vm = locked_vm + pages;
+        } else {
+                WARN_ON_ONCE(pages > locked_vm);
+                mm->locked_vm = locked_vm - pages;
+        }
+        pr_debug("%s: [%d] caller %ps %c%lu %lu/%lu%s\n", __func__, task->pid,
+                 (void *)_RET_IP_, (inc) ? '+' : '-', pages << PAGE_SHIFT,
+                 locked_vm << PAGE_SHIFT, task_rlimit(task, RLIMIT_MEMLOCK),
+                 ret ? " - exceeded" : "");
+        return ret;
+}
+EXPORT_SYMBOL_GPL(__account_locked_vm);
+/**
+ * account_locked_vm - account locked pages to an mm's locked_vm
+ * @mm:          mm to account against, may be NULL
+ * @pages:       number of pages to account
+ * @inc:         %true if @pages should be considered positive, %false if not
+ *
+ * Assumes a non-NULL @mm is valid (i.e. at least one reference on it).
+ *
+ * Return:
+ * * 0       on success, or if mm is NULL
+ * * -ENOMEM if RLIMIT_MEMLOCK would be exceeded.
+ */
+int account_locked_vm(struct mm_struct *mm, unsigned long pages, bool inc)
+{
+        int ret;
+        if (pages == 0 || !mm)
+                return 0;
+        down_write(&mm->mmap_sem);
+        ret = __account_locked_vm(mm, pages, inc, current,
+                                  capable(CAP_IPC_LOCK));
+        up_write(&mm->mmap_sem);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(account_locked_vm);
 unsigned long vm_mmap_pgoff(struct file *file, unsigned long addr,
        unsigned long len, unsigned long prot,
        unsigned long flag, unsigned long pgoff)
diff --git a/mm/vmscan.c b/mm/vmscan.c
index f8e3dcd527b8..44df66a98f2a 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -131,6 +131,9 @@ struct scan_control {
                unsigned int file_taken;
                unsigned int taken;
        } nr;
+        /* for recording the reclaimed slab by now */
+        struct reclaim_state reclaim_state;
 };
 #ifdef ARCH_HAS_PREFETCH
@@ -238,6 +241,18 @@ static void unregister_memcg_shrinker(struct shrinker *shrinker)
 }
 #endif /* CONFIG_MEMCG_KMEM */
+static void set_task_reclaim_state(struct task_struct *task,
+                                   struct reclaim_state *rs)
+{
+        /* Check for an overwrite */
+        WARN_ON_ONCE(rs && task->reclaim_state);
+        /* Check for the nulling of an already-nulled member */
+        WARN_ON_ONCE(!rs && !task->reclaim_state);
+        task->reclaim_state = rs;
+}
 #ifdef CONFIG_MEMCG
 static bool global_reclaim(struct scan_control *sc)
 {
@@ -3191,11 +3206,13 @@ unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
        if (throttle_direct_reclaim(sc.gfp_mask, zonelist, nodemask))
                return 1;
+        set_task_reclaim_state(current, &sc.reclaim_state);
        trace_mm_vmscan_direct_reclaim_begin(order, sc.gfp_mask);
        nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
        trace_mm_vmscan_direct_reclaim_end(nr_reclaimed);
+        set_task_reclaim_state(current, NULL);
        return nr_reclaimed;
 }
@@ -3218,6 +3235,7 @@ unsigned long mem_cgroup_shrink_node(struct mem_cgroup *memcg,
        };
        unsigned long lru_pages;
+        set_task_reclaim_state(current, &sc.reclaim_state);
        sc.gfp_mask = (gfp_mask & GFP_RECLAIM_MASK) |
                        (GFP_HIGHUSER_MOVABLE & ~GFP_RECLAIM_MASK);
@@ -3235,7 +3253,9 @@ unsigned long mem_cgroup_shrink_node(struct mem_cgroup *memcg,
        trace_mm_vmscan_memcg_softlimit_reclaim_end(sc.nr_reclaimed);
+        set_task_reclaim_state(current, NULL);
        *nr_scanned = sc.nr_scanned;
        return sc.nr_reclaimed;
 }
@@ -3262,6 +3282,7 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
                .may_shrinkslab = 1,
        };
+        set_task_reclaim_state(current, &sc.reclaim_state);
        /*
         * Unlike direct reclaim via alloc_pages(), memcg's reclaim doesn't
         * take care of from where we get pages. So the node where we start the
@@ -3282,6 +3303,7 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
        psi_memstall_leave(&pflags);
        trace_mm_vmscan_memcg_reclaim_end(nr_reclaimed);
+        set_task_reclaim_state(current, NULL);
        return nr_reclaimed;
 }
@@ -3483,6 +3505,7 @@ static int balance_pgdat(pg_data_t *pgdat, int order, int classzone_idx)
                .may_unmap = 1,
        };
+        set_task_reclaim_state(current, &sc.reclaim_state);
        psi_memstall_enter(&pflags);
        __fs_reclaim_acquire();
@@ -3664,6 +3687,8 @@ out:
        snapshot_refaults(NULL, pgdat);
        __fs_reclaim_release();
        psi_memstall_leave(&pflags);
+        set_task_reclaim_state(current, NULL);
        /*
         * Return the order kswapd stopped reclaiming at as
         * prepare_kswapd_sleep() takes it into account. If another caller
@@ -3787,15 +3812,10 @@ static int kswapd(void *p)
        unsigned int classzone_idx = MAX_NR_ZONES - 1;
        pg_data_t *pgdat = (pg_data_t*)p;
        struct task_struct *tsk = current;
-        struct reclaim_state reclaim_state = {
-                .reclaimed_slab = 0,
-        };
        const struct cpumask *cpumask = cpumask_of_node(pgdat->node_id);
        if (!cpumask_empty(cpumask))
                set_cpus_allowed_ptr(tsk, cpumask);
-        current->reclaim_state = &reclaim_state;
        /*
         * Tell the memory management that we're a "memory allocator",
@@ -3857,7 +3877,6 @@ kswapd_try_sleep:
        }
        tsk->flags &= ~(PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD);
-        current->reclaim_state = NULL;
        return 0;
 }
@@ -3922,7 +3941,6 @@ void wakeup_kswapd(struct zone *zone, gfp_t gfp_flags, int order,
 */
 unsigned long shrink_all_memory(unsigned long nr_to_reclaim)
 {
-        struct reclaim_state reclaim_state;
        struct scan_control sc = {
                .nr_to_reclaim = nr_to_reclaim,
                .gfp_mask = GFP_HIGHUSER_MOVABLE,
@@ -3934,18 +3952,16 @@ unsigned long shrink_all_memory(unsigned long nr_to_reclaim)
                .hibernation_mode = 1,
        };
        struct zonelist *zonelist = node_zonelist(numa_node_id(), sc.gfp_mask);
-        struct task_struct *p = current;
        unsigned long nr_reclaimed;
        unsigned int noreclaim_flag;
        fs_reclaim_acquire(sc.gfp_mask);
        noreclaim_flag = memalloc_noreclaim_save();
-        reclaim_state.reclaimed_slab = 0;
+        set_task_reclaim_state(current, &sc.reclaim_state);
-        p->reclaim_state = &reclaim_state;
        nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
-        p->reclaim_state = NULL;
+        set_task_reclaim_state(current, NULL);
        memalloc_noreclaim_restore(noreclaim_flag);
        fs_reclaim_release(sc.gfp_mask);
@@ -4110,7 +4126,6 @@ static int __node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned in
        /* Minimum pages needed in order to stay on node */
        const unsigned long nr_pages = 1 << order;
        struct task_struct *p = current;
-        struct reclaim_state reclaim_state;
        unsigned int noreclaim_flag;
        struct scan_control sc = {
                .nr_to_reclaim = max(nr_pages, SWAP_CLUSTER_MAX),
@@ -4135,8 +4150,7 @@ static int __node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned in
         */
        noreclaim_flag = memalloc_noreclaim_save();
        p->flags |= PF_SWAPWRITE;
-        reclaim_state.reclaimed_slab = 0;
+        set_task_reclaim_state(p, &sc.reclaim_state);
-        p->reclaim_state = &reclaim_state;
        if (node_pagecache_reclaimable(pgdat) > pgdat->min_unmapped_pages) {
                /*
@@ -4148,7 +4162,7 @@ static int __node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned in
                } while (sc.nr_reclaimed < nr_pages && --sc.priority >= 0);
        }
-        p->reclaim_state = NULL;
+        set_task_reclaim_state(p, NULL);
        current->flags &= ~PF_SWAPWRITE;
        memalloc_noreclaim_restore(noreclaim_flag);
        fs_reclaim_release(sc.gfp_mask);
diff --git a/mm/z3fold.c b/mm/z3fold.c
index dfcd69d08c1e..6c72b18d8b9c 100644
--- a/mm/z3fold.c
+++ b/mm/z3fold.c
@@ -101,6 +101,7 @@ struct z3fold_buddy_slots {
 * @refcount:           reference count for the z3fold page
 * @work:               work_struct for page layout optimization
 * @slots:              pointer to the structure holding buddy slots
+ * @pool:               pointer to the containing pool
 * @cpu:                CPU which this page "belongs" to
 * @first_chunks:       the size of the first buddy in chunks, 0 if free
 * @middle_chunks:      the size of the middle buddy in chunks, 0 if free
@@ -114,6 +115,7 @@ struct z3fold_header {
        struct kref refcount;
        struct work_struct work;
        struct z3fold_buddy_slots *slots;
+        struct z3fold_pool *pool;
        short cpu;
        unsigned short first_chunks;
        unsigned short middle_chunks;
@@ -193,8 +195,10 @@ static void compact_page_work(struct work_struct *w);
 static inline struct z3fold_buddy_slots *alloc_slots(struct z3fold_pool *pool,
                                                        gfp_t gfp)
 {
-        struct z3fold_buddy_slots *slots = kmem_cache_alloc(pool->c_handle,
+        struct z3fold_buddy_slots *slots;
-                                                            gfp);
+        slots = kmem_cache_alloc(pool->c_handle,
+                                 (gfp & ~(__GFP_HIGHMEM | __GFP_MOVABLE)));
        if (slots) {
                memset(slots->slot, 0, sizeof(slots->slot));
@@ -320,6 +324,7 @@ static struct z3fold_header *init_z3fold_page(struct page *page,
        zhdr->start_middle = 0;
        zhdr->cpu = -1;
        zhdr->slots = slots;
+        zhdr->pool = pool;
        INIT_LIST_HEAD(&zhdr->buddy);
        INIT_WORK(&zhdr->work, compact_page_work);
        return zhdr;
@@ -426,7 +431,7 @@ static enum buddy handle_to_buddy(unsigned long handle)
 static inline struct z3fold_pool *zhdr_to_pool(struct z3fold_header *zhdr)
 {
-        return slots_to_pool(zhdr->slots);
+        return zhdr->pool;
 }
 static void __release_z3fold_page(struct z3fold_header *zhdr, bool locked)
@@ -850,7 +855,7 @@ static int z3fold_alloc(struct z3fold_pool *pool, size_t size, gfp_t gfp,
        enum buddy bud;
        bool can_sleep = gfpflags_allow_blocking(gfp);
-        if (!size || (gfp & __GFP_HIGHMEM))
+        if (!size)
                return -EINVAL;
        if (size > PAGE_SIZE)
@@ -1345,24 +1350,29 @@ static int z3fold_page_migrate(struct address_space *mapping, struct page *newpa
        zhdr = page_address(page);
        pool = zhdr_to_pool(zhdr);
-        if (!trylock_page(page))
-                return -EAGAIN;
        if (!z3fold_page_trylock(zhdr)) {
-                unlock_page(page);
                return -EAGAIN;
        }
        if (zhdr->mapped_count != 0) {
                z3fold_page_unlock(zhdr);
-                unlock_page(page);
                return -EBUSY;
        }
+        if (work_pending(&zhdr->work)) {
+                z3fold_page_unlock(zhdr);
+                return -EAGAIN;
+        }
        new_zhdr = page_address(newpage);
        memcpy(new_zhdr, zhdr, PAGE_SIZE);
        newpage->private = page->private;
        page->private = 0;
        z3fold_page_unlock(zhdr);
        spin_lock_init(&new_zhdr->page_lock);
+        INIT_WORK(&new_zhdr->work, compact_page_work);
+        /*
+         * z3fold_page_isolate() ensures that new_zhdr->buddy is empty,
+         * so we only have to reinitialize it.
+         */
+        INIT_LIST_HEAD(&new_zhdr->buddy);
        new_mapping = page_mapping(page);
        __ClearPageMovable(page);
        ClearPagePrivate(page);
@@ -1386,7 +1396,6 @@ static int z3fold_page_migrate(struct address_space *mapping, struct page *newpa
        queue_work_on(new_zhdr->cpu, pool->compact_wq, &new_zhdr->work);
        page_mapcount_reset(page);
-        unlock_page(page);
        put_page(page);
        return 0;
 }
diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl
index a6d436809bf5..93a7edfe0f05 100755
--- a/scripts/checkpatch.pl
+++ b/scripts/checkpatch.pl
@@ -6639,6 +6639,12 @@ sub process {
                                     "unknown module license " . $extracted_string . "\n" . $herecurr);
                        }
                }
+# check for sysctl duplicate constants
+                if ($line =~ /\.extra[12]\s*=\s*&(zero|one|int_max)\b/) {
+                        WARN("DUPLICATED_SYSCTL_CONST",
+                                "duplicated sysctl range checking value '$1', consider using the shared one in include/linux/sysctl.h\n" . $herecurr);
+                }
        }
        # If we have no input at all, then there is nothing to report on
diff --git a/scripts/gdb/linux/device.py b/scripts/gdb/linux/device.py
new file mode 100644
index 000000000000..16376c5cfec6
--- /dev/null
+++ b/scripts/gdb/linux/device.py
@@ -0,0 +1,182 @@
+# SPDX-License-Identifier: GPL-2.0
+#
+# Copyright (c) NXP 2019
+import gdb
+from linux.utils import CachedType
+from linux.utils import container_of
+from linux.lists import list_for_each_entry
+device_private_type = CachedType('struct device_private')
+device_type = CachedType('struct device')
+subsys_private_type = CachedType('struct subsys_private')
+kobject_type = CachedType('struct kobject')
+kset_type = CachedType('struct kset')
+bus_type = CachedType('struct bus_type')
+class_type = CachedType('struct class')
+def dev_name(dev):
+    dev_init_name = dev['init_name']
+    if dev_init_name:
+        return dev_init_name.string()
+    return dev['kobj']['name'].string()
+def kset_for_each_object(kset):
+    return list_for_each_entry(kset['list'],
+            kobject_type.get_type().pointer(), "entry")
+def for_each_bus():
+    for kobj in kset_for_each_object(gdb.parse_and_eval('bus_kset')):
+        subsys = container_of(kobj, kset_type.get_type().pointer(), 'kobj')
+        subsys_priv = container_of(subsys, subsys_private_type.get_type().pointer(), 'subsys')
+        yield subsys_priv['bus']
+def for_each_class():
+    for kobj in kset_for_each_object(gdb.parse_and_eval('class_kset')):
+        subsys = container_of(kobj, kset_type.get_type().pointer(), 'kobj')
+        subsys_priv = container_of(subsys, subsys_private_type.get_type().pointer(), 'subsys')
+        yield subsys_priv['class']
+def get_bus_by_name(name):
+    for item in for_each_bus():
+        if item['name'].string() == name:
+            return item
+    raise gdb.GdbError("Can't find bus type {!r}".format(name))
+def get_class_by_name(name):
+    for item in for_each_class():
+        if item['name'].string() == name:
+            return item
+    raise gdb.GdbError("Can't find device class {!r}".format(name))
+klist_type = CachedType('struct klist')
+klist_node_type = CachedType('struct klist_node')
+def klist_for_each(klist):
+    return list_for_each_entry(klist['k_list'],
+                klist_node_type.get_type().pointer(), 'n_node')
+def bus_for_each_device(bus):
+    for kn in klist_for_each(bus['p']['klist_devices']):
+        dp = container_of(kn, device_private_type.get_type().pointer(), 'knode_bus')
+        yield dp['device']
+def class_for_each_device(cls):
+    for kn in klist_for_each(cls['p']['klist_devices']):
+        dp = container_of(kn, device_private_type.get_type().pointer(), 'knode_class')
+        yield dp['device']
+def device_for_each_child(dev):
+    for kn in klist_for_each(dev['p']['klist_children']):
+        dp = container_of(kn, device_private_type.get_type().pointer(), 'knode_parent')
+        yield dp['device']
+def _show_device(dev, level=0, recursive=False):
+    gdb.write('{}dev {}:\t{}\n'.format('\t' * level, dev_name(dev), dev))
+    if recursive:
+        for child in device_for_each_child(dev):
+            _show_device(child, level + 1, recursive)
+class LxDeviceListBus(gdb.Command):
+    '''Print devices on a bus (or all buses if not specified)'''
+    def __init__(self):
+        super(LxDeviceListBus, self).__init__('lx-device-list-bus', gdb.COMMAND_DATA)
+    def invoke(self, arg, from_tty):
+        if not arg:
+            for bus in for_each_bus():
+                gdb.write('bus {}:\t{}\n'.format(bus['name'].string(), bus))
+                for dev in bus_for_each_device(bus):
+                    _show_device(dev, level=1)
+        else:
+            bus = get_bus_by_name(arg)
+            if not bus:
+                raise gdb.GdbError("Can't find bus {!r}".format(arg))
+            for dev in bus_for_each_device(bus):
+                _show_device(dev)
+class LxDeviceListClass(gdb.Command):
+    '''Print devices in a class (or all classes if not specified)'''
+    def __init__(self):
+        super(LxDeviceListClass, self).__init__('lx-device-list-class', gdb.COMMAND_DATA)
+    def invoke(self, arg, from_tty):
+        if not arg:
+            for cls in for_each_class():
+                gdb.write("class {}:\t{}\n".format(cls['name'].string(), cls))
+                for dev in class_for_each_device(cls):
+                    _show_device(dev, level=1)
+        else:
+            cls = get_class_by_name(arg)
+            for dev in class_for_each_device(cls):
+                _show_device(dev)
+class LxDeviceListTree(gdb.Command):
+    '''Print a device and its children recursively'''
+    def __init__(self):
+        super(LxDeviceListTree, self).__init__('lx-device-list-tree', gdb.COMMAND_DATA)
+    def invoke(self, arg, from_tty):
+        if not arg:
+            raise gdb.GdbError('Please provide pointer to struct device')
+        dev = gdb.parse_and_eval(arg)
+        if dev.type != device_type.get_type().pointer():
+            raise gdb.GdbError('Please provide pointer to struct device')
+        _show_device(dev, level=0, recursive=True)
+class LxDeviceFindByBusName(gdb.Function):
+    '''Find struct device by bus and name (both strings)'''
+    def __init__(self):
+        super(LxDeviceFindByBusName, self).__init__('lx_device_find_by_bus_name')
+    def invoke(self, bus, name):
+        name = name.string()
+        bus = get_bus_by_name(bus.string())
+        for dev in bus_for_each_device(bus):
+            if dev_name(dev) == name:
+                return dev
+class LxDeviceFindByClassName(gdb.Function):
+    '''Find struct device by class and name (both strings)'''
+    def __init__(self):
+        super(LxDeviceFindByClassName, self).__init__('lx_device_find_by_class_name')
+    def invoke(self, cls, name):
+        name = name.string()
+        cls = get_class_by_name(cls.string())
+        for dev in class_for_each_device(cls):
+            if dev_name(dev) == name:
+                return dev
+LxDeviceListBus()
+LxDeviceListClass()
+LxDeviceListTree()
+LxDeviceFindByBusName()
+LxDeviceFindByClassName()
diff --git a/scripts/gdb/linux/genpd.py b/scripts/gdb/linux/genpd.py
new file mode 100644
index 000000000000..6ca93bd2949e
--- /dev/null
+++ b/scripts/gdb/linux/genpd.py
@@ -0,0 +1,83 @@
+# SPDX-License-Identifier: GPL-2.0
+#
+# Copyright (c) NXP 2019
+import gdb
+import sys
+from linux.utils import CachedType
+from linux.lists import list_for_each_entry
+generic_pm_domain_type = CachedType('struct generic_pm_domain')
+pm_domain_data_type = CachedType('struct pm_domain_data')
+device_link_type = CachedType('struct device_link')
+def kobject_get_path(kobj):
+    path = kobj['name'].string()
+    parent = kobj['parent']
+    if parent:
+        path = kobject_get_path(parent) + '/' + path
+    return path
+def rtpm_status_str(dev):
+    if dev['power']['runtime_error']:
+        return 'error'
+    if dev['power']['disable_depth']:
+        return 'unsupported'
+    _RPM_STATUS_LOOKUP = [
+        "active",
+        "resuming",
+        "suspended",
+        "suspending"
+    ]
+    return _RPM_STATUS_LOOKUP[dev['power']['runtime_status']]
+class LxGenPDSummary(gdb.Command):
+    '''Print genpd summary
+Output is similar to /sys/kernel/debug/pm_genpd/pm_genpd_summary'''
+    def __init__(self):
+        super(LxGenPDSummary, self).__init__('lx-genpd-summary', gdb.COMMAND_DATA)
+    def summary_one(self, genpd):
+        if genpd['status'] == 0:
+            status_string = 'on'
+        else:
+            status_string = 'off-{}'.format(genpd['state_idx'])
+        slave_names = []
+        for link in list_for_each_entry(
+                genpd['master_links'],
+                device_link_type.get_type().pointer(),
+                'master_node'):
+            slave_names.apend(link['slave']['name'])
+        gdb.write('%-30s  %-15s %s\n' % (
+                genpd['name'].string(),
+                status_string,
+                ', '.join(slave_names)))
+        # Print devices in domain
+        for pm_data in list_for_each_entry(genpd['dev_list'],
+                        pm_domain_data_type.get_type().pointer(),
+                        'list_node'):
+            dev = pm_data['dev']
+            kobj_path = kobject_get_path(dev['kobj'])
+            gdb.write('    %-50s  %s\n' % (kobj_path, rtpm_status_str(dev)))
+    def invoke(self, arg, from_tty):
+        gdb.write('domain                          status          slaves\n');
+        gdb.write('    /device                                             runtime status\n');
+        gdb.write('----------------------------------------------------------------------\n');
+        for genpd in list_for_each_entry(
+                gdb.parse_and_eval('&gpd_list'),
+                generic_pm_domain_type.get_type().pointer(),
+                'gpd_list_node'):
+            self.summary_one(genpd)
+LxGenPDSummary()
diff --git a/scripts/gdb/vmlinux-gdb.py b/scripts/gdb/vmlinux-gdb.py
index eff5a48ac026..4136dc2c59df 100644
--- a/scripts/gdb/vmlinux-gdb.py
+++ b/scripts/gdb/vmlinux-gdb.py
@@ -35,3 +35,5 @@ else:
    import linux.constants
    import linux.timerlist
    import linux.clk
+    import linux.genpd
+    import linux.device
diff --git a/scripts/get_maintainer.pl b/scripts/get_maintainer.pl
index c1c088ef1420..5ef59214c555 100755
--- a/scripts/get_maintainer.pl
+++ b/scripts/get_maintainer.pl
@@ -27,6 +27,7 @@ my $email_usename = 1;
 my $email_maintainer = 1;
 my $email_reviewer = 1;
 my $email_list = 1;
+my $email_moderated_list = 1;
 my $email_subscriber_list = 0;
 my $email_git_penguin_chiefs = 0;
 my $email_git = 0;
@@ -248,6 +249,7 @@ if (!GetOptions(
                'r!' => \$email_reviewer,
                'n!' => \$email_usename,
                'l!' => \$email_list,
+                'moderated!' => \$email_moderated_list,
                's!' => \$email_subscriber_list,
                'multiline!' => \$output_multiline,
                'roles!' => \$output_roles,
@@ -1023,7 +1025,8 @@ MAINTAINER field selection options:
    --r => include reviewer(s) if any
    --n => include name 'Full Name <addr\@domain.tld>'
    --l => include list(s) if any
-    --s => include subscriber only list(s) if any
+    --moderated => include moderated lists(s) if any (default: true)
+    --s => include subscriber only list(s) if any (default: false)
    --remove-duplicates => minimize duplicate email names/addresses
    --roles => show roles (status:subsystem, git-signer, list, etc...)
    --rolestats => show roles and statistics (commits/total_commits, %)
@@ -1313,11 +1316,14 @@ sub add_categories {
                } else {
                    if ($email_list) {
                        if (!$hash_list_to{lc($list_address)}) {
-                            $hash_list_to{lc($list_address)} = 1;
                            if ($list_additional =~ m/moderated/) {
-                                push(@list_to, [$list_address,
+                                if ($email_moderated_list) {
-                                                "moderated list${list_role}"]);
+                                    $hash_list_to{lc($list_address)} = 1;
+                                    push(@list_to, [$list_address,
+                                                    "moderated list${list_role}"]);
+                                }
                            } else {
+                                $hash_list_to{lc($list_address)} = 1;
                                push(@list_to, [$list_address,
                                                "open list${list_role}"]);
                            }
diff --git a/sound/soc/qcom/qdsp6/q6asm.c b/sound/soc/qcom/qdsp6/q6asm.c
index 4f85cb19a309..e8141a33a55e 100644
--- a/sound/soc/qcom/qdsp6/q6asm.c
+++ b/sound/soc/qcom/qdsp6/q6asm.c
@@ -1194,7 +1194,7 @@ EXPORT_SYMBOL_GPL(q6asm_open_read);
 * q6asm_write_async() - non blocking write
 *
 * @ac: audio client pointer
- * @len: lenght in bytes
+ * @len: length in bytes
 * @msw_ts: timestamp msw
 * @lsw_ts: timestamp lsw
 * @wflags: flags associated with write
diff --git a/tools/testing/selftests/proc/.gitignore b/tools/testing/selftests/proc/.gitignore
index 444ad39d3700..66fab4c58ed4 100644
--- a/tools/testing/selftests/proc/.gitignore
+++ b/tools/testing/selftests/proc/.gitignore
@@ -12,4 +12,5 @@
 /read
 /self
 /setns-dcache
+/setns-sysvipc
 /thread-self
diff --git a/tools/testing/selftests/proc/Makefile b/tools/testing/selftests/proc/Makefile
index 9f09fcd09ea3..a8ed0f684829 100644
--- a/tools/testing/selftests/proc/Makefile
+++ b/tools/testing/selftests/proc/Makefile
@@ -17,6 +17,7 @@ TEST_GEN_PROGS += proc-uptime-002
 TEST_GEN_PROGS += read
 TEST_GEN_PROGS += self
 TEST_GEN_PROGS += setns-dcache
+TEST_GEN_PROGS += setns-sysvipc
 TEST_GEN_PROGS += thread-self
 include ../lib.mk
diff --git a/tools/testing/selftests/proc/proc-pid-vm.c b/tools/testing/selftests/proc/proc-pid-vm.c
index 853aa164a401..18a3bde8bc96 100644
--- a/tools/testing/selftests/proc/proc-pid-vm.c
+++ b/tools/testing/selftests/proc/proc-pid-vm.c
@@ -215,6 +215,11 @@ static const char str_vsyscall[] =
 "ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0                  [vsyscall]\n";
 #ifdef __x86_64__
+static void sigaction_SIGSEGV(int _, siginfo_t *__, void *___)
+{
+        _exit(1);
+}
 /*
 * vsyscall page can't be unmapped, probe it with memory load.
 */
@@ -231,11 +236,19 @@ static void vsyscall(void)
        if (pid == 0) {
                struct rlimit rlim = {0, 0};
                (void)setrlimit(RLIMIT_CORE, &rlim);
+                /* Hide "segfault at ffffffffff600000" messages. */
+                struct sigaction act;
+                memset(&act, 0, sizeof(struct sigaction));
+                act.sa_flags = SA_SIGINFO;
+                act.sa_sigaction = sigaction_SIGSEGV;
+                (void)sigaction(SIGSEGV, &act, NULL);
                *(volatile int *)0xffffffffff600000UL;
                exit(0);
        }
-        wait(&wstatus);
+        waitpid(pid, &wstatus, 0);
-        if (WIFEXITED(wstatus)) {
+        if (WIFEXITED(wstatus) && WEXITSTATUS(wstatus) == 0) {
                g_vsyscall = true;
        }
 }
diff --git a/tools/testing/selftests/proc/setns-sysvipc.c b/tools/testing/selftests/proc/setns-sysvipc.c
new file mode 100644
index 000000000000..903890c5e587
--- /dev/null
+++ b/tools/testing/selftests/proc/setns-sysvipc.c
@@ -0,0 +1,133 @@
+/*
+ * Copyright © 2019 Alexey Dobriyan <adobriyan@gmail.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+/*
+ * Test that setns(CLONE_NEWIPC) points to new /proc/sysvipc content even
+ * if old one is in dcache.
+ */
+#undef NDEBUG
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <sched.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+static pid_t pid = -1;
+static void f(void)
+{
+        if (pid > 0) {
+                kill(pid, SIGTERM);
+        }
+}
+int main(void)
+{
+        int fd[2];
+        char _ = 0;
+        int nsfd;
+        atexit(f);
+        /* Check for priviledges and syscall availability straight away. */
+        if (unshare(CLONE_NEWIPC) == -1) {
+                if (errno == ENOSYS || errno == EPERM) {
+                        return 4;
+                }
+                return 1;
+        }
+        /* Distinguisher between two otherwise empty IPC namespaces. */
+        if (shmget(IPC_PRIVATE, 1, IPC_CREAT) == -1) {
+                return 1;
+        }
+        if (pipe(fd) == -1) {
+                return 1;
+        }
+        pid = fork();
+        if (pid == -1) {
+                return 1;
+        }
+        if (pid == 0) {
+                if (unshare(CLONE_NEWIPC) == -1) {
+                        return 1;
+                }
+                if (write(fd[1], &_, 1) != 1) {
+                        return 1;
+                }
+                pause();
+                return 0;
+        }
+        if (read(fd[0], &_, 1) != 1) {
+                return 1;
+        }
+        {
+                char buf[64];
+                snprintf(buf, sizeof(buf), "/proc/%u/ns/ipc", pid);
+                nsfd = open(buf, O_RDONLY);
+                if (nsfd == -1) {
+                        return 1;
+                }
+        }
+        /* Reliably pin dentry into dcache. */
+        (void)open("/proc/sysvipc/shm", O_RDONLY);
+        if (setns(nsfd, CLONE_NEWIPC) == -1) {
+                return 1;
+        }
+        kill(pid, SIGTERM);
+        pid = 0;
+        {
+                char buf[4096];
+                ssize_t rv;
+                int fd;
+                fd = open("/proc/sysvipc/shm", O_RDONLY);
+                if (fd == -1) {
+                        return 1;
+                }
+#define S32 "       key      shmid perms       size  cpid  lpid nattch   uid   gid  cuid  cgid      atime      dtime      ctime        rss       swap\n"
+#define S64 "       key      shmid perms                  size  cpid  lpid nattch   uid   gid  cuid  cgid      atime      dtime      ctime                   rss                  swap\n"
+                rv = read(fd, buf, sizeof(buf));
+                if (rv == strlen(S32)) {
+                        assert(memcmp(buf, S32, strlen(S32)) == 0);
+                } else if (rv == strlen(S64)) {
+                        assert(memcmp(buf, S64, strlen(S64)) == 0);
+                } else {
+                        assert(0);
+                }
+        }
+        return 0;
+}
diff --git a/tools/testing/selftests/ptrace/.gitignore b/tools/testing/selftests/ptrace/.gitignore
index b3e59d41fd82..cfcc49a7def7 100644
--- a/tools/testing/selftests/ptrace/.gitignore
+++ b/tools/testing/selftests/ptrace/.gitignore
@@ -1 +1,2 @@
+get_syscall_info
 peeksiginfo
diff --git a/tools/testing/selftests/ptrace/Makefile b/tools/testing/selftests/ptrace/Makefile
index cb21c76a18ca..c0b7f89f0930 100644
--- a/tools/testing/selftests/ptrace/Makefile
+++ b/tools/testing/selftests/ptrace/Makefile
@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: GPL-2.0-only
 CFLAGS += -iquote../../../../include/uapi -Wall
-TEST_GEN_PROGS := peeksiginfo
+TEST_GEN_PROGS := get_syscall_info peeksiginfo
 include ../lib.mk
diff --git a/tools/testing/selftests/ptrace/get_syscall_info.c b/tools/testing/selftests/ptrace/get_syscall_info.c
new file mode 100644
index 000000000000..5bcd1c7b5be6
--- /dev/null
+++ b/tools/testing/selftests/ptrace/get_syscall_info.c
@@ -0,0 +1,271 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (c) 2018 Dmitry V. Levin <ldv@altlinux.org>
+ * All rights reserved.
+ *
+ * Check whether PTRACE_GET_SYSCALL_INFO semantics implemented in the kernel
+ * matches userspace expectations.
+ */
+#include "../kselftest_harness.h"
+#include <err.h>
+#include <signal.h>
+#include <asm/unistd.h>
+#include "linux/ptrace.h"
+static int
+kill_tracee(pid_t pid)
+{
+        if (!pid)
+                return 0;
+        int saved_errno = errno;
+        int rc = kill(pid, SIGKILL);
+        errno = saved_errno;
+        return rc;
+}
+static long
+sys_ptrace(int request, pid_t pid, unsigned long addr, unsigned long data)
+{
+        return syscall(__NR_ptrace, request, pid, addr, data);
+}
+#define LOG_KILL_TRACEE(fmt, ...)                               \
+        do {                                                    \
+                kill_tracee(pid);                               \
+                TH_LOG("wait #%d: " fmt,                        \
+                       ptrace_stop, ##__VA_ARGS__);             \
+        } while (0)
+TEST(get_syscall_info)
+{
+        static const unsigned long args[][7] = {
+                /* a sequence of architecture-agnostic syscalls */
+                {
+                        __NR_chdir,
+                        (unsigned long) "",
+                        0xbad1fed1,
+                        0xbad2fed2,
+                        0xbad3fed3,
+                        0xbad4fed4,
+                        0xbad5fed5
+                },
+                {
+                        __NR_gettid,
+                        0xcaf0bea0,
+                        0xcaf1bea1,
+                        0xcaf2bea2,
+                        0xcaf3bea3,
+                        0xcaf4bea4,
+                        0xcaf5bea5
+                },
+                {
+                        __NR_exit_group,
+                        0,
+                        0xfac1c0d1,
+                        0xfac2c0d2,
+                        0xfac3c0d3,
+                        0xfac4c0d4,
+                        0xfac5c0d5
+                }
+        };
+        const unsigned long *exp_args;
+        pid_t pid = fork();
+        ASSERT_LE(0, pid) {
+                TH_LOG("fork: %m");
+        }
+        if (pid == 0) {
+                /* get the pid before PTRACE_TRACEME */
+                pid = getpid();
+                ASSERT_EQ(0, sys_ptrace(PTRACE_TRACEME, 0, 0, 0)) {
+                        TH_LOG("PTRACE_TRACEME: %m");
+                }
+                ASSERT_EQ(0, kill(pid, SIGSTOP)) {
+                        /* cannot happen */
+                        TH_LOG("kill SIGSTOP: %m");
+                }
+                for (unsigned int i = 0; i < ARRAY_SIZE(args); ++i) {
+                        syscall(args[i][0],
+                                args[i][1], args[i][2], args[i][3],
+                                args[i][4], args[i][5], args[i][6]);
+                }
+                /* unreachable */
+                _exit(1);
+        }
+        const struct {
+                unsigned int is_error;
+                int rval;
+        } *exp_param, exit_param[] = {
+                { 1, -ENOENT }, /* chdir */
+                { 0, pid }      /* gettid */
+        };
+        unsigned int ptrace_stop;
+        for (ptrace_stop = 0; ; ++ptrace_stop) {
+                struct ptrace_syscall_info info = {
+                        .op = 0xff      /* invalid PTRACE_SYSCALL_INFO_* op */
+                };
+                const size_t size = sizeof(info);
+                const int expected_none_size =
+                        (void *) &info.entry - (void *) &info;
+                const int expected_entry_size =
+                        (void *) &info.entry.args[6] - (void *) &info;
+                const int expected_exit_size =
+                        (void *) (&info.exit.is_error + 1) -
+                        (void *) &info;
+                int status;
+                long rc;
+                ASSERT_EQ(pid, wait(&status)) {
+                        /* cannot happen */
+                        LOG_KILL_TRACEE("wait: %m");
+                }
+                if (WIFEXITED(status)) {
+                        pid = 0;        /* the tracee is no more */
+                        ASSERT_EQ(0, WEXITSTATUS(status));
+                        break;
+                }
+                ASSERT_FALSE(WIFSIGNALED(status)) {
+                        pid = 0;        /* the tracee is no more */
+                        LOG_KILL_TRACEE("unexpected signal %u",
+                                        WTERMSIG(status));
+                }
+                ASSERT_TRUE(WIFSTOPPED(status)) {
+                        /* cannot happen */
+                        LOG_KILL_TRACEE("unexpected wait status %#x", status);
+                }
+                switch (WSTOPSIG(status)) {
+                case SIGSTOP:
+                        ASSERT_EQ(0, ptrace_stop) {
+                                LOG_KILL_TRACEE("unexpected signal stop");
+                        }
+                        ASSERT_EQ(0, sys_ptrace(PTRACE_SETOPTIONS, pid, 0,
+                                                PTRACE_O_TRACESYSGOOD)) {
+                                LOG_KILL_TRACEE("PTRACE_SETOPTIONS: %m");
+                        }
+                        ASSERT_LT(0, (rc = sys_ptrace(PTRACE_GET_SYSCALL_INFO,
+                                                      pid, size,
+                                                      (unsigned long) &info))) {
+                                LOG_KILL_TRACEE("PTRACE_GET_SYSCALL_INFO: %m");
+                        }
+                        ASSERT_EQ(expected_none_size, rc) {
+                                LOG_KILL_TRACEE("signal stop mismatch");
+                        }
+                        ASSERT_EQ(PTRACE_SYSCALL_INFO_NONE, info.op) {
+                                LOG_KILL_TRACEE("signal stop mismatch");
+                        }
+                        ASSERT_TRUE(info.arch) {
+                                LOG_KILL_TRACEE("signal stop mismatch");
+                        }
+                        ASSERT_TRUE(info.instruction_pointer) {
+                                LOG_KILL_TRACEE("signal stop mismatch");
+                        }
+                        ASSERT_TRUE(info.stack_pointer) {
+                                LOG_KILL_TRACEE("signal stop mismatch");
+                        }
+                        break;
+                case SIGTRAP | 0x80:
+                        ASSERT_LT(0, (rc = sys_ptrace(PTRACE_GET_SYSCALL_INFO,
+                                                      pid, size,
+                                                      (unsigned long) &info))) {
+                                LOG_KILL_TRACEE("PTRACE_GET_SYSCALL_INFO: %m");
+                        }
+                        switch (ptrace_stop) {
+                        case 1: /* entering chdir */
+                        case 3: /* entering gettid */
+                        case 5: /* entering exit_group */
+                                exp_args = args[ptrace_stop / 2];
+                                ASSERT_EQ(expected_entry_size, rc) {
+                                        LOG_KILL_TRACEE("entry stop mismatch");
+                                }
+                                ASSERT_EQ(PTRACE_SYSCALL_INFO_ENTRY, info.op) {
+                                        LOG_KILL_TRACEE("entry stop mismatch");
+                                }
+                                ASSERT_TRUE(info.arch) {
+                                        LOG_KILL_TRACEE("entry stop mismatch");
+                                }
+                                ASSERT_TRUE(info.instruction_pointer) {
+                                        LOG_KILL_TRACEE("entry stop mismatch");
+                                }
+                                ASSERT_TRUE(info.stack_pointer) {
+                                        LOG_KILL_TRACEE("entry stop mismatch");
+                                }
+                                ASSERT_EQ(exp_args[0], info.entry.nr) {
+                                        LOG_KILL_TRACEE("entry stop mismatch");
+                                }
+                                ASSERT_EQ(exp_args[1], info.entry.args[0]) {
+                                        LOG_KILL_TRACEE("entry stop mismatch");
+                                }
+                                ASSERT_EQ(exp_args[2], info.entry.args[1]) {
+                                        LOG_KILL_TRACEE("entry stop mismatch");
+                                }
+                                ASSERT_EQ(exp_args[3], info.entry.args[2]) {
+                                        LOG_KILL_TRACEE("entry stop mismatch");
+                                }
+                                ASSERT_EQ(exp_args[4], info.entry.args[3]) {
+                                        LOG_KILL_TRACEE("entry stop mismatch");
+                                }
+                                ASSERT_EQ(exp_args[5], info.entry.args[4]) {
+                                        LOG_KILL_TRACEE("entry stop mismatch");
+                                }
+                                ASSERT_EQ(exp_args[6], info.entry.args[5]) {
+                                        LOG_KILL_TRACEE("entry stop mismatch");
+                                }
+                                break;
+                        case 2: /* exiting chdir */
+                        case 4: /* exiting gettid */
+                                exp_param = &exit_param[ptrace_stop / 2 - 1];
+                                ASSERT_EQ(expected_exit_size, rc) {
+                                        LOG_KILL_TRACEE("exit stop mismatch");
+                                }
+                                ASSERT_EQ(PTRACE_SYSCALL_INFO_EXIT, info.op) {
+                                        LOG_KILL_TRACEE("exit stop mismatch");
+                                }
+                                ASSERT_TRUE(info.arch) {
+                                        LOG_KILL_TRACEE("exit stop mismatch");
+                                }
+                                ASSERT_TRUE(info.instruction_pointer) {
+                                        LOG_KILL_TRACEE("exit stop mismatch");
+                                }
+                                ASSERT_TRUE(info.stack_pointer) {
+                                        LOG_KILL_TRACEE("exit stop mismatch");
+                                }
+                                ASSERT_EQ(exp_param->is_error,
+                                          info.exit.is_error) {
+                                        LOG_KILL_TRACEE("exit stop mismatch");
+                                }
+                                ASSERT_EQ(exp_param->rval, info.exit.rval) {
+                                        LOG_KILL_TRACEE("exit stop mismatch");
+                                }
+                                break;
+                        default:
+                                LOG_KILL_TRACEE("unexpected syscall stop");
+                                abort();
+                        }
+                        break;
+                default:
+                        LOG_KILL_TRACEE("unexpected stop signal %#x",
+                                        WSTOPSIG(status));
+                        abort();
+                }
+                ASSERT_EQ(0, sys_ptrace(PTRACE_SYSCALL, pid, 0, 0)) {
+                        LOG_KILL_TRACEE("PTRACE_SYSCALL: %m");
+                }
+        }
+        ASSERT_EQ(ARRAY_SIZE(args) * 2, ptrace_stop);
+}
+TEST_HARNESS_MAIN
diff --git a/tools/testing/selftests/seccomp/seccomp_bpf.c b/tools/testing/selftests/seccomp/seccomp_bpf.c
index dc66fe852768..6ef7f16c4cf5 100644
--- a/tools/testing/selftests/seccomp/seccomp_bpf.c
+++ b/tools/testing/selftests/seccomp/seccomp_bpf.c
@@ -1775,13 +1775,18 @@ void tracer_ptrace(struct __test_metadata *_metadata, pid_t tracee,
        unsigned long msg;
        static bool entry;
-        /* Make sure we got an empty message. */
+        /*
+         * The traditional way to tell PTRACE_SYSCALL entry/exit
+         * is by counting.
+         */
+        entry = !entry;
+        /* Make sure we got an appropriate message. */
        ret = ptrace(PTRACE_GETEVENTMSG, tracee, NULL, &msg);
        EXPECT_EQ(0, ret);
-        EXPECT_EQ(0, msg);
+        EXPECT_EQ(entry ? PTRACE_EVENTMSG_SYSCALL_ENTRY
+                        : PTRACE_EVENTMSG_SYSCALL_EXIT, msg);
-        /* The only way to tell PTRACE_SYSCALL entry/exit is by counting. */
-        entry = !entry;
        if (!entry)
                return;
author	Linus Torvalds <torvalds@linux-foundation.org>	2019-07-17 11:58:04 -0400
committer	Linus Torvalds <torvalds@linux-foundation.org>	2019-07-17 11:58:04 -0400
commit	57a8ec387e1441ea5e1232bc0749fb99a8cba7e7 (patch)
tree	b5fb03fc6bc5754de8b5b1f8b0e4f36d67c8315c
parent	0a8ad0ffa4d80a544f6cbff703bf6394339afcdf (diff)
parent	43e11fa2d1d3b6e35629fa556eb7d571edba2010 (diff)