![Paul Gortmaker](/assets/img/avatar_default.png)
Historically a lot of these existed because we did not have a distinction between what was modular code and what was providing support to modules via EXPORT_SYMBOL and friends. That changed when we forked out support for the latter into the export.h file. This means we should be able to reduce the usage of module.h in code that is obj-y Makefile or bool Kconfig. The advantage in doing so is that module.h itself sources about 15 other headers; adding significantly to what we feed cpp, and it can obscure what headers we are effectively using. Since module.h was the source for init.h (for __init) and for export.h (for EXPORT_SYMBOL) we consider each obj-y/bool instance for the presence of either and replace as needed. Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com> Cc: linux-mips@linux-mips.org Patchwork: https://patchwork.linux-mips.org/patch/14033/ Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
343 lines
8.7 KiB
C
343 lines
8.7 KiB
C
/*
|
|
* This file is subject to the terms and conditions of the GNU General Public
|
|
* License. See the file "COPYING" in the main directory of this archive
|
|
* for more details.
|
|
*
|
|
* Copyright (C) 1995 - 2000 by Ralf Baechle
|
|
*/
|
|
#include <linux/context_tracking.h>
|
|
#include <linux/signal.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/string.h>
|
|
#include <linux/types.h>
|
|
#include <linux/ptrace.h>
|
|
#include <linux/ratelimit.h>
|
|
#include <linux/mman.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/smp.h>
|
|
#include <linux/kprobes.h>
|
|
#include <linux/perf_event.h>
|
|
#include <linux/uaccess.h>
|
|
|
|
#include <asm/branch.h>
|
|
#include <asm/mmu_context.h>
|
|
#include <asm/ptrace.h>
|
|
#include <asm/highmem.h> /* For VMALLOC_END */
|
|
#include <linux/kdebug.h>
|
|
|
|
int show_unhandled_signals = 1;
|
|
|
|
/*
|
|
* This routine handles page faults. It determines the address,
|
|
* and the problem, and then passes it off to one of the appropriate
|
|
* routines.
|
|
*/
|
|
static void __kprobes __do_page_fault(struct pt_regs *regs, unsigned long write,
|
|
unsigned long address)
|
|
{
|
|
struct vm_area_struct * vma = NULL;
|
|
struct task_struct *tsk = current;
|
|
struct mm_struct *mm = tsk->mm;
|
|
const int field = sizeof(unsigned long) * 2;
|
|
siginfo_t info;
|
|
int fault;
|
|
unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
|
|
|
|
static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);
|
|
|
|
#if 0
|
|
printk("Cpu%d[%s:%d:%0*lx:%ld:%0*lx]\n", raw_smp_processor_id(),
|
|
current->comm, current->pid, field, address, write,
|
|
field, regs->cp0_epc);
|
|
#endif
|
|
|
|
#ifdef CONFIG_KPROBES
|
|
/*
|
|
* This is to notify the fault handler of the kprobes.
|
|
*/
|
|
if (notify_die(DIE_PAGE_FAULT, "page fault", regs, -1,
|
|
current->thread.trap_nr, SIGSEGV) == NOTIFY_STOP)
|
|
return;
|
|
#endif
|
|
|
|
info.si_code = SEGV_MAPERR;
|
|
|
|
/*
|
|
* We fault-in kernel-space virtual memory on-demand. The
|
|
* 'reference' page table is init_mm.pgd.
|
|
*
|
|
* NOTE! We MUST NOT take any locks for this case. We may
|
|
* be in an interrupt or a critical region, and should
|
|
* only copy the information from the master page table,
|
|
* nothing more.
|
|
*/
|
|
#ifdef CONFIG_64BIT
|
|
# define VMALLOC_FAULT_TARGET no_context
|
|
#else
|
|
# define VMALLOC_FAULT_TARGET vmalloc_fault
|
|
#endif
|
|
|
|
if (unlikely(address >= VMALLOC_START && address <= VMALLOC_END))
|
|
goto VMALLOC_FAULT_TARGET;
|
|
#ifdef MODULE_START
|
|
if (unlikely(address >= MODULE_START && address < MODULE_END))
|
|
goto VMALLOC_FAULT_TARGET;
|
|
#endif
|
|
|
|
/*
|
|
* If we're in an interrupt or have no user
|
|
* context, we must not take the fault..
|
|
*/
|
|
if (faulthandler_disabled() || !mm)
|
|
goto bad_area_nosemaphore;
|
|
|
|
if (user_mode(regs))
|
|
flags |= FAULT_FLAG_USER;
|
|
retry:
|
|
down_read(&mm->mmap_sem);
|
|
vma = find_vma(mm, address);
|
|
if (!vma)
|
|
goto bad_area;
|
|
if (vma->vm_start <= address)
|
|
goto good_area;
|
|
if (!(vma->vm_flags & VM_GROWSDOWN))
|
|
goto bad_area;
|
|
if (expand_stack(vma, address))
|
|
goto bad_area;
|
|
/*
|
|
* Ok, we have a good vm_area for this memory access, so
|
|
* we can handle it..
|
|
*/
|
|
good_area:
|
|
info.si_code = SEGV_ACCERR;
|
|
|
|
if (write) {
|
|
if (!(vma->vm_flags & VM_WRITE))
|
|
goto bad_area;
|
|
flags |= FAULT_FLAG_WRITE;
|
|
} else {
|
|
if (cpu_has_rixi) {
|
|
if (address == regs->cp0_epc && !(vma->vm_flags & VM_EXEC)) {
|
|
#if 0
|
|
pr_notice("Cpu%d[%s:%d:%0*lx:%ld:%0*lx] XI violation\n",
|
|
raw_smp_processor_id(),
|
|
current->comm, current->pid,
|
|
field, address, write,
|
|
field, regs->cp0_epc);
|
|
#endif
|
|
goto bad_area;
|
|
}
|
|
if (!(vma->vm_flags & VM_READ) &&
|
|
exception_epc(regs) != address) {
|
|
#if 0
|
|
pr_notice("Cpu%d[%s:%d:%0*lx:%ld:%0*lx] RI violation\n",
|
|
raw_smp_processor_id(),
|
|
current->comm, current->pid,
|
|
field, address, write,
|
|
field, regs->cp0_epc);
|
|
#endif
|
|
goto bad_area;
|
|
}
|
|
} else {
|
|
if (!(vma->vm_flags & (VM_READ | VM_WRITE | VM_EXEC)))
|
|
goto bad_area;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If for any reason at all we couldn't handle the fault,
|
|
* make sure we exit gracefully rather than endlessly redo
|
|
* the fault.
|
|
*/
|
|
fault = handle_mm_fault(vma, address, flags);
|
|
|
|
if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current))
|
|
return;
|
|
|
|
perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);
|
|
if (unlikely(fault & VM_FAULT_ERROR)) {
|
|
if (fault & VM_FAULT_OOM)
|
|
goto out_of_memory;
|
|
else if (fault & VM_FAULT_SIGSEGV)
|
|
goto bad_area;
|
|
else if (fault & VM_FAULT_SIGBUS)
|
|
goto do_sigbus;
|
|
BUG();
|
|
}
|
|
if (flags & FAULT_FLAG_ALLOW_RETRY) {
|
|
if (fault & VM_FAULT_MAJOR) {
|
|
perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1,
|
|
regs, address);
|
|
tsk->maj_flt++;
|
|
} else {
|
|
perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1,
|
|
regs, address);
|
|
tsk->min_flt++;
|
|
}
|
|
if (fault & VM_FAULT_RETRY) {
|
|
flags &= ~FAULT_FLAG_ALLOW_RETRY;
|
|
flags |= FAULT_FLAG_TRIED;
|
|
|
|
/*
|
|
* No need to up_read(&mm->mmap_sem) as we would
|
|
* have already released it in __lock_page_or_retry
|
|
* in mm/filemap.c.
|
|
*/
|
|
|
|
goto retry;
|
|
}
|
|
}
|
|
|
|
up_read(&mm->mmap_sem);
|
|
return;
|
|
|
|
/*
|
|
* Something tried to access memory that isn't in our memory map..
|
|
* Fix it, but check if it's kernel or user first..
|
|
*/
|
|
bad_area:
|
|
up_read(&mm->mmap_sem);
|
|
|
|
bad_area_nosemaphore:
|
|
/* User mode accesses just cause a SIGSEGV */
|
|
if (user_mode(regs)) {
|
|
tsk->thread.cp0_badvaddr = address;
|
|
tsk->thread.error_code = write;
|
|
if (show_unhandled_signals &&
|
|
unhandled_signal(tsk, SIGSEGV) &&
|
|
__ratelimit(&ratelimit_state)) {
|
|
pr_info("\ndo_page_fault(): sending SIGSEGV to %s for invalid %s %0*lx",
|
|
tsk->comm,
|
|
write ? "write access to" : "read access from",
|
|
field, address);
|
|
pr_info("epc = %0*lx in", field,
|
|
(unsigned long) regs->cp0_epc);
|
|
print_vma_addr(" ", regs->cp0_epc);
|
|
pr_info("ra = %0*lx in", field,
|
|
(unsigned long) regs->regs[31]);
|
|
print_vma_addr(" ", regs->regs[31]);
|
|
pr_info("\n");
|
|
}
|
|
current->thread.trap_nr = (regs->cp0_cause >> 2) & 0x1f;
|
|
info.si_signo = SIGSEGV;
|
|
info.si_errno = 0;
|
|
/* info.si_code has been set above */
|
|
info.si_addr = (void __user *) address;
|
|
force_sig_info(SIGSEGV, &info, tsk);
|
|
return;
|
|
}
|
|
|
|
no_context:
|
|
/* Are we prepared to handle this kernel fault? */
|
|
if (fixup_exception(regs)) {
|
|
current->thread.cp0_baduaddr = address;
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Oops. The kernel tried to access some bad page. We'll have to
|
|
* terminate things with extreme prejudice.
|
|
*/
|
|
bust_spinlocks(1);
|
|
|
|
printk(KERN_ALERT "CPU %d Unable to handle kernel paging request at "
|
|
"virtual address %0*lx, epc == %0*lx, ra == %0*lx\n",
|
|
raw_smp_processor_id(), field, address, field, regs->cp0_epc,
|
|
field, regs->regs[31]);
|
|
die("Oops", regs);
|
|
|
|
out_of_memory:
|
|
/*
|
|
* We ran out of memory, call the OOM killer, and return the userspace
|
|
* (which will retry the fault, or kill us if we got oom-killed).
|
|
*/
|
|
up_read(&mm->mmap_sem);
|
|
if (!user_mode(regs))
|
|
goto no_context;
|
|
pagefault_out_of_memory();
|
|
return;
|
|
|
|
do_sigbus:
|
|
up_read(&mm->mmap_sem);
|
|
|
|
/* Kernel mode? Handle exceptions or die */
|
|
if (!user_mode(regs))
|
|
goto no_context;
|
|
else
|
|
/*
|
|
* Send a sigbus, regardless of whether we were in kernel
|
|
* or user mode.
|
|
*/
|
|
#if 0
|
|
printk("do_page_fault() #3: sending SIGBUS to %s for "
|
|
"invalid %s\n%0*lx (epc == %0*lx, ra == %0*lx)\n",
|
|
tsk->comm,
|
|
write ? "write access to" : "read access from",
|
|
field, address,
|
|
field, (unsigned long) regs->cp0_epc,
|
|
field, (unsigned long) regs->regs[31]);
|
|
#endif
|
|
current->thread.trap_nr = (regs->cp0_cause >> 2) & 0x1f;
|
|
tsk->thread.cp0_badvaddr = address;
|
|
info.si_signo = SIGBUS;
|
|
info.si_errno = 0;
|
|
info.si_code = BUS_ADRERR;
|
|
info.si_addr = (void __user *) address;
|
|
force_sig_info(SIGBUS, &info, tsk);
|
|
|
|
return;
|
|
#ifndef CONFIG_64BIT
|
|
vmalloc_fault:
|
|
{
|
|
/*
|
|
* Synchronize this task's top level page-table
|
|
* with the 'reference' page table.
|
|
*
|
|
* Do _not_ use "tsk" here. We might be inside
|
|
* an interrupt in the middle of a task switch..
|
|
*/
|
|
int offset = __pgd_offset(address);
|
|
pgd_t *pgd, *pgd_k;
|
|
pud_t *pud, *pud_k;
|
|
pmd_t *pmd, *pmd_k;
|
|
pte_t *pte_k;
|
|
|
|
pgd = (pgd_t *) pgd_current[raw_smp_processor_id()] + offset;
|
|
pgd_k = init_mm.pgd + offset;
|
|
|
|
if (!pgd_present(*pgd_k))
|
|
goto no_context;
|
|
set_pgd(pgd, *pgd_k);
|
|
|
|
pud = pud_offset(pgd, address);
|
|
pud_k = pud_offset(pgd_k, address);
|
|
if (!pud_present(*pud_k))
|
|
goto no_context;
|
|
|
|
pmd = pmd_offset(pud, address);
|
|
pmd_k = pmd_offset(pud_k, address);
|
|
if (!pmd_present(*pmd_k))
|
|
goto no_context;
|
|
set_pmd(pmd, *pmd_k);
|
|
|
|
pte_k = pte_offset_kernel(pmd_k, address);
|
|
if (!pte_present(*pte_k))
|
|
goto no_context;
|
|
return;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
asmlinkage void __kprobes do_page_fault(struct pt_regs *regs,
|
|
unsigned long write, unsigned long address)
|
|
{
|
|
enum ctx_state prev_state;
|
|
|
|
prev_state = exception_enter();
|
|
__do_page_fault(regs, write, address);
|
|
exception_exit(prev_state);
|
|
}
|