Merge tag 'arm64-upstream' of git://git.kernel.org/pub/scm/linux/kernel/git/arm64/linux

Pull arm64 updates from Catalin Marinas:

 - kdump support, including two necessary memblock additions:
   memblock_clear_nomap() and memblock_cap_memory_range()

 - ARMv8.3 HWCAP bits for JavaScript conversion instructions, complex
   numbers and weaker release consistency

 - arm64 ACPI platform MSI support

 - arm perf updates: ACPI PMU support, L3 cache PMU in some Qualcomm
   SoCs, Cortex-A53 L2 cache events and DTLB refills, MAINTAINERS update
   for DT perf bindings

 - architected timer errata framework (the arch/arm64 changes only)

 - support for DMA_ATTR_FORCE_CONTIGUOUS in the arm64 iommu DMA API

 - arm64 KVM refactoring to use common system register definitions

 - remove support for ASID-tagged VIVT I-cache (no ARMv8 implementation
   using it and deprecated in the architecture) together with some
   I-cache handling clean-up

 - PE/COFF EFI header clean-up/hardening

 - define BUG() instruction without CONFIG_BUG

* tag 'arm64-upstream' of git://git.kernel.org/pub/scm/linux/kernel/git/arm64/linux: (92 commits)
  arm64: Fix the DMA mmap and get_sgtable API with DMA_ATTR_FORCE_CONTIGUOUS
  arm64: Print DT machine model in setup_machine_fdt()
  arm64: pmu: Wire-up Cortex A53 L2 cache events and DTLB refills
  arm64: module: split core and init PLT sections
  arm64: pmuv3: handle pmuv3+
  arm64: Add CNTFRQ_EL0 trap handler
  arm64: Silence spurious kbuild warning on menuconfig
  arm64: pmuv3: use arm_pmu ACPI framework
  arm64: pmuv3: handle !PMUv3 when probing
  drivers/perf: arm_pmu: add ACPI framework
  arm64: add function to get a cpu's MADT GICC table
  drivers/perf: arm_pmu: split out platform device probe logic
  drivers/perf: arm_pmu: move irq request/free into probe
  drivers/perf: arm_pmu: split cpu-local irq request/free
  drivers/perf: arm_pmu: rename irq request/free functions
  drivers/perf: arm_pmu: handle no platform_device
  drivers/perf: arm_pmu: simplify cpu_pmu_request_irqs()
  drivers/perf: arm_pmu: factor out pmu registration
  drivers/perf: arm_pmu: fold init into alloc
  drivers/perf: arm_pmu: define armpmu_init_fn
  ...

1 files changed, 36 insertions, 19 deletions

diff --git a/arch/arm64/mm/fault.c b/arch/arm64/mm/fault.c
index 1b35b8bddbfb..37b95dff0b07 100644
--- a/arch/arm64/mm/fault.c
+++ b/arch/arm64/mm/fault.c
@@ -174,12 +174,33 @@ static bool is_el1_instruction_abort(unsigned int esr)
         return ESR_ELx_EC(esr) == ESR_ELx_EC_IABT_CUR;
 }
 
+static inline bool is_permission_fault(unsigned int esr, struct pt_regs *regs,
+                                       unsigned long addr)
+{
+        unsigned int ec       = ESR_ELx_EC(esr);
+        unsigned int fsc_type = esr & ESR_ELx_FSC_TYPE;
+
+        if (ec != ESR_ELx_EC_DABT_CUR && ec != ESR_ELx_EC_IABT_CUR)
+                return false;
+
+        if (fsc_type == ESR_ELx_FSC_PERM)
+                return true;
+
+        if (addr < USER_DS && system_uses_ttbr0_pan())
+                return fsc_type == ESR_ELx_FSC_FAULT &&
+                        (regs->pstate & PSR_PAN_BIT);
+
+        return false;
+}
+
 /*
  * The kernel tried to access some page that wasn't present.
  */
 static void __do_kernel_fault(struct mm_struct *mm, unsigned long addr,
                               unsigned int esr, struct pt_regs *regs)
 {
+        const char *msg;
+
         /*
          * Are we prepared to handle this kernel fault?
          * We are almost certainly not prepared to handle instruction faults.
@@ -191,9 +212,20 @@ static void __do_kernel_fault(struct mm_struct *mm, unsigned long addr,
          * No handler, we'll have to terminate things with extreme prejudice.
          */
         bust_spinlocks(1);
-        pr_alert("Unable to handle kernel %s at virtual address %08lx\n",
-                 (addr < PAGE_SIZE) ? "NULL pointer dereference" :
-                 "paging request", addr);
+
+        if (is_permission_fault(esr, regs, addr)) {
+                if (esr & ESR_ELx_WNR)
+                        msg = "write to read-only memory";
+                else
+                        msg = "read from unreadable memory";
+        } else if (addr < PAGE_SIZE) {
+                msg = "NULL pointer dereference";
+        } else {
+                msg = "paging request";
+        }
+
+        pr_alert("Unable to handle kernel %s at virtual address %08lx\n", msg,
+                 addr);
 
         show_pte(mm, addr);
         die("Oops", regs, esr);
@@ -287,21 +319,6 @@ out:
         return fault;
 }
 
-static inline bool is_permission_fault(unsigned int esr, struct pt_regs *regs)
-{
-        unsigned int ec       = ESR_ELx_EC(esr);
-        unsigned int fsc_type = esr & ESR_ELx_FSC_TYPE;
-
-        if (ec != ESR_ELx_EC_DABT_CUR && ec != ESR_ELx_EC_IABT_CUR)
-                return false;
-
-        if (system_uses_ttbr0_pan())
-                return fsc_type == ESR_ELx_FSC_FAULT &&
-                        (regs->pstate & PSR_PAN_BIT);
-        else
-                return fsc_type == ESR_ELx_FSC_PERM;
-}
-
 static bool is_el0_instruction_abort(unsigned int esr)
 {
         return ESR_ELx_EC(esr) == ESR_ELx_EC_IABT_LOW;
@@ -339,7 +356,7 @@ static int __kprobes do_page_fault(unsigned long addr, unsigned int esr,
                 mm_flags |= FAULT_FLAG_WRITE;
         }
 
-        if (addr < USER_DS && is_permission_fault(esr, regs)) {
+        if (addr < USER_DS && is_permission_fault(esr, regs, addr)) {
                 /* regs->orig_addr_limit may be 0 if we entered from EL0 */
                 if (regs->orig_addr_limit == KERNEL_DS)
                         die("Accessing user space memory with fs=KERNEL_DS", regs, esr);