2019-05-27 09:55:01 +03:00
// SPDX-License-Identifier: GPL-2.0-or-later
2005-09-26 10:04:21 +04:00
/*
* PowerPC version
* Copyright ( C ) 1995 - 1996 Gary Thomas ( gdt @ linuxppc . org )
*
* Derived from " arch/i386/mm/fault.c "
* Copyright ( C ) 1991 , 1992 , 1993 , 1994 Linus Torvalds
*
* Modified by Cort Dougan and Paul Mackerras .
*
* Modified for PPC64 by Dave Engebretsen ( engebret @ ibm . com )
*/
# include <linux/signal.h>
# include <linux/sched.h>
2017-02-08 20:51:37 +03:00
# include <linux/sched/task_stack.h>
2005-09-26 10:04:21 +04:00
# include <linux/kernel.h>
# include <linux/errno.h>
# include <linux/string.h>
# include <linux/types.h>
2018-05-23 11:53:22 +03:00
# include <linux/pagemap.h>
2005-09-26 10:04:21 +04:00
# include <linux/ptrace.h>
# include <linux/mman.h>
# include <linux/mm.h>
# include <linux/interrupt.h>
# include <linux/highmem.h>
2016-08-16 17:57:34 +03:00
# include <linux/extable.h>
2005-09-26 10:04:21 +04:00
# include <linux/kprobes.h>
2007-05-08 11:27:03 +04:00
# include <linux/kdebug.h>
perf: Do the big rename: Performance Counters -> Performance Events
Bye-bye Performance Counters, welcome Performance Events!
In the past few months the perfcounters subsystem has grown out its
initial role of counting hardware events, and has become (and is
becoming) a much broader generic event enumeration, reporting, logging,
monitoring, analysis facility.
Naming its core object 'perf_counter' and naming the subsystem
'perfcounters' has become more and more of a misnomer. With pending
code like hw-breakpoints support the 'counter' name is less and
less appropriate.
All in one, we've decided to rename the subsystem to 'performance
events' and to propagate this rename through all fields, variables
and API names. (in an ABI compatible fashion)
The word 'event' is also a bit shorter than 'counter' - which makes
it slightly more convenient to write/handle as well.
Thanks goes to Stephane Eranian who first observed this misnomer and
suggested a rename.
User-space tooling and ABI compatibility is not affected - this patch
should be function-invariant. (Also, defconfigs were not touched to
keep the size down.)
This patch has been generated via the following script:
FILES=$(find * -type f | grep -vE 'oprofile|[^K]config')
sed -i \
-e 's/PERF_EVENT_/PERF_RECORD_/g' \
-e 's/PERF_COUNTER/PERF_EVENT/g' \
-e 's/perf_counter/perf_event/g' \
-e 's/nb_counters/nb_events/g' \
-e 's/swcounter/swevent/g' \
-e 's/tpcounter_event/tp_event/g' \
$FILES
for N in $(find . -name perf_counter.[ch]); do
M=$(echo $N | sed 's/perf_counter/perf_event/g')
mv $N $M
done
FILES=$(find . -name perf_event.*)
sed -i \
-e 's/COUNTER_MASK/REG_MASK/g' \
-e 's/COUNTER/EVENT/g' \
-e 's/\<event\>/event_id/g' \
-e 's/counter/event/g' \
-e 's/Counter/Event/g' \
$FILES
... to keep it as correct as possible. This script can also be
used by anyone who has pending perfcounters patches - it converts
a Linux kernel tree over to the new naming. We tried to time this
change to the point in time where the amount of pending patches
is the smallest: the end of the merge window.
Namespace clashes were fixed up in a preparatory patch - and some
stylistic fallout will be fixed up in a subsequent patch.
( NOTE: 'counters' are still the proper terminology when we deal
with hardware registers - and these sed scripts are a bit
over-eager in renaming them. I've undone some of that, but
in case there's something left where 'counter' would be
better than 'event' we can undo that on an individual basis
instead of touching an otherwise nicely automated patch. )
Suggested-by: Stephane Eranian <eranian@google.com>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Acked-by: Paul Mackerras <paulus@samba.org>
Reviewed-by: Arjan van de Ven <arjan@linux.intel.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: David Howells <dhowells@redhat.com>
Cc: Kyle McMartin <kyle@mcmartin.ca>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: <linux-arch@vger.kernel.org>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-09-21 14:02:48 +04:00
# include <linux/perf_event.h>
2011-06-04 09:36:54 +04:00
# include <linux/ratelimit.h>
powerpc: Exception hooks for context tracking subsystem
This is the exception hooks for context tracking subsystem, including
data access, program check, single step, instruction breakpoint, machine check,
alignment, fp unavailable, altivec assist, unknown exception, whose handlers
might use RCU.
This patch corresponds to
[PATCH] x86: Exception hooks for userspace RCU extended QS
commit 6ba3c97a38803883c2eee489505796cb0a727122
But after the exception handling moved to generic code, and some changes in
following two commits:
56dd9470d7c8734f055da2a6bac553caf4a468eb
context_tracking: Move exception handling to generic code
6c1e0256fad84a843d915414e4b5973b7443d48d
context_tracking: Restore correct previous context state on exception exit
it is able for exception hooks to use the generic code above instead of a
redundant arch implementation.
Signed-off-by: Li Zhong <zhong@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2013-05-13 20:16:41 +04:00
# include <linux/context_tracking.h>
2014-09-24 10:59:58 +04:00
# include <linux/hugetlb.h>
2015-05-11 18:52:11 +03:00
# include <linux/uaccess.h>
2021-03-04 17:35:09 +03:00
# include <linux/kfence.h>
2021-03-15 17:52:51 +03:00
# include <linux/pkeys.h>
2005-09-26 10:04:21 +04:00
2008-10-22 09:53:45 +04:00
# include <asm/firmware.h>
2021-01-30 16:08:38 +03:00
# include <asm/interrupt.h>
2005-09-26 10:04:21 +04:00
# include <asm/page.h>
# include <asm/mmu.h>
# include <asm/mmu_context.h>
# include <asm/siginfo.h>
2012-03-28 21:30:02 +04:00
# include <asm/debug.h>
powerpc/mm: Detect bad KUAP faults
When KUAP is enabled we have logic to detect page faults that occur
outside of a valid user access region and are blocked by the AMR.
What we don't have at the moment is logic to detect a fault *within* a
valid user access region, that has been incorrectly blocked by AMR.
This is not meant to ever happen, but it can if we incorrectly
save/restore the AMR, or if the AMR was overwritten for some other
reason.
Currently if that happens we assume it's just a regular fault that
will be corrected by handling the fault normally, so we just return.
But there is nothing the fault handling code can do to fix it, so the
fault just happens again and we spin forever, leading to soft lockups.
So add some logic to detect that case and WARN() if we ever see it.
Arguably it should be a BUG(), but it's more polite to fail the access
and let the kernel continue, rather than taking down the box. There
should be no data integrity issue with failing the fault rather than
BUG'ing, as we're just going to disallow an access that should have
been allowed.
To make the code a little easier to follow, unroll the condition at
the end of bad_kernel_fault() and comment each case, before adding the
call to bad_kuap_fault().
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2019-04-18 09:51:25 +03:00
# include <asm/kup.h>
2020-05-06 06:40:28 +03:00
# include <asm/inst.h>
2006-06-26 11:25:27 +04:00
2020-07-24 12:25:27 +03:00
2012-03-01 11:14:45 +04:00
/*
* do_page_fault error handling helpers
*/
2017-07-19 07:49:35 +03:00
static int
2018-09-18 11:42:33 +03:00
__bad_area_nosemaphore ( struct pt_regs * regs , unsigned long address , int si_code )
2017-07-19 07:49:35 +03:00
{
/*
* If we are in kernel mode , bail out with a SEGV , this will
* be caught by the assembly which will restore the non - volatile
* registers before calling bad_page_fault ( )
*/
if ( ! user_mode ( regs ) )
return SIGSEGV ;
2018-09-18 11:42:33 +03:00
_exception ( SIGSEGV , regs , si_code , address ) ;
2017-07-19 07:49:35 +03:00
return 0 ;
}
static noinline int bad_area_nosemaphore ( struct pt_regs * regs , unsigned long address )
{
2018-09-18 11:42:33 +03:00
return __bad_area_nosemaphore ( regs , address , SEGV_MAPERR ) ;
2017-07-19 07:49:35 +03:00
}
2018-09-18 10:19:24 +03:00
static int __bad_area ( struct pt_regs * regs , unsigned long address , int si_code )
2017-07-19 07:49:35 +03:00
{
struct mm_struct * mm = current - > mm ;
/*
* Something tried to access memory that isn ' t in our memory map . .
* Fix it , but check if it ' s kernel or user first . .
*/
2020-06-09 07:33:25 +03:00
mmap_read_unlock ( mm ) ;
2017-07-19 07:49:35 +03:00
2018-09-18 11:42:33 +03:00
return __bad_area_nosemaphore ( regs , address , si_code ) ;
2017-07-19 07:49:35 +03:00
}
static noinline int bad_area ( struct pt_regs * regs , unsigned long address )
{
2018-09-18 10:19:24 +03:00
return __bad_area ( regs , address , SEGV_MAPERR ) ;
2018-01-19 04:50:42 +03:00
}
2020-05-05 10:17:08 +03:00
static noinline int bad_access_pkey ( struct pt_regs * regs , unsigned long address ,
struct vm_area_struct * vma )
2018-01-19 04:50:42 +03:00
{
2020-05-05 10:17:08 +03:00
struct mm_struct * mm = current - > mm ;
int pkey ;
/*
* We don ' t try to fetch the pkey from page table because reading
* page table without locking doesn ' t guarantee stable pte value .
* Hence the pkey value that we return to userspace can be different
* from the pkey that actually caused access error .
*
* It does * not * guarantee that the VMA we find here
* was the one that we faulted on .
*
* 1. T1 : mprotect_key ( foo , PAGE_SIZE , pkey = 4 ) ;
* 2. T1 : set AMR to deny access to pkey = 4 , touches , page
* 3. T1 : faults . . .
* 4. T2 : mprotect_key ( foo , PAGE_SIZE , pkey = 5 ) ;
2020-06-09 07:33:54 +03:00
* 5. T1 : enters fault handler , takes mmap_lock , etc . . .
2020-05-05 10:17:08 +03:00
* 6. T1 : reaches here , sees vma_pkey ( vma ) = 5 , when we really
* faulted on a pte with its pkey = 4.
*/
pkey = vma_pkey ( vma ) ;
2020-06-09 07:33:25 +03:00
mmap_read_unlock ( mm ) ;
2020-05-05 10:17:08 +03:00
2018-09-18 10:14:49 +03:00
/*
* If we are in kernel mode , bail out with a SEGV , this will
* be caught by the assembly which will restore the non - volatile
* registers before calling bad_page_fault ( )
*/
if ( ! user_mode ( regs ) )
return SIGSEGV ;
2018-09-18 11:56:25 +03:00
_exception_pkey ( regs , address , pkey ) ;
2018-09-18 10:14:49 +03:00
return 0 ;
2017-07-19 07:49:35 +03:00
}
powerpc/mm: Fix SEGV on mapped region to return SEGV_ACCERR
The recent refactoring of the powerpc page fault handler in commit
c3350602e876 ("powerpc/mm: Make bad_area* helper functions") caused
access to protected memory regions to indicate SEGV_MAPERR instead of
the traditional SEGV_ACCERR in the si_code field of a user-space
signal handler. This can confuse debug libraries that temporarily
change the protection of memory regions, and expect to use SEGV_ACCERR
as an indication to restore access to a region.
This commit restores the previous behavior. The following program
exhibits the issue:
$ ./repro read || echo "FAILED"
$ ./repro write || echo "FAILED"
$ ./repro exec || echo "FAILED"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/mman.h>
#include <assert.h>
static void segv_handler(int n, siginfo_t *info, void *arg) {
_exit(info->si_code == SEGV_ACCERR ? 0 : 1);
}
int main(int argc, char **argv)
{
void *p = NULL;
struct sigaction act = {
.sa_sigaction = segv_handler,
.sa_flags = SA_SIGINFO,
};
assert(argc == 2);
p = mmap(NULL, getpagesize(),
(strcmp(argv[1], "write") == 0) ? PROT_READ : 0,
MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
assert(p != MAP_FAILED);
assert(sigaction(SIGSEGV, &act, NULL) == 0);
if (strcmp(argv[1], "read") == 0)
printf("%c", *(unsigned char *)p);
else if (strcmp(argv[1], "write") == 0)
*(unsigned char *)p = 0;
else if (strcmp(argv[1], "exec") == 0)
((void (*)(void))p)();
return 1; /* failed to generate SEGV */
}
Fixes: c3350602e876 ("powerpc/mm: Make bad_area* helper functions")
Cc: stable@vger.kernel.org # v4.14+
Signed-off-by: John Sperbeck <jsperbeck@google.com>
Acked-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
[mpe: Add commit references in change log]
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2018-01-01 08:24:58 +03:00
static noinline int bad_access ( struct pt_regs * regs , unsigned long address )
{
2018-09-18 10:19:24 +03:00
return __bad_area ( regs , address , SEGV_ACCERR ) ;
powerpc/mm: Fix SEGV on mapped region to return SEGV_ACCERR
The recent refactoring of the powerpc page fault handler in commit
c3350602e876 ("powerpc/mm: Make bad_area* helper functions") caused
access to protected memory regions to indicate SEGV_MAPERR instead of
the traditional SEGV_ACCERR in the si_code field of a user-space
signal handler. This can confuse debug libraries that temporarily
change the protection of memory regions, and expect to use SEGV_ACCERR
as an indication to restore access to a region.
This commit restores the previous behavior. The following program
exhibits the issue:
$ ./repro read || echo "FAILED"
$ ./repro write || echo "FAILED"
$ ./repro exec || echo "FAILED"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/mman.h>
#include <assert.h>
static void segv_handler(int n, siginfo_t *info, void *arg) {
_exit(info->si_code == SEGV_ACCERR ? 0 : 1);
}
int main(int argc, char **argv)
{
void *p = NULL;
struct sigaction act = {
.sa_sigaction = segv_handler,
.sa_flags = SA_SIGINFO,
};
assert(argc == 2);
p = mmap(NULL, getpagesize(),
(strcmp(argv[1], "write") == 0) ? PROT_READ : 0,
MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
assert(p != MAP_FAILED);
assert(sigaction(SIGSEGV, &act, NULL) == 0);
if (strcmp(argv[1], "read") == 0)
printf("%c", *(unsigned char *)p);
else if (strcmp(argv[1], "write") == 0)
*(unsigned char *)p = 0;
else if (strcmp(argv[1], "exec") == 0)
((void (*)(void))p)();
return 1; /* failed to generate SEGV */
}
Fixes: c3350602e876 ("powerpc/mm: Make bad_area* helper functions")
Cc: stable@vger.kernel.org # v4.14+
Signed-off-by: John Sperbeck <jsperbeck@google.com>
Acked-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
[mpe: Add commit references in change log]
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2018-01-01 08:24:58 +03:00
}
2014-09-24 10:59:57 +04:00
static int do_sigbus ( struct pt_regs * regs , unsigned long address ,
2018-08-18 01:44:47 +03:00
vm_fault_t fault )
2012-03-01 11:14:45 +04:00
{
2014-09-24 10:59:56 +04:00
if ( ! user_mode ( regs ) )
2017-07-19 07:49:36 +03:00
return SIGBUS ;
2014-09-24 10:59:56 +04:00
current - > thread . trap_nr = BUS_ADRERR ;
2014-09-24 10:59:57 +04:00
# ifdef CONFIG_MEMORY_FAILURE
if ( fault & ( VM_FAULT_HWPOISON | VM_FAULT_HWPOISON_LARGE ) ) {
2018-04-20 01:36:43 +03:00
unsigned int lsb = 0 ; /* shutup gcc */
2014-09-24 10:59:57 +04:00
pr_err ( " MCE: Killing %s:%d due to hardware memory corruption fault at %lx \n " ,
current - > comm , current - > pid , address ) ;
2018-04-20 01:36:43 +03:00
if ( fault & VM_FAULT_HWPOISON_LARGE )
lsb = hstate_index_to_shift ( VM_FAULT_GET_HINDEX ( fault ) ) ;
if ( fault & VM_FAULT_HWPOISON )
lsb = PAGE_SHIFT ;
2019-02-06 03:14:19 +03:00
force_sig_mceerr ( BUS_MCEERR_AR , ( void __user * ) address , lsb ) ;
2018-04-20 01:36:43 +03:00
return 0 ;
2014-09-24 10:59:57 +04:00
}
2014-09-24 10:59:58 +04:00
2014-09-24 10:59:57 +04:00
# endif
2019-05-23 19:04:24 +03:00
force_sig_fault ( SIGBUS , BUS_ADRERR , ( void __user * ) address ) ;
2017-07-19 07:49:36 +03:00
return 0 ;
2012-03-01 11:14:45 +04:00
}
2018-08-18 01:44:47 +03:00
static int mm_fault_error ( struct pt_regs * regs , unsigned long addr ,
vm_fault_t fault )
2012-03-01 11:14:45 +04:00
{
/*
2017-07-19 07:49:36 +03:00
* Kernel page fault interrupted by SIGKILL . We have no reason to
* continue processing .
2012-03-01 11:14:45 +04:00
*/
2017-07-19 07:49:36 +03:00
if ( fatal_signal_pending ( current ) & & ! user_mode ( regs ) )
return SIGKILL ;
2012-03-01 11:14:45 +04:00
/* Out of memory */
2012-12-13 01:52:10 +04:00
if ( fault & VM_FAULT_OOM ) {
/*
* We ran out of memory , or some other thing happened to us that
* made us unable to handle the page fault gracefully .
*/
if ( ! user_mode ( regs ) )
2017-07-19 07:49:36 +03:00
return SIGSEGV ;
2012-12-13 01:52:10 +04:00
pagefault_out_of_memory ( ) ;
2017-07-19 07:49:36 +03:00
} else {
if ( fault & ( VM_FAULT_SIGBUS | VM_FAULT_HWPOISON |
VM_FAULT_HWPOISON_LARGE ) )
return do_sigbus ( regs , addr , fault ) ;
else if ( fault & VM_FAULT_SIGSEGV )
return bad_area_nosemaphore ( regs , addr ) ;
else
BUG ( ) ;
2012-12-13 01:52:10 +04:00
}
2017-07-19 07:49:36 +03:00
return 0 ;
2012-03-01 11:14:45 +04:00
}
2005-09-26 10:04:21 +04:00
2017-07-19 07:49:34 +03:00
/* Is this a bad kernel fault ? */
2019-04-18 09:51:20 +03:00
static bool bad_kernel_fault ( struct pt_regs * regs , unsigned long error_code ,
powerpc/mm: Detect bad KUAP faults
When KUAP is enabled we have logic to detect page faults that occur
outside of a valid user access region and are blocked by the AMR.
What we don't have at the moment is logic to detect a fault *within* a
valid user access region, that has been incorrectly blocked by AMR.
This is not meant to ever happen, but it can if we incorrectly
save/restore the AMR, or if the AMR was overwritten for some other
reason.
Currently if that happens we assume it's just a regular fault that
will be corrected by handling the fault normally, so we just return.
But there is nothing the fault handling code can do to fix it, so the
fault just happens again and we spin forever, leading to soft lockups.
So add some logic to detect that case and WARN() if we ever see it.
Arguably it should be a BUG(), but it's more polite to fail the access
and let the kernel continue, rather than taking down the box. There
should be no data integrity issue with failing the fault rather than
BUG'ing, as we're just going to disallow an access that should have
been allowed.
To make the code a little easier to follow, unroll the condition at
the end of bad_kernel_fault() and comment each case, before adding the
call to bad_kuap_fault().
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2019-04-18 09:51:25 +03:00
unsigned long address , bool is_write )
2017-07-19 07:49:34 +03:00
{
2021-04-14 14:00:33 +03:00
int is_exec = TRAP ( regs ) = = INTERRUPT_INST_STORAGE ;
2019-04-18 09:51:20 +03:00
powerpc/mm: Fix lockup on kernel exec fault
The powerpc kernel is not prepared to handle exec faults from kernel.
Especially, the function is_exec_fault() will return 'false' when an
exec fault is taken by kernel, because the check is based on reading
current->thread.regs->trap which contains the trap from user.
For instance, when provoking a LKDTM EXEC_USERSPACE test,
current->thread.regs->trap is set to SYSCALL trap (0xc00), and
the fault taken by the kernel is not seen as an exec fault by
set_access_flags_filter().
Commit d7df2443cd5f ("powerpc/mm: Fix spurious segfaults on radix
with autonuma") made it clear and handled it properly. But later on
commit d3ca587404b3 ("powerpc/mm: Fix reporting of kernel execute
faults") removed that handling, introducing test based on error_code.
And here is the problem, because on the 603 all upper bits of SRR1
get cleared when the TLB instruction miss handler bails out to ISI.
Until commit cbd7e6ca0210 ("powerpc/fault: Avoid heavy
search_exception_tables() verification"), an exec fault from kernel
at a userspace address was indirectly caught by the lack of entry for
that address in the exception tables. But after that commit the
kernel mainly relies on KUAP or on core mm handling to catch wrong
user accesses. Here the access is not wrong, so mm handles it.
It is a minor fault because PAGE_EXEC is not set,
set_access_flags_filter() should set PAGE_EXEC and voila.
But as is_exec_fault() returns false as explained in the beginning,
set_access_flags_filter() bails out without setting PAGE_EXEC flag,
which leads to a forever minor exec fault.
As the kernel is not prepared to handle such exec faults, the thing to
do is to fire in bad_kernel_fault() for any exec fault taken by the
kernel, as it was prior to commit d3ca587404b3.
Fixes: d3ca587404b3 ("powerpc/mm: Fix reporting of kernel execute faults")
Cc: stable@vger.kernel.org # v4.14+
Signed-off-by: Christophe Leroy <christophe.leroy@csgroup.eu>
Acked-by: Nicholas Piggin <npiggin@gmail.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/024bb05105050f704743a0083fe3548702be5706.1625138205.git.christophe.leroy@csgroup.eu
2021-07-01 14:17:08 +03:00
if ( is_exec ) {
2019-04-18 09:51:19 +03:00
pr_crit_ratelimited ( " kernel tried to execute %s page (%lx) - exploit attempt? (uid: %d) \n " ,
address > = TASK_SIZE ? " exec-protected " : " user " ,
address ,
from_kuid ( & init_user_ns , current_uid ( ) ) ) ;
powerpc/mm: Detect bad KUAP faults
When KUAP is enabled we have logic to detect page faults that occur
outside of a valid user access region and are blocked by the AMR.
What we don't have at the moment is logic to detect a fault *within* a
valid user access region, that has been incorrectly blocked by AMR.
This is not meant to ever happen, but it can if we incorrectly
save/restore the AMR, or if the AMR was overwritten for some other
reason.
Currently if that happens we assume it's just a regular fault that
will be corrected by handling the fault normally, so we just return.
But there is nothing the fault handling code can do to fix it, so the
fault just happens again and we spin forever, leading to soft lockups.
So add some logic to detect that case and WARN() if we ever see it.
Arguably it should be a BUG(), but it's more polite to fail the access
and let the kernel continue, rather than taking down the box. There
should be no data integrity issue with failing the fault rather than
BUG'ing, as we're just going to disallow an access that should have
been allowed.
To make the code a little easier to follow, unroll the condition at
the end of bad_kernel_fault() and comment each case, before adding the
call to bad_kuap_fault().
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2019-04-18 09:51:25 +03:00
// Kernel exec fault is always bad
return true ;
2017-07-19 07:49:34 +03:00
}
2019-04-18 09:51:20 +03:00
powerpc/mm: Detect bad KUAP faults
When KUAP is enabled we have logic to detect page faults that occur
outside of a valid user access region and are blocked by the AMR.
What we don't have at the moment is logic to detect a fault *within* a
valid user access region, that has been incorrectly blocked by AMR.
This is not meant to ever happen, but it can if we incorrectly
save/restore the AMR, or if the AMR was overwritten for some other
reason.
Currently if that happens we assume it's just a regular fault that
will be corrected by handling the fault normally, so we just return.
But there is nothing the fault handling code can do to fix it, so the
fault just happens again and we spin forever, leading to soft lockups.
So add some logic to detect that case and WARN() if we ever see it.
Arguably it should be a BUG(), but it's more polite to fail the access
and let the kernel continue, rather than taking down the box. There
should be no data integrity issue with failing the fault rather than
BUG'ing, as we're just going to disallow an access that should have
been allowed.
To make the code a little easier to follow, unroll the condition at
the end of bad_kernel_fault() and comment each case, before adding the
call to bad_kuap_fault().
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2019-04-18 09:51:25 +03:00
// Kernel fault on kernel address is bad
if ( address > = TASK_SIZE )
return true ;
2020-12-09 08:29:24 +03:00
// Read/write fault blocked by KUAP is bad, it can never succeed.
if ( bad_kuap_fault ( regs , address , is_write ) ) {
pr_crit_ratelimited ( " Kernel attempted to %s user page (%lx) - exploit attempt? (uid: %d) \n " ,
is_write ? " write " : " read " , address ,
from_kuid ( & init_user_ns , current_uid ( ) ) ) ;
powerpc/mm: Detect bad KUAP faults
When KUAP is enabled we have logic to detect page faults that occur
outside of a valid user access region and are blocked by the AMR.
What we don't have at the moment is logic to detect a fault *within* a
valid user access region, that has been incorrectly blocked by AMR.
This is not meant to ever happen, but it can if we incorrectly
save/restore the AMR, or if the AMR was overwritten for some other
reason.
Currently if that happens we assume it's just a regular fault that
will be corrected by handling the fault normally, so we just return.
But there is nothing the fault handling code can do to fix it, so the
fault just happens again and we spin forever, leading to soft lockups.
So add some logic to detect that case and WARN() if we ever see it.
Arguably it should be a BUG(), but it's more polite to fail the access
and let the kernel continue, rather than taking down the box. There
should be no data integrity issue with failing the fault rather than
BUG'ing, as we're just going to disallow an access that should have
been allowed.
To make the code a little easier to follow, unroll the condition at
the end of bad_kernel_fault() and comment each case, before adding the
call to bad_kuap_fault().
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2019-04-18 09:51:25 +03:00
2020-12-09 08:29:24 +03:00
// Fault on user outside of certain regions (eg. copy_tofrom_user()) is bad
if ( ! search_exception_tables ( regs - > nip ) )
return true ;
// Read/write fault in a valid region (the exception table search passed
// above), but blocked by KUAP is bad, it can never succeed.
2020-12-09 08:29:23 +03:00
return WARN ( true , " Bug: %s fault blocked by KUAP! " , is_write ? " Write " : " Read " ) ;
2020-12-09 08:29:24 +03:00
}
powerpc/mm: Detect bad KUAP faults
When KUAP is enabled we have logic to detect page faults that occur
outside of a valid user access region and are blocked by the AMR.
What we don't have at the moment is logic to detect a fault *within* a
valid user access region, that has been incorrectly blocked by AMR.
This is not meant to ever happen, but it can if we incorrectly
save/restore the AMR, or if the AMR was overwritten for some other
reason.
Currently if that happens we assume it's just a regular fault that
will be corrected by handling the fault normally, so we just return.
But there is nothing the fault handling code can do to fix it, so the
fault just happens again and we spin forever, leading to soft lockups.
So add some logic to detect that case and WARN() if we ever see it.
Arguably it should be a BUG(), but it's more polite to fail the access
and let the kernel continue, rather than taking down the box. There
should be no data integrity issue with failing the fault rather than
BUG'ing, as we're just going to disallow an access that should have
been allowed.
To make the code a little easier to follow, unroll the condition at
the end of bad_kernel_fault() and comment each case, before adding the
call to bad_kuap_fault().
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2019-04-18 09:51:25 +03:00
2020-12-09 08:29:24 +03:00
// What's left? Kernel fault on user and allowed by KUAP in the faulting context.
powerpc/mm: Detect bad KUAP faults
When KUAP is enabled we have logic to detect page faults that occur
outside of a valid user access region and are blocked by the AMR.
What we don't have at the moment is logic to detect a fault *within* a
valid user access region, that has been incorrectly blocked by AMR.
This is not meant to ever happen, but it can if we incorrectly
save/restore the AMR, or if the AMR was overwritten for some other
reason.
Currently if that happens we assume it's just a regular fault that
will be corrected by handling the fault normally, so we just return.
But there is nothing the fault handling code can do to fix it, so the
fault just happens again and we spin forever, leading to soft lockups.
So add some logic to detect that case and WARN() if we ever see it.
Arguably it should be a BUG(), but it's more polite to fail the access
and let the kernel continue, rather than taking down the box. There
should be no data integrity issue with failing the fault rather than
BUG'ing, as we're just going to disallow an access that should have
been allowed.
To make the code a little easier to follow, unroll the condition at
the end of bad_kernel_fault() and comment each case, before adding the
call to bad_kuap_fault().
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2019-04-18 09:51:25 +03:00
return false ;
2017-07-19 07:49:34 +03:00
}
2020-05-05 10:17:08 +03:00
static bool access_pkey_error ( bool is_write , bool is_exec , bool is_pkey ,
struct vm_area_struct * vma )
{
/*
* Make sure to check the VMA so that we do not perform
* faults just to hit a pkey fault as soon as we fill in a
* page . Only called for current mm , hence foreign = = 0
*/
if ( ! arch_vma_access_permitted ( vma , is_write , is_exec , 0 ) )
return true ;
return false ;
}
static bool access_error ( bool is_write , bool is_exec , struct vm_area_struct * vma )
2017-07-19 07:49:43 +03:00
{
/*
* Allow execution from readable areas if the MMU does not
* provide separate controls over reading and executing .
*
* Note : That code used to not be enabled for 4 xx / BookE .
* It is now as I / D cache coherency for these is done at
* set_pte_at ( ) time and I see no reason why the test
* below wouldn ' t be valid on those processors . This - may -
* break programs compiled with a really old ABI though .
*/
if ( is_exec ) {
return ! ( vma - > vm_flags & VM_EXEC ) & &
( cpu_has_feature ( CPU_FTR_NOEXECUTE ) | |
! ( vma - > vm_flags & ( VM_READ | VM_WRITE ) ) ) ;
}
if ( is_write ) {
if ( unlikely ( ! ( vma - > vm_flags & VM_WRITE ) ) )
return true ;
return false ;
}
2022-08-17 08:06:39 +03:00
/*
* Check for a read fault . This could be caused by a read on an
* inaccessible page ( i . e . PROT_NONE ) , or a Radix MMU execute - only page .
*/
if ( unlikely ( ! ( vma - > vm_flags & VM_READ ) ) )
2017-07-19 07:49:43 +03:00
return true ;
2018-03-07 16:36:45 +03:00
/*
* We should ideally do the vma pkey access check here . But in the
* fault path , handle_mm_fault ( ) also does the same check . To avoid
* these multiple checks , we skip it here and handle access error due
* to pkeys later .
*/
2017-07-19 07:49:43 +03:00
return false ;
}
2017-07-19 07:49:37 +03:00
# ifdef CONFIG_PPC_SMLPAR
static inline void cmo_account_page_fault ( void )
{
if ( firmware_has_feature ( FW_FEATURE_CMO ) ) {
u32 page_ins ;
preempt_disable ( ) ;
page_ins = be32_to_cpu ( get_lppaca ( ) - > page_ins ) ;
page_ins + = 1 < < PAGE_FACTOR ;
get_lppaca ( ) - > page_ins = cpu_to_be32 ( page_ins ) ;
preempt_enable ( ) ;
}
}
# else
static inline void cmo_account_page_fault ( void ) { }
# endif /* CONFIG_PPC_SMLPAR */
2018-11-26 17:35:04 +03:00
static void sanity_check_fault ( bool is_write , bool is_user ,
unsigned long error_code , unsigned long address )
2017-07-19 07:49:39 +03:00
{
2018-11-26 17:35:04 +03:00
/*
* Userspace trying to access kernel address , we get PROTFAULT for that .
*/
if ( is_user & & address > = TASK_SIZE ) {
2019-12-23 10:54:22 +03:00
if ( ( long ) address = = - 1 )
return ;
2018-11-26 17:35:04 +03:00
pr_crit_ratelimited ( " %s[%d]: User access of kernel address (%lx) - exploit attempt? (uid: %d) \n " ,
current - > comm , current - > pid , address ,
from_kuid ( & init_user_ns , current_uid ( ) ) ) ;
return ;
}
2020-12-09 08:29:21 +03:00
if ( ! IS_ENABLED ( CONFIG_PPC_BOOK3S ) )
return ;
2017-07-19 07:49:39 +03:00
/*
* For hash translation mode , we should never get a
* PROTFAULT . Any update to pte to reduce access will result in us
* removing the hash page table entry , thus resulting in a DSISR_NOHPTE
* fault instead of DSISR_PROTFAULT .
*
* A pte update to relax the access will not result in a hash page table
* entry invalidate and hence can result in DSISR_PROTFAULT .
* ptep_set_access_flags ( ) doesn ' t do a hpte flush . This is why we have
* the special ! is_write in the below conditional .
*
* For platforms that doesn ' t supports coherent icache and do support
* per page noexec bit , we do setup things such that we do the
* sync between D / I cache via fault . But that is handled via low level
* hash fault code ( hash_page_do_lazy_icache ( ) ) and we should not reach
* here in such case .
*
* For wrong access that can result in PROTFAULT , the above vma - > vm_flags
* check should handle those and hence we should fall to the bad_area
* handling correctly .
*
* For embedded with per page exec support that doesn ' t support coherent
* icache we do get PROTFAULT and we handle that D / I cache sync in
* set_pte_at while taking the noexec / prot fault . Hence this is WARN_ON
* is conditional for server MMU .
*
* For radix , we can get prot fault for autonuma case , because radix
* page table will have them marked noaccess for user .
*/
2018-11-26 17:35:04 +03:00
if ( radix_enabled ( ) | | is_write )
return ;
WARN_ON_ONCE ( error_code & DSISR_PROTFAULT ) ;
2017-07-19 07:49:39 +03:00
}
2017-07-19 07:49:29 +03:00
/*
* Define the correct " is_write " bit in error_code based
* on the processor family
*/
# if (defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
# define page_fault_is_write(__err) ((__err) & ESR_DST)
# else
# define page_fault_is_write(__err) ((__err) & DSISR_ISSTORE)
2020-12-09 08:29:22 +03:00
# endif
# if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
# define page_fault_is_bad(__err) (0)
# elif defined(CONFIG_PPC_8xx)
2017-08-08 14:59:00 +03:00
# define page_fault_is_bad(__err) ((__err) & DSISR_NOEXEC_OR_G)
2017-07-19 07:49:31 +03:00
# elif defined(CONFIG_PPC64)
2022-09-28 04:29:27 +03:00
static int page_fault_is_bad ( unsigned long err )
{
unsigned long flag = DSISR_BAD_FAULT_64S ;
/*
* PAPR + v2 .11 § 14.15 .3 .4 .1 ( unreleased )
* If byte 0 , bit 3 of pi - attribute - specifier - type in
* ibm , pi - features property is defined , ignore the DSI error
* which is caused by the paste instruction on the
* suspended NX window .
*/
if ( mmu_has_feature ( MMU_FTR_NX_DSI ) )
flag & = ~ DSISR_BAD_COPYPASTE ;
return err & flag ;
}
2017-07-19 07:49:31 +03:00
# else
# define page_fault_is_bad(__err) ((__err) & DSISR_BAD_FAULT_32S)
# endif
2017-07-19 07:49:29 +03:00
2005-09-26 10:04:21 +04:00
/*
* For 600 - and 800 - family processors , the error_code parameter is DSISR
2021-01-30 16:08:26 +03:00
* for a data fault , SRR1 for an instruction fault .
* For 400 - family processors the error_code parameter is ESR for a data fault ,
* 0 for an instruction fault .
* For 64 - bit processors , the error_code parameter is DSISR for a data access
* fault , SRR1 & 0x08000000 for an instruction access fault .
2005-09-26 10:04:21 +04:00
*
* The return value is 0 if the fault was handled , or the signal
* number if this is a kernel fault that can ' t be handled here .
*/
powerpc/64s/hash: improve context tracking of hash faults
This moves the 64s/hash context tracking from hash_page_mm() to
__do_hash_fault(), so it's no longer called by OCXL / SPU
accelerators, which was certainly the wrong thing to be doing,
because those callers are not low level interrupt handlers, so
should have entered a kernel context tracking already.
Then remain in kernel context for the duration of the fault,
rather than enter/exit for the hash fault then enter/exit for
the page fault, which is pointless.
Even still, calling exception_enter/exit in __do_hash_fault seems
questionable because that's touching per-cpu variables, tracing,
etc., which might have been interrupted by this hash fault or
themselves cause hash faults. But maybe I miss something because
hash_page_mm very deliberately calls trace_hash_fault too, for
example. So for now go with it, it's no worse than before, in this
regard.
Signed-off-by: Nicholas Piggin <npiggin@gmail.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/20210130130852.2952424-32-npiggin@gmail.com
2021-01-30 16:08:41 +03:00
static int ___do_page_fault ( struct pt_regs * regs , unsigned long address ,
2017-07-19 07:49:23 +03:00
unsigned long error_code )
2005-09-26 10:04:21 +04:00
{
struct vm_area_struct * vma ;
struct mm_struct * mm = current - > mm ;
2020-04-02 07:08:37 +03:00
unsigned int flags = FAULT_FLAG_DEFAULT ;
2021-04-14 14:00:33 +03:00
int is_exec = TRAP ( regs ) = = INTERRUPT_INST_STORAGE ;
powerpc/mm: Evaluate user_mode(regs) only once in do_page_fault()
Analysis of the assembly code shows that when using user_mode(regs),
at least the 'andi.' is redone all the time, and also
the 'lwz ,132(r31)' most of the time. With the new form, the 'is_user'
is mapped to cr4, then all further use of is_user results in just
things like 'beq cr4,218 <do_page_fault+0x218>'
Without the patch:
50: 81 1e 00 84 lwz r8,132(r30)
54: 71 09 40 00 andi. r9,r8,16384
58: 40 82 00 0c bne 64 <do_page_fault+0x64>
84: 81 3e 00 84 lwz r9,132(r30)
8c: 71 2a 40 00 andi. r10,r9,16384
90: 41 a2 01 64 beq 1f4 <do_page_fault+0x1f4>
d4: 81 3e 00 84 lwz r9,132(r30)
dc: 71 28 40 00 andi. r8,r9,16384
e0: 41 82 02 08 beq 2e8 <do_page_fault+0x2e8>
108: 81 3e 00 84 lwz r9,132(r30)
110: 71 28 40 00 andi. r8,r9,16384
118: 41 82 02 28 beq 340 <do_page_fault+0x340>
1e4: 81 3e 00 84 lwz r9,132(r30)
1e8: 71 2a 40 00 andi. r10,r9,16384
1ec: 40 82 01 68 bne 354 <do_page_fault+0x354>
228: 81 3e 00 84 lwz r9,132(r30)
22c: 71 28 40 00 andi. r8,r9,16384
230: 41 82 ff c4 beq 1f4 <do_page_fault+0x1f4>
288: 71 2a 40 00 andi. r10,r9,16384
294: 41 a2 fe 60 beq f4 <do_page_fault+0xf4>
50c: 81 3e 00 84 lwz r9,132(r30)
514: 71 2a 40 00 andi. r10,r9,16384
518: 40 a2 fc e0 bne 1f8 <do_page_fault+0x1f8>
534: 81 3e 00 84 lwz r9,132(r30)
53c: 71 2a 40 00 andi. r10,r9,16384
540: 41 82 fc b8 beq 1f8 <do_page_fault+0x1f8>
This patch creates a local var called 'is_user' which contains the
result of user_mode(regs)
With the patch:
20: 81 03 00 84 lwz r8,132(r3)
48: 55 09 97 fe rlwinm r9,r8,18,31,31
58: 2e 09 00 00 cmpwi cr4,r9,0
5c: 40 92 00 0c bne cr4,68 <do_page_fault+0x68>
88: 41 b2 01 90 beq cr4,218 <do_page_fault+0x218>
d4: 40 92 01 d0 bne cr4,2a4 <do_page_fault+0x2a4>
120: 41 b2 00 f8 beq cr4,218 <do_page_fault+0x218>
138: 41 b2 ff a0 beq cr4,d8 <do_page_fault+0xd8>
1d4: 40 92 00 e0 bne cr4,2b4 <do_page_fault+0x2b4>
Signed-off-by: Christophe Leroy <christophe.leroy@c-s.fr>
Reviewed-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2017-04-19 15:56:30 +03:00
int is_user = user_mode ( regs ) ;
2017-07-19 07:49:29 +03:00
int is_write = page_fault_is_write ( error_code ) ;
2018-08-18 01:44:47 +03:00
vm_fault_t fault , major = 0 ;
2019-07-17 02:28:00 +03:00
bool kprobe_fault = kprobe_page_fault ( regs , 11 ) ;
2005-09-26 10:04:21 +04:00
2019-07-17 02:28:00 +03:00
if ( unlikely ( debugger_fault_handler ( regs ) | | kprobe_fault ) )
2017-07-19 07:49:33 +03:00
return 0 ;
2005-09-26 10:04:21 +04:00
2017-07-19 07:49:31 +03:00
if ( unlikely ( page_fault_is_bad ( error_code ) ) ) {
2017-07-19 07:49:33 +03:00
if ( is_user ) {
2017-07-19 07:49:31 +03:00
_exception ( SIGBUS , regs , BUS_OBJERR , address ) ;
2017-07-19 07:49:33 +03:00
return 0 ;
}
return SIGBUS ;
2017-07-19 07:49:30 +03:00
}
2017-07-19 07:49:39 +03:00
/* Additional sanity check(s) */
2018-11-26 17:35:04 +03:00
sanity_check_fault ( is_write , is_user , error_code , address ) ;
2017-07-19 07:49:39 +03:00
2017-02-03 09:10:28 +03:00
/*
* The kernel should never take an execute fault nor should it
2019-04-18 09:51:20 +03:00
* take a page fault to a kernel address or a page fault to a user
* address outside of dedicated places
2017-02-03 09:10:28 +03:00
*/
2021-03-04 17:35:09 +03:00
if ( unlikely ( ! is_user & & bad_kernel_fault ( regs , error_code , address , is_write ) ) ) {
if ( kfence_handle_page_fault ( address , is_write , regs ) )
return 0 ;
2017-07-19 07:49:33 +03:00
return SIGSEGV ;
2021-03-04 17:35:09 +03:00
}
2005-09-26 10:04:21 +04:00
2017-07-19 07:49:40 +03:00
/*
* If we ' re in an interrupt , have no user context or are running
* in a region with pagefaults disabled then we must not take the fault
*/
if ( unlikely ( faulthandler_disabled ( ) | | ! mm ) ) {
if ( is_user )
printk_ratelimited ( KERN_ERR " Page fault in user mode "
" with faulthandler_disabled()=%d "
" mm=%p \n " ,
faulthandler_disabled ( ) , mm ) ;
return bad_area_nosemaphore ( regs , address ) ;
}
2021-01-30 16:08:39 +03:00
interrupt_cond_local_irq_enable ( regs ) ;
2012-03-07 09:48:45 +04:00
2011-06-27 16:41:57 +04:00
perf_sw_event ( PERF_COUNT_SW_PAGE_FAULTS , 1 , regs , address ) ;
2009-03-13 14:21:33 +03:00
2013-09-10 17:14:42 +04:00
/*
2020-06-09 07:33:54 +03:00
* We want to do this outside mmap_lock , because reading code around nip
2013-09-10 17:14:42 +04:00
* can result in fault , which will cause a deadlock when called with
2020-06-09 07:33:54 +03:00
* mmap_lock held
2013-09-10 17:14:42 +04:00
*/
powerpc/mm: Evaluate user_mode(regs) only once in do_page_fault()
Analysis of the assembly code shows that when using user_mode(regs),
at least the 'andi.' is redone all the time, and also
the 'lwz ,132(r31)' most of the time. With the new form, the 'is_user'
is mapped to cr4, then all further use of is_user results in just
things like 'beq cr4,218 <do_page_fault+0x218>'
Without the patch:
50: 81 1e 00 84 lwz r8,132(r30)
54: 71 09 40 00 andi. r9,r8,16384
58: 40 82 00 0c bne 64 <do_page_fault+0x64>
84: 81 3e 00 84 lwz r9,132(r30)
8c: 71 2a 40 00 andi. r10,r9,16384
90: 41 a2 01 64 beq 1f4 <do_page_fault+0x1f4>
d4: 81 3e 00 84 lwz r9,132(r30)
dc: 71 28 40 00 andi. r8,r9,16384
e0: 41 82 02 08 beq 2e8 <do_page_fault+0x2e8>
108: 81 3e 00 84 lwz r9,132(r30)
110: 71 28 40 00 andi. r8,r9,16384
118: 41 82 02 28 beq 340 <do_page_fault+0x340>
1e4: 81 3e 00 84 lwz r9,132(r30)
1e8: 71 2a 40 00 andi. r10,r9,16384
1ec: 40 82 01 68 bne 354 <do_page_fault+0x354>
228: 81 3e 00 84 lwz r9,132(r30)
22c: 71 28 40 00 andi. r8,r9,16384
230: 41 82 ff c4 beq 1f4 <do_page_fault+0x1f4>
288: 71 2a 40 00 andi. r10,r9,16384
294: 41 a2 fe 60 beq f4 <do_page_fault+0xf4>
50c: 81 3e 00 84 lwz r9,132(r30)
514: 71 2a 40 00 andi. r10,r9,16384
518: 40 a2 fc e0 bne 1f8 <do_page_fault+0x1f8>
534: 81 3e 00 84 lwz r9,132(r30)
53c: 71 2a 40 00 andi. r10,r9,16384
540: 41 82 fc b8 beq 1f8 <do_page_fault+0x1f8>
This patch creates a local var called 'is_user' which contains the
result of user_mode(regs)
With the patch:
20: 81 03 00 84 lwz r8,132(r3)
48: 55 09 97 fe rlwinm r9,r8,18,31,31
58: 2e 09 00 00 cmpwi cr4,r9,0
5c: 40 92 00 0c bne cr4,68 <do_page_fault+0x68>
88: 41 b2 01 90 beq cr4,218 <do_page_fault+0x218>
d4: 40 92 01 d0 bne cr4,2a4 <do_page_fault+0x2a4>
120: 41 b2 00 f8 beq cr4,218 <do_page_fault+0x218>
138: 41 b2 ff a0 beq cr4,d8 <do_page_fault+0xd8>
1d4: 40 92 00 e0 bne cr4,2b4 <do_page_fault+0x2b4>
Signed-off-by: Christophe Leroy <christophe.leroy@c-s.fr>
Reviewed-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2017-04-19 15:56:30 +03:00
if ( is_user )
2013-09-13 02:13:39 +04:00
flags | = FAULT_FLAG_USER ;
2017-07-19 07:49:42 +03:00
if ( is_write )
flags | = FAULT_FLAG_WRITE ;
if ( is_exec )
flags | = FAULT_FLAG_INSTRUCTION ;
2013-09-13 02:13:39 +04:00
2005-09-26 10:04:21 +04:00
/* When running in the kernel we expect faults to occur only to
* addresses in user space . All other faults represent errors in the
2006-04-01 04:33:12 +04:00
* kernel and should generate an OOPS . Unfortunately , in the case of an
2020-06-09 07:33:54 +03:00
* erroneous fault occurring in a code path which already holds mmap_lock
2005-09-26 10:04:21 +04:00
* we will deadlock attempting to validate the fault against the
* address space . Luckily the kernel only validly references user
* space from well defined areas of code , which are listed in the
* exceptions table .
*
* As the vast majority of faults will be valid we will only perform
2006-04-01 04:33:12 +04:00
* the source reference check when there is a possibility of a deadlock .
2005-09-26 10:04:21 +04:00
* Attempt to lock the address space , if we cannot we then validate the
* source . If this is invalid we can skip the address space check ,
* thus avoiding the deadlock .
*/
2020-06-09 07:33:25 +03:00
if ( unlikely ( ! mmap_read_trylock ( mm ) ) ) {
powerpc/mm: Evaluate user_mode(regs) only once in do_page_fault()
Analysis of the assembly code shows that when using user_mode(regs),
at least the 'andi.' is redone all the time, and also
the 'lwz ,132(r31)' most of the time. With the new form, the 'is_user'
is mapped to cr4, then all further use of is_user results in just
things like 'beq cr4,218 <do_page_fault+0x218>'
Without the patch:
50: 81 1e 00 84 lwz r8,132(r30)
54: 71 09 40 00 andi. r9,r8,16384
58: 40 82 00 0c bne 64 <do_page_fault+0x64>
84: 81 3e 00 84 lwz r9,132(r30)
8c: 71 2a 40 00 andi. r10,r9,16384
90: 41 a2 01 64 beq 1f4 <do_page_fault+0x1f4>
d4: 81 3e 00 84 lwz r9,132(r30)
dc: 71 28 40 00 andi. r8,r9,16384
e0: 41 82 02 08 beq 2e8 <do_page_fault+0x2e8>
108: 81 3e 00 84 lwz r9,132(r30)
110: 71 28 40 00 andi. r8,r9,16384
118: 41 82 02 28 beq 340 <do_page_fault+0x340>
1e4: 81 3e 00 84 lwz r9,132(r30)
1e8: 71 2a 40 00 andi. r10,r9,16384
1ec: 40 82 01 68 bne 354 <do_page_fault+0x354>
228: 81 3e 00 84 lwz r9,132(r30)
22c: 71 28 40 00 andi. r8,r9,16384
230: 41 82 ff c4 beq 1f4 <do_page_fault+0x1f4>
288: 71 2a 40 00 andi. r10,r9,16384
294: 41 a2 fe 60 beq f4 <do_page_fault+0xf4>
50c: 81 3e 00 84 lwz r9,132(r30)
514: 71 2a 40 00 andi. r10,r9,16384
518: 40 a2 fc e0 bne 1f8 <do_page_fault+0x1f8>
534: 81 3e 00 84 lwz r9,132(r30)
53c: 71 2a 40 00 andi. r10,r9,16384
540: 41 82 fc b8 beq 1f8 <do_page_fault+0x1f8>
This patch creates a local var called 'is_user' which contains the
result of user_mode(regs)
With the patch:
20: 81 03 00 84 lwz r8,132(r3)
48: 55 09 97 fe rlwinm r9,r8,18,31,31
58: 2e 09 00 00 cmpwi cr4,r9,0
5c: 40 92 00 0c bne cr4,68 <do_page_fault+0x68>
88: 41 b2 01 90 beq cr4,218 <do_page_fault+0x218>
d4: 40 92 01 d0 bne cr4,2a4 <do_page_fault+0x2a4>
120: 41 b2 00 f8 beq cr4,218 <do_page_fault+0x218>
138: 41 b2 ff a0 beq cr4,d8 <do_page_fault+0xd8>
1d4: 40 92 00 e0 bne cr4,2b4 <do_page_fault+0x2b4>
Signed-off-by: Christophe Leroy <christophe.leroy@c-s.fr>
Reviewed-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2017-04-19 15:56:30 +03:00
if ( ! is_user & & ! search_exception_tables ( regs - > nip ) )
2017-07-19 07:49:35 +03:00
return bad_area_nosemaphore ( regs , address ) ;
2005-09-26 10:04:21 +04:00
2012-03-01 11:14:45 +04:00
retry :
2020-06-09 07:33:25 +03:00
mmap_read_lock ( mm ) ;
2012-03-07 09:48:45 +04:00
} else {
/*
* The above down_read_trylock ( ) might have succeeded in
* which case we ' ll have missed the might_sleep ( ) from
* down_read ( ) :
*/
might_sleep ( ) ;
2005-09-26 10:04:21 +04:00
}
vma = find_vma ( mm , address ) ;
2017-07-19 07:49:41 +03:00
if ( unlikely ( ! vma ) )
2017-07-19 07:49:35 +03:00
return bad_area ( regs , address ) ;
2005-09-26 10:04:21 +04:00
2020-07-24 12:25:27 +03:00
if ( unlikely ( vma - > vm_start > address ) ) {
if ( unlikely ( ! ( vma - > vm_flags & VM_GROWSDOWN ) ) )
2018-05-23 11:53:22 +03:00
return bad_area ( regs , address ) ;
2020-07-24 12:25:27 +03:00
if ( unlikely ( expand_stack ( vma , address ) ) )
return bad_area ( regs , address ) ;
2018-05-23 11:53:22 +03:00
}
2005-09-26 10:04:21 +04:00
2020-05-05 10:17:08 +03:00
if ( unlikely ( access_pkey_error ( is_write , is_exec ,
( error_code & DSISR_KEYFAULT ) , vma ) ) )
return bad_access_pkey ( regs , address , vma ) ;
2017-07-19 07:49:43 +03:00
if ( unlikely ( access_error ( is_write , is_exec , vma ) ) )
powerpc/mm: Fix SEGV on mapped region to return SEGV_ACCERR
The recent refactoring of the powerpc page fault handler in commit
c3350602e876 ("powerpc/mm: Make bad_area* helper functions") caused
access to protected memory regions to indicate SEGV_MAPERR instead of
the traditional SEGV_ACCERR in the si_code field of a user-space
signal handler. This can confuse debug libraries that temporarily
change the protection of memory regions, and expect to use SEGV_ACCERR
as an indication to restore access to a region.
This commit restores the previous behavior. The following program
exhibits the issue:
$ ./repro read || echo "FAILED"
$ ./repro write || echo "FAILED"
$ ./repro exec || echo "FAILED"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/mman.h>
#include <assert.h>
static void segv_handler(int n, siginfo_t *info, void *arg) {
_exit(info->si_code == SEGV_ACCERR ? 0 : 1);
}
int main(int argc, char **argv)
{
void *p = NULL;
struct sigaction act = {
.sa_sigaction = segv_handler,
.sa_flags = SA_SIGINFO,
};
assert(argc == 2);
p = mmap(NULL, getpagesize(),
(strcmp(argv[1], "write") == 0) ? PROT_READ : 0,
MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
assert(p != MAP_FAILED);
assert(sigaction(SIGSEGV, &act, NULL) == 0);
if (strcmp(argv[1], "read") == 0)
printf("%c", *(unsigned char *)p);
else if (strcmp(argv[1], "write") == 0)
*(unsigned char *)p = 0;
else if (strcmp(argv[1], "exec") == 0)
((void (*)(void))p)();
return 1; /* failed to generate SEGV */
}
Fixes: c3350602e876 ("powerpc/mm: Make bad_area* helper functions")
Cc: stable@vger.kernel.org # v4.14+
Signed-off-by: John Sperbeck <jsperbeck@google.com>
Acked-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
[mpe: Add commit references in change log]
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2018-01-01 08:24:58 +03:00
return bad_access ( regs , address ) ;
2005-09-26 10:04:21 +04:00
/*
* If for any reason at all we couldn ' t handle the fault ,
* make sure we exit gracefully rather than endlessly redo
* the fault .
*/
2020-08-12 04:38:31 +03:00
fault = handle_mm_fault ( vma , address , flags , regs ) ;
2018-01-19 04:50:40 +03:00
2017-07-19 07:49:44 +03:00
major | = fault & VM_FAULT_MAJOR ;
2017-02-14 19:45:11 +03:00
2020-04-02 07:08:22 +03:00
if ( fault_signal_pending ( fault , regs ) )
return user_mode ( regs ) ? 0 : SIGBUS ;
mm: avoid unnecessary page fault retires on shared memory types
I observed that for each of the shared file-backed page faults, we're very
likely to retry one more time for the 1st write fault upon no page. It's
because we'll need to release the mmap lock for dirty rate limit purpose
with balance_dirty_pages_ratelimited() (in fault_dirty_shared_page()).
Then after that throttling we return VM_FAULT_RETRY.
We did that probably because VM_FAULT_RETRY is the only way we can return
to the fault handler at that time telling it we've released the mmap lock.
However that's not ideal because it's very likely the fault does not need
to be retried at all since the pgtable was well installed before the
throttling, so the next continuous fault (including taking mmap read lock,
walk the pgtable, etc.) could be in most cases unnecessary.
It's not only slowing down page faults for shared file-backed, but also add
more mmap lock contention which is in most cases not needed at all.
To observe this, one could try to write to some shmem page and look at
"pgfault" value in /proc/vmstat, then we should expect 2 counts for each
shmem write simply because we retried, and vm event "pgfault" will capture
that.
To make it more efficient, add a new VM_FAULT_COMPLETED return code just to
show that we've completed the whole fault and released the lock. It's also
a hint that we should very possibly not need another fault immediately on
this page because we've just completed it.
This patch provides a ~12% perf boost on my aarch64 test VM with a simple
program sequentially dirtying 400MB shmem file being mmap()ed and these are
the time it needs:
Before: 650.980 ms (+-1.94%)
After: 569.396 ms (+-1.38%)
I believe it could help more than that.
We need some special care on GUP and the s390 pgfault handler (for gmap
code before returning from pgfault), the rest changes in the page fault
handlers should be relatively straightforward.
Another thing to mention is that mm_account_fault() does take this new
fault as a generic fault to be accounted, unlike VM_FAULT_RETRY.
I explicitly didn't touch hmm_vma_fault() and break_ksm() because they do
not handle VM_FAULT_RETRY even with existing code, so I'm literally keeping
them as-is.
Link: https://lkml.kernel.org/r/20220530183450.42886-1-peterx@redhat.com
Signed-off-by: Peter Xu <peterx@redhat.com>
Acked-by: Geert Uytterhoeven <geert@linux-m68k.org>
Acked-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: Johannes Weiner <hannes@cmpxchg.org>
Acked-by: Vineet Gupta <vgupta@kernel.org>
Acked-by: Guo Ren <guoren@kernel.org>
Acked-by: Max Filippov <jcmvbkbc@gmail.com>
Acked-by: Christian Borntraeger <borntraeger@linux.ibm.com>
Acked-by: Michael Ellerman <mpe@ellerman.id.au> (powerpc)
Acked-by: Catalin Marinas <catalin.marinas@arm.com>
Reviewed-by: Alistair Popple <apopple@nvidia.com>
Reviewed-by: Ingo Molnar <mingo@kernel.org>
Acked-by: Russell King (Oracle) <rmk+kernel@armlinux.org.uk> [arm part]
Acked-by: Heiko Carstens <hca@linux.ibm.com>
Cc: Vasily Gorbik <gor@linux.ibm.com>
Cc: Stafford Horne <shorne@gmail.com>
Cc: David S. Miller <davem@davemloft.net>
Cc: Johannes Berg <johannes@sipsolutions.net>
Cc: Brian Cain <bcain@quicinc.com>
Cc: Richard Henderson <rth@twiddle.net>
Cc: Richard Weinberger <richard@nod.at>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Janosch Frank <frankja@linux.ibm.com>
Cc: Albert Ou <aou@eecs.berkeley.edu>
Cc: Anton Ivanov <anton.ivanov@cambridgegreys.com>
Cc: Dave Hansen <dave.hansen@linux.intel.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Sven Schnelle <svens@linux.ibm.com>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: James Bottomley <James.Bottomley@HansenPartnership.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alexander Gordeev <agordeev@linux.ibm.com>
Cc: Jonas Bonn <jonas@southpole.se>
Cc: Will Deacon <will@kernel.org>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Michal Simek <monstr@monstr.eu>
Cc: Matt Turner <mattst88@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: David Hildenbrand <david@redhat.com>
Cc: Nicholas Piggin <npiggin@gmail.com>
Cc: Palmer Dabbelt <palmer@dabbelt.com>
Cc: Stefan Kristiansson <stefan.kristiansson@saunalahti.fi>
Cc: Paul Walmsley <paul.walmsley@sifive.com>
Cc: Ivan Kokshaysky <ink@jurassic.park.msu.ru>
Cc: Chris Zankel <chris@zankel.net>
Cc: Hugh Dickins <hughd@google.com>
Cc: Dinh Nguyen <dinguyen@kernel.org>
Cc: Rich Felker <dalias@libc.org>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Thomas Bogendoerfer <tsbogend@alpha.franken.de>
Cc: Helge Deller <deller@gmx.de>
Cc: Yoshinori Sato <ysato@users.osdn.me>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
2022-05-30 21:34:50 +03:00
/* The fault is fully completed (including releasing mmap lock) */
if ( fault & VM_FAULT_COMPLETED )
goto out ;
2017-02-14 19:45:11 +03:00
/*
2020-06-09 07:33:54 +03:00
* Handle the retry right now , the mmap_lock has been released in that
2017-02-14 19:45:11 +03:00
* case .
*/
if ( unlikely ( fault & VM_FAULT_RETRY ) ) {
2022-01-15 01:05:51 +03:00
flags | = FAULT_FLAG_TRIED ;
goto retry ;
2005-09-26 10:04:21 +04:00
}
2012-03-01 11:14:45 +04:00
2020-06-09 07:33:25 +03:00
mmap_read_unlock ( current - > mm ) ;
2017-07-19 07:49:36 +03:00
if ( unlikely ( fault & VM_FAULT_ERROR ) )
return mm_fault_error ( regs , address , fault ) ;
mm: avoid unnecessary page fault retires on shared memory types
I observed that for each of the shared file-backed page faults, we're very
likely to retry one more time for the 1st write fault upon no page. It's
because we'll need to release the mmap lock for dirty rate limit purpose
with balance_dirty_pages_ratelimited() (in fault_dirty_shared_page()).
Then after that throttling we return VM_FAULT_RETRY.
We did that probably because VM_FAULT_RETRY is the only way we can return
to the fault handler at that time telling it we've released the mmap lock.
However that's not ideal because it's very likely the fault does not need
to be retried at all since the pgtable was well installed before the
throttling, so the next continuous fault (including taking mmap read lock,
walk the pgtable, etc.) could be in most cases unnecessary.
It's not only slowing down page faults for shared file-backed, but also add
more mmap lock contention which is in most cases not needed at all.
To observe this, one could try to write to some shmem page and look at
"pgfault" value in /proc/vmstat, then we should expect 2 counts for each
shmem write simply because we retried, and vm event "pgfault" will capture
that.
To make it more efficient, add a new VM_FAULT_COMPLETED return code just to
show that we've completed the whole fault and released the lock. It's also
a hint that we should very possibly not need another fault immediately on
this page because we've just completed it.
This patch provides a ~12% perf boost on my aarch64 test VM with a simple
program sequentially dirtying 400MB shmem file being mmap()ed and these are
the time it needs:
Before: 650.980 ms (+-1.94%)
After: 569.396 ms (+-1.38%)
I believe it could help more than that.
We need some special care on GUP and the s390 pgfault handler (for gmap
code before returning from pgfault), the rest changes in the page fault
handlers should be relatively straightforward.
Another thing to mention is that mm_account_fault() does take this new
fault as a generic fault to be accounted, unlike VM_FAULT_RETRY.
I explicitly didn't touch hmm_vma_fault() and break_ksm() because they do
not handle VM_FAULT_RETRY even with existing code, so I'm literally keeping
them as-is.
Link: https://lkml.kernel.org/r/20220530183450.42886-1-peterx@redhat.com
Signed-off-by: Peter Xu <peterx@redhat.com>
Acked-by: Geert Uytterhoeven <geert@linux-m68k.org>
Acked-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: Johannes Weiner <hannes@cmpxchg.org>
Acked-by: Vineet Gupta <vgupta@kernel.org>
Acked-by: Guo Ren <guoren@kernel.org>
Acked-by: Max Filippov <jcmvbkbc@gmail.com>
Acked-by: Christian Borntraeger <borntraeger@linux.ibm.com>
Acked-by: Michael Ellerman <mpe@ellerman.id.au> (powerpc)
Acked-by: Catalin Marinas <catalin.marinas@arm.com>
Reviewed-by: Alistair Popple <apopple@nvidia.com>
Reviewed-by: Ingo Molnar <mingo@kernel.org>
Acked-by: Russell King (Oracle) <rmk+kernel@armlinux.org.uk> [arm part]
Acked-by: Heiko Carstens <hca@linux.ibm.com>
Cc: Vasily Gorbik <gor@linux.ibm.com>
Cc: Stafford Horne <shorne@gmail.com>
Cc: David S. Miller <davem@davemloft.net>
Cc: Johannes Berg <johannes@sipsolutions.net>
Cc: Brian Cain <bcain@quicinc.com>
Cc: Richard Henderson <rth@twiddle.net>
Cc: Richard Weinberger <richard@nod.at>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Janosch Frank <frankja@linux.ibm.com>
Cc: Albert Ou <aou@eecs.berkeley.edu>
Cc: Anton Ivanov <anton.ivanov@cambridgegreys.com>
Cc: Dave Hansen <dave.hansen@linux.intel.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Sven Schnelle <svens@linux.ibm.com>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: James Bottomley <James.Bottomley@HansenPartnership.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alexander Gordeev <agordeev@linux.ibm.com>
Cc: Jonas Bonn <jonas@southpole.se>
Cc: Will Deacon <will@kernel.org>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Michal Simek <monstr@monstr.eu>
Cc: Matt Turner <mattst88@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: David Hildenbrand <david@redhat.com>
Cc: Nicholas Piggin <npiggin@gmail.com>
Cc: Palmer Dabbelt <palmer@dabbelt.com>
Cc: Stefan Kristiansson <stefan.kristiansson@saunalahti.fi>
Cc: Paul Walmsley <paul.walmsley@sifive.com>
Cc: Ivan Kokshaysky <ink@jurassic.park.msu.ru>
Cc: Chris Zankel <chris@zankel.net>
Cc: Hugh Dickins <hughd@google.com>
Cc: Dinh Nguyen <dinguyen@kernel.org>
Cc: Rich Felker <dalias@libc.org>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Thomas Bogendoerfer <tsbogend@alpha.franken.de>
Cc: Helge Deller <deller@gmx.de>
Cc: Yoshinori Sato <ysato@users.osdn.me>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
2022-05-30 21:34:50 +03:00
out :
2012-03-01 11:14:45 +04:00
/*
2017-02-14 19:45:11 +03:00
* Major / minor page fault accounting .
2012-03-01 11:14:45 +04:00
*/
2020-08-12 04:38:31 +03:00
if ( major )
2017-07-19 07:49:37 +03:00
cmo_account_page_fault ( ) ;
2020-08-12 04:38:31 +03:00
2017-07-19 07:49:35 +03:00
return 0 ;
2017-07-19 07:49:23 +03:00
}
powerpc/64s/hash: improve context tracking of hash faults
This moves the 64s/hash context tracking from hash_page_mm() to
__do_hash_fault(), so it's no longer called by OCXL / SPU
accelerators, which was certainly the wrong thing to be doing,
because those callers are not low level interrupt handlers, so
should have entered a kernel context tracking already.
Then remain in kernel context for the duration of the fault,
rather than enter/exit for the hash fault then enter/exit for
the page fault, which is pointless.
Even still, calling exception_enter/exit in __do_hash_fault seems
questionable because that's touching per-cpu variables, tracing,
etc., which might have been interrupted by this hash fault or
themselves cause hash faults. But maybe I miss something because
hash_page_mm very deliberately calls trace_hash_fault too, for
example. So for now go with it, it's no worse than before, in this
regard.
Signed-off-by: Nicholas Piggin <npiggin@gmail.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/20210130130852.2952424-32-npiggin@gmail.com
2021-01-30 16:08:41 +03:00
NOKPROBE_SYMBOL ( ___do_page_fault ) ;
2017-07-19 07:49:23 +03:00
2021-03-16 13:42:03 +03:00
static __always_inline void __do_page_fault ( struct pt_regs * regs )
2017-07-19 07:49:23 +03:00
{
2021-01-30 16:08:23 +03:00
long err ;
powerpc/64s/hash: improve context tracking of hash faults
This moves the 64s/hash context tracking from hash_page_mm() to
__do_hash_fault(), so it's no longer called by OCXL / SPU
accelerators, which was certainly the wrong thing to be doing,
because those callers are not low level interrupt handlers, so
should have entered a kernel context tracking already.
Then remain in kernel context for the duration of the fault,
rather than enter/exit for the hash fault then enter/exit for
the page fault, which is pointless.
Even still, calling exception_enter/exit in __do_hash_fault seems
questionable because that's touching per-cpu variables, tracing,
etc., which might have been interrupted by this hash fault or
themselves cause hash faults. But maybe I miss something because
hash_page_mm very deliberately calls trace_hash_fault too, for
example. So for now go with it, it's no worse than before, in this
regard.
Signed-off-by: Nicholas Piggin <npiggin@gmail.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/20210130130852.2952424-32-npiggin@gmail.com
2021-01-30 16:08:41 +03:00
err = ___do_page_fault ( regs , regs - > dar , regs - > dsisr ) ;
2021-03-16 13:42:03 +03:00
if ( unlikely ( err ) )
bad_page_fault ( regs , err ) ;
powerpc/64s/hash: improve context tracking of hash faults
This moves the 64s/hash context tracking from hash_page_mm() to
__do_hash_fault(), so it's no longer called by OCXL / SPU
accelerators, which was certainly the wrong thing to be doing,
because those callers are not low level interrupt handlers, so
should have entered a kernel context tracking already.
Then remain in kernel context for the duration of the fault,
rather than enter/exit for the hash fault then enter/exit for
the page fault, which is pointless.
Even still, calling exception_enter/exit in __do_hash_fault seems
questionable because that's touching per-cpu variables, tracing,
etc., which might have been interrupted by this hash fault or
themselves cause hash faults. But maybe I miss something because
hash_page_mm very deliberately calls trace_hash_fault too, for
example. So for now go with it, it's no worse than before, in this
regard.
Signed-off-by: Nicholas Piggin <npiggin@gmail.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/20210130130852.2952424-32-npiggin@gmail.com
2021-01-30 16:08:41 +03:00
}
2021-03-16 13:42:03 +03:00
DEFINE_INTERRUPT_HANDLER ( do_page_fault )
powerpc/64s/hash: improve context tracking of hash faults
This moves the 64s/hash context tracking from hash_page_mm() to
__do_hash_fault(), so it's no longer called by OCXL / SPU
accelerators, which was certainly the wrong thing to be doing,
because those callers are not low level interrupt handlers, so
should have entered a kernel context tracking already.
Then remain in kernel context for the duration of the fault,
rather than enter/exit for the hash fault then enter/exit for
the page fault, which is pointless.
Even still, calling exception_enter/exit in __do_hash_fault seems
questionable because that's touching per-cpu variables, tracing,
etc., which might have been interrupted by this hash fault or
themselves cause hash faults. But maybe I miss something because
hash_page_mm very deliberately calls trace_hash_fault too, for
example. So for now go with it, it's no worse than before, in this
regard.
Signed-off-by: Nicholas Piggin <npiggin@gmail.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/20210130130852.2952424-32-npiggin@gmail.com
2021-01-30 16:08:41 +03:00
{
2021-03-16 13:42:03 +03:00
__do_page_fault ( regs ) ;
2005-09-26 10:04:21 +04:00
}
powerpc/64s/hash: improve context tracking of hash faults
This moves the 64s/hash context tracking from hash_page_mm() to
__do_hash_fault(), so it's no longer called by OCXL / SPU
accelerators, which was certainly the wrong thing to be doing,
because those callers are not low level interrupt handlers, so
should have entered a kernel context tracking already.
Then remain in kernel context for the duration of the fault,
rather than enter/exit for the hash fault then enter/exit for
the page fault, which is pointless.
Even still, calling exception_enter/exit in __do_hash_fault seems
questionable because that's touching per-cpu variables, tracing,
etc., which might have been interrupted by this hash fault or
themselves cause hash faults. But maybe I miss something because
hash_page_mm very deliberately calls trace_hash_fault too, for
example. So for now go with it, it's no worse than before, in this
regard.
Signed-off-by: Nicholas Piggin <npiggin@gmail.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/20210130130852.2952424-32-npiggin@gmail.com
2021-01-30 16:08:41 +03:00
# ifdef CONFIG_PPC_BOOK3S_64
/* Same as do_page_fault but interrupt entry has already run in do_hash_fault */
2021-03-16 13:42:03 +03:00
void hash__do_page_fault ( struct pt_regs * regs )
powerpc/64s/hash: improve context tracking of hash faults
This moves the 64s/hash context tracking from hash_page_mm() to
__do_hash_fault(), so it's no longer called by OCXL / SPU
accelerators, which was certainly the wrong thing to be doing,
because those callers are not low level interrupt handlers, so
should have entered a kernel context tracking already.
Then remain in kernel context for the duration of the fault,
rather than enter/exit for the hash fault then enter/exit for
the page fault, which is pointless.
Even still, calling exception_enter/exit in __do_hash_fault seems
questionable because that's touching per-cpu variables, tracing,
etc., which might have been interrupted by this hash fault or
themselves cause hash faults. But maybe I miss something because
hash_page_mm very deliberately calls trace_hash_fault too, for
example. So for now go with it, it's no worse than before, in this
regard.
Signed-off-by: Nicholas Piggin <npiggin@gmail.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/20210130130852.2952424-32-npiggin@gmail.com
2021-01-30 16:08:41 +03:00
{
2021-03-16 13:42:03 +03:00
__do_page_fault ( regs ) ;
powerpc/64s/hash: improve context tracking of hash faults
This moves the 64s/hash context tracking from hash_page_mm() to
__do_hash_fault(), so it's no longer called by OCXL / SPU
accelerators, which was certainly the wrong thing to be doing,
because those callers are not low level interrupt handlers, so
should have entered a kernel context tracking already.
Then remain in kernel context for the duration of the fault,
rather than enter/exit for the hash fault then enter/exit for
the page fault, which is pointless.
Even still, calling exception_enter/exit in __do_hash_fault seems
questionable because that's touching per-cpu variables, tracing,
etc., which might have been interrupted by this hash fault or
themselves cause hash faults. But maybe I miss something because
hash_page_mm very deliberately calls trace_hash_fault too, for
example. So for now go with it, it's no worse than before, in this
regard.
Signed-off-by: Nicholas Piggin <npiggin@gmail.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/20210130130852.2952424-32-npiggin@gmail.com
2021-01-30 16:08:41 +03:00
}
NOKPROBE_SYMBOL ( hash__do_page_fault ) ;
# endif
2005-09-26 10:04:21 +04:00
/*
* bad_page_fault is called when we have a bad access from the kernel .
* It is called from the DSI and ISI handlers in head . S and from some
* of the procedures in traps . c .
*/
2021-03-16 13:42:03 +03:00
static void __bad_page_fault ( struct pt_regs * regs , int sig )
2005-09-26 10:04:21 +04:00
{
2019-08-21 18:21:55 +03:00
int is_write = page_fault_is_write ( regs - > dsisr ) ;
2022-02-22 14:34:49 +03:00
const char * msg ;
2005-09-26 10:04:21 +04:00
/* kernel has accessed a bad area */
2005-11-07 01:54:36 +03:00
2022-02-22 14:34:49 +03:00
if ( regs - > dar < PAGE_SIZE )
msg = " Kernel NULL pointer dereference " ;
else
msg = " Unable to handle kernel data access " ;
2018-01-12 05:28:49 +03:00
switch ( TRAP ( regs ) ) {
2021-04-14 14:00:33 +03:00
case INTERRUPT_DATA_STORAGE :
case INTERRUPT_H_DATA_STORAGE :
2022-02-22 14:34:49 +03:00
pr_alert ( " BUG: %s on %s at 0x%08lx \n " , msg ,
2019-08-21 18:21:55 +03:00
is_write ? " write " : " read " , regs - > dar ) ;
2006-11-08 02:22:59 +03:00
break ;
2022-02-22 14:34:49 +03:00
case INTERRUPT_DATA_SEGMENT :
pr_alert ( " BUG: %s at 0x%08lx \n " , msg , regs - > dar ) ;
break ;
2021-04-14 14:00:33 +03:00
case INTERRUPT_INST_STORAGE :
case INTERRUPT_INST_SEGMENT :
2018-12-14 18:23:33 +03:00
pr_alert ( " BUG: Unable to handle kernel instruction fetch%s " ,
regs - > nip < PAGE_SIZE ? " (NULL pointer?) \n " : " \n " ) ;
2006-11-08 02:22:59 +03:00
break ;
2021-04-14 14:00:33 +03:00
case INTERRUPT_ALIGNMENT :
2018-12-14 18:23:33 +03:00
pr_alert ( " BUG: Unable to handle kernel unaligned access at 0x%08lx \n " ,
regs - > dar ) ;
2015-07-02 07:56:20 +03:00
break ;
2006-11-08 02:22:59 +03:00
default :
2018-12-14 18:23:33 +03:00
pr_alert ( " BUG: Unable to handle unknown paging fault at 0x%08lx \n " ,
regs - > dar ) ;
2006-11-08 02:22:59 +03:00
break ;
2005-11-07 01:54:36 +03:00
}
printk ( KERN_ALERT " Faulting instruction address: 0x%08lx \n " ,
regs - > nip ) ;
2014-09-12 17:16:18 +04:00
if ( task_stack_end_corrupted ( current ) )
2010-08-24 17:15:28 +04:00
printk ( KERN_ALERT " Thread overran stack, or stack corrupted \n " ) ;
2005-09-26 10:04:21 +04:00
die ( " Kernel access of bad area " , regs , sig ) ;
}
2020-12-09 08:29:25 +03:00
2021-01-30 16:08:21 +03:00
void bad_page_fault ( struct pt_regs * regs , int sig )
2020-12-09 08:29:25 +03:00
{
const struct exception_table_entry * entry ;
/* Are we prepared to handle this fault? */
entry = search_exception_tables ( instruction_pointer ( regs ) ) ;
if ( entry )
instruction_pointer_set ( regs , extable_fixup ( entry ) ) ;
else
2021-01-30 16:08:21 +03:00
__bad_page_fault ( regs , sig ) ;
2020-12-09 08:29:25 +03:00
}
2021-01-30 16:08:22 +03:00
# ifdef CONFIG_PPC_BOOK3S_64
2021-01-30 16:08:38 +03:00
DEFINE_INTERRUPT_HANDLER ( do_bad_page_fault_segv )
2021-01-30 16:08:22 +03:00
{
bad_page_fault ( regs , SIGSEGV ) ;
}
2021-12-01 17:41:39 +03:00
/*
* In radix , segment interrupts indicate the EA is not addressable by the
* page table geometry , so they are always sent here .
*
* In hash , this is called if do_slb_fault returns error . Typically it is
* because the EA was outside the region allowed by software .
*/
DEFINE_INTERRUPT_HANDLER ( do_bad_segment_interrupt )
{
int err = regs - > result ;
if ( err = = - EFAULT ) {
if ( user_mode ( regs ) )
_exception ( SIGSEGV , regs , SEGV_BNDERR , regs - > dar ) ;
else
bad_page_fault ( regs , SIGSEGV ) ;
} else if ( err = = - EINVAL ) {
unrecoverable_exception ( regs ) ;
} else {
BUG ( ) ;
}
}
2021-01-30 16:08:22 +03:00
# endif
