xtensa: allow handling protection faults in noMMU
Max Filippov
maintainercover xtensa: allow handling protection faults in noMMU
Hello,
most xtensa cores have some sort of memory protection mechanism, even those without full MMU. This series separates protection fault handling from the CONFIG_MMU setting and allows noMMU configurations to also do it. This improves userspace behavior in case of errors such as passing NULL pointer to a syscall that expects a valid memory pointer:
instead of killing the process the kernel is now able to return -EINVAL from a syscall.
Max Filippov (3):
xtensa: move asid_cache from fault.c to mmu.c
xtensa: extract vmalloc_fault code into a function
xtensa: noMMU: allow handling protection faults
arch/xtensa/Kconfig | 11 ++++ arch/xtensa/kernel/traps.c | 20 +++---- arch/xtensa/mm/Makefile | 3 +- arch/xtensa/mm/fault.c | 112 +++++++++++++++++++------------------ arch/xtensa/mm/mmu.c | 2 + 5 files changed, 83 insertions(+), 65 deletions(-)
Signature · 1 line
2.30.2
Max Filippov
maintainerPATCH 1/3 xtensa: move asid_cache from fault.c to mmu.c
asid_cache is only useful with full MMU, but fault.c is also useful with MPU. Move asid_cache definition to MMU-specific source file.
--- arch/xtensa/mm/fault.c | 1 - arch/xtensa/mm/mmu.c | 2 ++ 2 files changed, 2 insertions(+), 1 deletion(-)
arch/xtensa/mm/fault.c +0 -1
@@ -21,7 +21,6 @@#include <asm/cacheflush.h> #include <asm/hardirq.h> -DEFINE_PER_CPU(unsigned long, asid_cache) = ASID_USER_FIRST;void bad_page_fault (struct pt_regs *,unsigned long ,int );/*
arch/xtensa/mm/mmu.c +2 -0
@@ -18,6 +18,8 @@#include <asm/initialize_mmu.h> #include <asm/io.h> +DEFINE_PER_CPU(unsigned long, asid_cache) = ASID_USER_FIRST; +#if defined(CONFIG_HIGHMEM )static void *__init init_pmd (unsigned long vaddr,unsigned long n_pages) {
Signature · 1 line
2.30.2
Max Filippov
maintainerPATCH 2/3 xtensa: extract vmalloc_fault code into a function
In reply to Max FilippovMove full MMU-specific code into a separate function to isolate it from more generic do_page_fault code. No functional changes.
--- arch/xtensa/mm/fault.c | 107 +++++++++++++++++++++-------------------- 1 file changed, 54 insertions(+), 53 deletions(-)
arch/xtensa/mm/fault.c +54 -53
@@ -23,6 +23,55 @@void bad_page_fault (struct pt_regs *,unsigned long ,int ); +static void vmalloc_fault (struct pt_regs *regs,unsigned int address) +{ +/* Synchronize this task's top level page-table +* with the 'reference' page table. +*/ +struct mm_struct *act_mm = current->active_mm; +int index =pgd_index (address); +pgd_t *pgd, *pgd_k; +p4d_t *p4d, *p4d_k; +pud_t *pud, *pud_k; +pmd_t *pmd, *pmd_k; +pte_t *pte_k; + +if (act_mm ==NULL ) + goto bad_page_fault; + + pgd = act_mm->pgd + index; + pgd_k = init_mm.pgd + index; + +if (!pgd_present (*pgd_k)) + goto bad_page_fault; + +pgd_val (*pgd) =pgd_val (*pgd_k); + + p4d =p4d_offset (pgd, address); + p4d_k =p4d_offset (pgd_k, address); +if (!p4d_present (*p4d) || !p4d_present (*p4d_k)) + goto bad_page_fault; + + pud =pud_offset (p4d, address); + pud_k =pud_offset (p4d_k, address); +if (!pud_present (*pud) || !pud_present (*pud_k)) + goto bad_page_fault; + + pmd =pmd_offset (pud, address); + pmd_k =pmd_offset (pud_k, address); +if (!pmd_present (*pmd) || !pmd_present (*pmd_k)) + goto bad_page_fault; + +pmd_val (*pmd) =pmd_val (*pmd_k); + pte_k =pte_offset_kernel (pmd_k, address); + +if (!pte_present (*pte_k)) + goto bad_page_fault; +return ; + +bad_page_fault: +bad_page_fault (regs, address,SIGKILL ); +}/* * This routine handles page faults. It determines the address, * and the problem, and then passes it off to one of the appropriate
@@ -48,8 +97,10 @@ void do_page_fault(struct pt_regs *regs)/* We fault-in kernel-space virtual memory on-demand. The * 'reference' page table is init_mm.pgd. */ -if (address >=TASK_SIZE && !user_mode (regs)) - goto vmalloc_fault; +if (address >=TASK_SIZE && !user_mode (regs)) { +vmalloc_fault (regs, address); +return ; + }/* If we're in an interrupt or have no user * context, we must not take the fault..
@@ -113,7 +164,7 @@ void do_page_fault(struct pt_regs *regs)if (fault_signal_pending (fault, regs)) {if (!user_mode (regs)) - goto bad_page_fault; +bad_page_fault (regs, address,SIGKILL );return ; }
@@ -180,56 +231,6 @@ void do_page_fault(struct pt_regs *regs)if (!user_mode (regs))bad_page_fault (regs, address,SIGBUS );return ; - -vmalloc_fault: - { -/* Synchronize this task's top level page-table -* with the 'reference' page table. -*/ -struct mm_struct *act_mm = current->active_mm; -int index =pgd_index (address); -pgd_t *pgd, *pgd_k; -p4d_t *p4d, *p4d_k; -pud_t *pud, *pud_k; -pmd_t *pmd, *pmd_k; -pte_t *pte_k; - -if (act_mm ==NULL ) - goto bad_page_fault; - - pgd = act_mm->pgd + index; - pgd_k = init_mm.pgd + index; - -if (!pgd_present (*pgd_k)) - goto bad_page_fault; - -pgd_val (*pgd) =pgd_val (*pgd_k); - - p4d =p4d_offset (pgd, address); - p4d_k =p4d_offset (pgd_k, address); -if (!p4d_present (*p4d) || !p4d_present (*p4d_k)) - goto bad_page_fault; - - pud =pud_offset (p4d, address); - pud_k =pud_offset (p4d_k, address); -if (!pud_present (*pud) || !pud_present (*pud_k)) - goto bad_page_fault; - - pmd =pmd_offset (pud, address); - pmd_k =pmd_offset (pud_k, address); -if (!pmd_present (*pmd) || !pmd_present (*pmd_k)) - goto bad_page_fault; - -pmd_val (*pmd) =pmd_val (*pmd_k); - pte_k =pte_offset_kernel (pmd_k, address); - -if (!pte_present (*pte_k)) - goto bad_page_fault; -return ; - } -bad_page_fault: -bad_page_fault (regs, address,SIGKILL ); -return ; }
Signature · 1 line
2.30.2
Max Filippov
maintainerPATCH 3/3 xtensa: noMMU: allow handling protection faults
In reply to Max FilippovMany xtensa CPU cores without full MMU still have memory protection features capable of raising exceptions for invalid instruction fetches/data access. Allow handling such exceptions. This improves behavior of processes that pass invalid memory pointers to syscalls in noMMU configs: in case of exception the kernel instead of killing the process is now able to return -EINVAL from a syscall.
Introduce CONFIG_PFAULT that controls whether protection fault code is enabled and register handlers for common memory protection exceptions when it is enabled.
--- arch/xtensa/Kconfig | 11 +++++++++++ arch/xtensa/kernel/traps.c | 20 ++++++++++---------- arch/xtensa/mm/Makefile | 3 ++- arch/xtensa/mm/fault.c | 4 ++++ 4 files changed, 27 insertions(+), 11 deletions(-)
arch/xtensa/Kconfig +11 -0
@@ -79,6 +79,7 @@ config STACKTRACE_SUPPORT config MMU def_bool n + select PFAULT config HAVE_XTENSA_GPIO32 def_bool n
@@ -178,6 +179,16 @@ config XTENSA_FAKE_NMI If unsure, say N. +config PFAULT + bool "Handle protection faults" if EXPERT && !MMU + default y + help + Handle protection faults. MMU configurations must enable it. + noMMU configurations may disable it if used memory map never + generates protection faults or faults are always fatal. + + If unsure, say Y. + config XTENSA_UNALIGNED_USER bool "Unaligned memory access in user space" help
arch/xtensa/kernel/traps.c +10 -10
@@ -110,21 +110,21 @@ static dispatch_init_table_t __initdata dispatch_init_table[] = { { EXCCAUSE_UNALIGNED, KRNL, fast_unaligned }, #endif #ifdef CONFIG_MMU -{ EXCCAUSE_ITLB_MISS, 0, do_page_fault }, -{ EXCCAUSE_ITLB_MISS, USER|KRNL, fast_second_level_miss}, +{ EXCCAUSE_ITLB_MISS, 0, do_page_fault }, +{ EXCCAUSE_ITLB_MISS, USER|KRNL, fast_second_level_miss}, +{ EXCCAUSE_DTLB_MISS, USER|KRNL, fast_second_level_miss}, +{ EXCCAUSE_DTLB_MISS, 0, do_page_fault }, +{ EXCCAUSE_STORE_CACHE_ATTRIBUTE, USER|KRNL, fast_store_prohibited }, +#endif /* CONFIG_MMU */ +#ifdef CONFIG_PFAULT { EXCCAUSE_ITLB_MULTIHIT, 0, do_multihit }, -{ EXCCAUSE_ITLB_PRIVILEGE, 0, do_page_fault }, -/* EXCCAUSE_SIZE_RESTRICTION unhandled */ +{ EXCCAUSE_ITLB_PRIVILEGE, 0, do_page_fault }, { EXCCAUSE_FETCH_CACHE_ATTRIBUTE, 0, do_page_fault }, -{ EXCCAUSE_DTLB_MISS, USER|KRNL, fast_second_level_miss}, -{ EXCCAUSE_DTLB_MISS, 0, do_page_fault }, { EXCCAUSE_DTLB_MULTIHIT, 0, do_multihit }, -{ EXCCAUSE_DTLB_PRIVILEGE, 0, do_page_fault }, -/* EXCCAUSE_DTLB_SIZE_RESTRICTION unhandled */ -{ EXCCAUSE_STORE_CACHE_ATTRIBUTE, USER|KRNL, fast_store_prohibited }, +{ EXCCAUSE_DTLB_PRIVILEGE, 0, do_page_fault }, { EXCCAUSE_STORE_CACHE_ATTRIBUTE, 0, do_page_fault }, { EXCCAUSE_LOAD_CACHE_ATTRIBUTE, 0, do_page_fault }, -#endif /* CONFIG_MMU */ +#endif /* XCCHAL_EXCCAUSE_FLOATING_POINT unhandled */ #if XTENSA_HAVE_COPROCESSOR(0) COPROCESSOR(0),
arch/xtensa/mm/Makefile +2 -1
@@ -4,7 +4,8 @@ # obj-y := init.o misc.o -obj-$(CONFIG_MMU) += cache.o fault.o ioremap.o mmu.o tlb.o +obj-$(CONFIG_PFAULT) += fault.o +obj-$(CONFIG_MMU) += cache.o ioremap.o mmu.o tlb.o obj-$(CONFIG_HIGHMEM) += highmem.o obj-$(CONFIG_KASAN) += kasan_init.o
arch/xtensa/mm/fault.c +4 -0
@@ -25,6 +25,7 @@ void bad_page_fault(struct pt_regs*, unsigned long, int);static void vmalloc_fault (struct pt_regs *regs,unsigned int address) { +#ifdef CONFIG_MMU /* Synchronize this task's top level page-table * with the 'reference' page table. */
@@ -71,6 +72,9 @@ static void vmalloc_fault(struct pt_regs *regs, unsigned int address) bad_page_fault:bad_page_fault (regs, address,SIGKILL ); +#else +WARN_ONCE (1 ,"%s in noMMU configuration\n" , __func__); +#endif }/* * This routine handles page faults. It determines the address,
Signature · 1 line
2.30.2