2008-05-20 01:53:02 +02:00
|
|
|
/*
|
2005-04-17 00:20:36 +02:00
|
|
|
* fault.c: Page fault handlers for the Sparc.
|
|
|
|
*
|
|
|
|
* Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
|
|
|
|
* Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)
|
|
|
|
* Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <asm/head.h>
|
|
|
|
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/ptrace.h>
|
|
|
|
#include <linux/mman.h>
|
|
|
|
#include <linux/threads.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/signal.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/smp.h>
|
2010-01-20 12:04:14 +01:00
|
|
|
#include <linux/perf_event.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/module.h>
|
2007-05-08 09:27:03 +02:00
|
|
|
#include <linux/kdebug.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#include <asm/system.h>
|
|
|
|
#include <asm/page.h>
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/memreg.h>
|
|
|
|
#include <asm/openprom.h>
|
|
|
|
#include <asm/oplib.h>
|
|
|
|
#include <asm/smp.h>
|
|
|
|
#include <asm/traps.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
|
|
|
|
extern int prom_node_root;
|
|
|
|
|
2010-03-01 09:02:23 +01:00
|
|
|
int show_unhandled_signals = 1;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* At boot time we determine these two values necessary for setting
|
|
|
|
* up the segment maps and page table entries (pte's).
|
|
|
|
*/
|
|
|
|
|
|
|
|
int num_segmaps, num_contexts;
|
|
|
|
int invalid_segment;
|
|
|
|
|
|
|
|
/* various Virtual Address Cache parameters we find at boot time... */
|
|
|
|
|
|
|
|
int vac_size, vac_linesize, vac_do_hw_vac_flushes;
|
|
|
|
int vac_entries_per_context, vac_entries_per_segment;
|
|
|
|
int vac_entries_per_page;
|
|
|
|
|
2008-05-02 07:28:17 +02:00
|
|
|
/* Return how much physical memory we have. */
|
|
|
|
unsigned long probe_memory(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-05-02 07:28:17 +02:00
|
|
|
unsigned long total = 0;
|
|
|
|
int i;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-05-02 07:28:17 +02:00
|
|
|
for (i = 0; sp_banks[i].num_bytes; i++)
|
|
|
|
total += sp_banks[i].num_bytes;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
return total;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern void sun4c_complete_all_stores(void);
|
|
|
|
|
|
|
|
/* Whee, a level 15 NMI interrupt memory error. Let's have fun... */
|
|
|
|
asmlinkage void sparc_lvl15_nmi(struct pt_regs *regs, unsigned long serr,
|
|
|
|
unsigned long svaddr, unsigned long aerr,
|
|
|
|
unsigned long avaddr)
|
|
|
|
{
|
|
|
|
sun4c_complete_all_stores();
|
|
|
|
printk("FAULT: NMI received\n");
|
|
|
|
printk("SREGS: Synchronous Error %08lx\n", serr);
|
|
|
|
printk(" Synchronous Vaddr %08lx\n", svaddr);
|
|
|
|
printk(" Asynchronous Error %08lx\n", aerr);
|
|
|
|
printk(" Asynchronous Vaddr %08lx\n", avaddr);
|
|
|
|
if (sun4c_memerr_reg)
|
|
|
|
printk(" Memory Parity Error %08lx\n", *sun4c_memerr_reg);
|
|
|
|
printk("REGISTER DUMP:\n");
|
|
|
|
show_regs(regs);
|
|
|
|
prom_halt();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void unhandled_fault(unsigned long, struct task_struct *,
|
|
|
|
struct pt_regs *) __attribute__ ((noreturn));
|
|
|
|
|
|
|
|
static void unhandled_fault(unsigned long address, struct task_struct *tsk,
|
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
if((unsigned long) address < PAGE_SIZE) {
|
|
|
|
printk(KERN_ALERT
|
|
|
|
"Unable to handle kernel NULL pointer dereference\n");
|
|
|
|
} else {
|
|
|
|
printk(KERN_ALERT "Unable to handle kernel paging request "
|
|
|
|
"at virtual address %08lx\n", address);
|
|
|
|
}
|
|
|
|
printk(KERN_ALERT "tsk->{mm,active_mm}->context = %08lx\n",
|
|
|
|
(tsk->mm ? tsk->mm->context : tsk->active_mm->context));
|
|
|
|
printk(KERN_ALERT "tsk->{mm,active_mm}->pgd = %08lx\n",
|
|
|
|
(tsk->mm ? (unsigned long) tsk->mm->pgd :
|
|
|
|
(unsigned long) tsk->active_mm->pgd));
|
|
|
|
die_if_kernel("Oops", regs);
|
|
|
|
}
|
|
|
|
|
|
|
|
asmlinkage int lookup_fault(unsigned long pc, unsigned long ret_pc,
|
|
|
|
unsigned long address)
|
|
|
|
{
|
|
|
|
struct pt_regs regs;
|
|
|
|
unsigned long g2;
|
|
|
|
unsigned int insn;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
i = search_extables_range(ret_pc, &g2);
|
|
|
|
switch (i) {
|
|
|
|
case 3:
|
|
|
|
/* load & store will be handled by fixup */
|
|
|
|
return 3;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
/* store will be handled by fixup, load will bump out */
|
|
|
|
/* for _to_ macros */
|
|
|
|
insn = *((unsigned int *) pc);
|
|
|
|
if ((insn >> 21) & 1)
|
|
|
|
return 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
/* load will be handled by fixup, store will bump out */
|
|
|
|
/* for _from_ macros */
|
|
|
|
insn = *((unsigned int *) pc);
|
|
|
|
if (!((insn >> 21) & 1) || ((insn>>19)&0x3f) == 15)
|
|
|
|
return 2;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
2011-06-03 16:45:23 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
memset(®s, 0, sizeof (regs));
|
|
|
|
regs.pc = pc;
|
|
|
|
regs.npc = pc + 4;
|
|
|
|
__asm__ __volatile__(
|
|
|
|
"rd %%psr, %0\n\t"
|
|
|
|
"nop\n\t"
|
|
|
|
"nop\n\t"
|
|
|
|
"nop\n" : "=r" (regs.psr));
|
|
|
|
unhandled_fault(address, current, ®s);
|
|
|
|
|
|
|
|
/* Not reached */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-03-01 09:02:23 +01:00
|
|
|
static inline void
|
|
|
|
show_signal_msg(struct pt_regs *regs, int sig, int code,
|
|
|
|
unsigned long address, struct task_struct *tsk)
|
|
|
|
{
|
|
|
|
if (!unhandled_signal(tsk, sig))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!printk_ratelimit())
|
|
|
|
return;
|
|
|
|
|
|
|
|
printk("%s%s[%d]: segfault at %lx ip %p (rpc %p) sp %p error %x",
|
|
|
|
task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG,
|
|
|
|
tsk->comm, task_pid_nr(tsk), address,
|
|
|
|
(void *)regs->pc, (void *)regs->u_regs[UREG_I7],
|
|
|
|
(void *)regs->u_regs[UREG_FP], code);
|
|
|
|
|
|
|
|
print_vma_addr(KERN_CONT " in ", regs->pc);
|
|
|
|
|
|
|
|
printk(KERN_CONT "\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __do_fault_siginfo(int code, int sig, struct pt_regs *regs,
|
|
|
|
unsigned long addr)
|
|
|
|
{
|
|
|
|
siginfo_t info;
|
|
|
|
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_code = code;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_addr = (void __user *) addr;
|
|
|
|
info.si_trapno = 0;
|
|
|
|
|
|
|
|
if (unlikely(show_unhandled_signals))
|
|
|
|
show_signal_msg(regs, sig, info.si_code,
|
|
|
|
addr, current);
|
|
|
|
|
|
|
|
force_sig_info (sig, &info, current);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
extern unsigned long safe_compute_effective_address(struct pt_regs *,
|
|
|
|
unsigned int);
|
|
|
|
|
|
|
|
static unsigned long compute_si_addr(struct pt_regs *regs, int text_fault)
|
|
|
|
{
|
|
|
|
unsigned int insn;
|
|
|
|
|
|
|
|
if (text_fault)
|
|
|
|
return regs->pc;
|
|
|
|
|
|
|
|
if (regs->psr & PSR_PS) {
|
|
|
|
insn = *(unsigned int *) regs->pc;
|
|
|
|
} else {
|
|
|
|
__get_user(insn, (unsigned int *) regs->pc);
|
|
|
|
}
|
|
|
|
|
|
|
|
return safe_compute_effective_address(regs, insn);
|
|
|
|
}
|
|
|
|
|
2010-03-01 09:02:23 +01:00
|
|
|
static noinline void do_fault_siginfo(int code, int sig, struct pt_regs *regs,
|
|
|
|
int text_fault)
|
|
|
|
{
|
|
|
|
unsigned long addr = compute_si_addr(regs, text_fault);
|
|
|
|
|
|
|
|
__do_fault_siginfo(code, sig, regs, addr);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
asmlinkage void do_sparc_fault(struct pt_regs *regs, int text_fault, int write,
|
|
|
|
unsigned long address)
|
|
|
|
{
|
|
|
|
struct vm_area_struct *vma;
|
|
|
|
struct task_struct *tsk = current;
|
|
|
|
struct mm_struct *mm = tsk->mm;
|
|
|
|
unsigned int fixup;
|
|
|
|
unsigned long g2;
|
|
|
|
int from_user = !(regs->psr & PSR_PS);
|
2010-03-01 09:02:23 +01:00
|
|
|
int fault, code;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if(text_fault)
|
|
|
|
address = regs->pc;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2011-03-09 22:00:47 +01:00
|
|
|
code = SEGV_MAPERR;
|
2008-09-01 05:59:37 +02:00
|
|
|
if (!ARCH_SUN4C && address >= TASK_SIZE)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto vmalloc_fault;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we're in an interrupt or have no user
|
|
|
|
* context, we must not take the fault..
|
|
|
|
*/
|
|
|
|
if (in_atomic() || !mm)
|
|
|
|
goto no_context;
|
|
|
|
|
2011-06-27 14:41:57 +02:00
|
|
|
perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);
|
2010-01-20 12:04:14 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
down_read(&mm->mmap_sem);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The kernel referencing a bad kernel pointer can lock up
|
|
|
|
* a sun4c machine completely, so we must attempt recovery.
|
|
|
|
*/
|
|
|
|
if(!from_user && address >= PAGE_OFFSET)
|
|
|
|
goto bad_area;
|
|
|
|
|
|
|
|
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:
|
2010-03-01 09:02:23 +01:00
|
|
|
code = SEGV_ACCERR;
|
2005-04-17 00:20:36 +02:00
|
|
|
if(write) {
|
|
|
|
if(!(vma->vm_flags & VM_WRITE))
|
|
|
|
goto bad_area;
|
|
|
|
} else {
|
|
|
|
/* Allow reads even for write-only mappings */
|
|
|
|
if(!(vma->vm_flags & (VM_READ | 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.
|
|
|
|
*/
|
2009-04-10 18:01:23 +02:00
|
|
|
fault = handle_mm_fault(mm, vma, address, write ? FAULT_FLAG_WRITE : 0);
|
2007-07-19 10:47:05 +02:00
|
|
|
if (unlikely(fault & VM_FAULT_ERROR)) {
|
|
|
|
if (fault & VM_FAULT_OOM)
|
|
|
|
goto out_of_memory;
|
|
|
|
else if (fault & VM_FAULT_SIGBUS)
|
|
|
|
goto do_sigbus;
|
|
|
|
BUG();
|
|
|
|
}
|
2010-01-20 12:04:14 +01:00
|
|
|
if (fault & VM_FAULT_MAJOR) {
|
2005-04-17 00:20:36 +02:00
|
|
|
current->maj_flt++;
|
2011-06-27 14:41:57 +02:00
|
|
|
perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1, regs, address);
|
2010-01-20 12:04:14 +01:00
|
|
|
} else {
|
2005-04-17 00:20:36 +02:00
|
|
|
current->min_flt++;
|
2011-06-27 14:41:57 +02:00
|
|
|
perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1, regs, address);
|
2010-01-20 12:04:14 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
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 */
|
2010-03-01 09:02:23 +01:00
|
|
|
if (from_user) {
|
|
|
|
do_fault_siginfo(code, SIGSEGV, regs, text_fault);
|
2005-04-17 00:20:36 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Is this in ex_table? */
|
|
|
|
no_context:
|
|
|
|
g2 = regs->u_regs[UREG_G2];
|
2009-01-06 21:52:41 +01:00
|
|
|
if (!from_user) {
|
|
|
|
fixup = search_extables_range(regs->pc, &g2);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (fixup > 10) { /* Values below are reserved for other things */
|
|
|
|
extern const unsigned __memset_start[];
|
|
|
|
extern const unsigned __memset_end[];
|
|
|
|
extern const unsigned __csum_partial_copy_start[];
|
|
|
|
extern const unsigned __csum_partial_copy_end[];
|
|
|
|
|
|
|
|
#ifdef DEBUG_EXCEPTIONS
|
|
|
|
printk("Exception: PC<%08lx> faddr<%08lx>\n", regs->pc, address);
|
|
|
|
printk("EX_TABLE: insn<%08lx> fixup<%08x> g2<%08lx>\n",
|
|
|
|
regs->pc, fixup, g2);
|
|
|
|
#endif
|
|
|
|
if ((regs->pc >= (unsigned long)__memset_start &&
|
|
|
|
regs->pc < (unsigned long)__memset_end) ||
|
|
|
|
(regs->pc >= (unsigned long)__csum_partial_copy_start &&
|
|
|
|
regs->pc < (unsigned long)__csum_partial_copy_end)) {
|
|
|
|
regs->u_regs[UREG_I4] = address;
|
|
|
|
regs->u_regs[UREG_I5] = regs->pc;
|
|
|
|
}
|
|
|
|
regs->u_regs[UREG_G2] = g2;
|
|
|
|
regs->pc = fixup;
|
|
|
|
regs->npc = regs->pc + 4;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
unhandled_fault (address, tsk, regs);
|
|
|
|
do_exit(SIGKILL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We ran out of memory, or some other thing happened to us that made
|
|
|
|
* us unable to handle the page fault gracefully.
|
|
|
|
*/
|
|
|
|
out_of_memory:
|
|
|
|
up_read(&mm->mmap_sem);
|
2009-08-03 04:17:15 +02:00
|
|
|
if (from_user) {
|
|
|
|
pagefault_out_of_memory();
|
|
|
|
return;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
goto no_context;
|
|
|
|
|
|
|
|
do_sigbus:
|
|
|
|
up_read(&mm->mmap_sem);
|
2010-03-01 09:02:23 +01:00
|
|
|
do_fault_siginfo(BUS_ADRERR, SIGBUS, regs, text_fault);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!from_user)
|
|
|
|
goto no_context;
|
|
|
|
|
|
|
|
vmalloc_fault:
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Synchronize this task's top level page-table
|
|
|
|
* with the 'reference' page table.
|
|
|
|
*/
|
|
|
|
int offset = pgd_index(address);
|
|
|
|
pgd_t *pgd, *pgd_k;
|
|
|
|
pmd_t *pmd, *pmd_k;
|
|
|
|
|
|
|
|
pgd = tsk->active_mm->pgd + offset;
|
|
|
|
pgd_k = init_mm.pgd + offset;
|
|
|
|
|
|
|
|
if (!pgd_present(*pgd)) {
|
|
|
|
if (!pgd_present(*pgd_k))
|
|
|
|
goto bad_area_nosemaphore;
|
|
|
|
pgd_val(*pgd) = pgd_val(*pgd_k);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
pmd = pmd_offset(pgd, address);
|
|
|
|
pmd_k = pmd_offset(pgd_k, address);
|
|
|
|
|
|
|
|
if (pmd_present(*pmd) || !pmd_present(*pmd_k))
|
|
|
|
goto bad_area_nosemaphore;
|
|
|
|
*pmd = *pmd_k;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
asmlinkage void do_sun4c_fault(struct pt_regs *regs, int text_fault, int write,
|
|
|
|
unsigned long address)
|
|
|
|
{
|
|
|
|
extern void sun4c_update_mmu_cache(struct vm_area_struct *,
|
MM: Pass a PTE pointer to update_mmu_cache() rather than the PTE itself
On VIVT ARM, when we have multiple shared mappings of the same file
in the same MM, we need to ensure that we have coherency across all
copies. We do this via make_coherent() by making the pages
uncacheable.
This used to work fine, until we allowed highmem with highpte - we
now have a page table which is mapped as required, and is not available
for modification via update_mmu_cache().
Ralf Beache suggested getting rid of the PTE value passed to
update_mmu_cache():
On MIPS update_mmu_cache() calls __update_tlb() which walks pagetables
to construct a pointer to the pte again. Passing a pte_t * is much
more elegant. Maybe we might even replace the pte argument with the
pte_t?
Ben Herrenschmidt would also like the pte pointer for PowerPC:
Passing the ptep in there is exactly what I want. I want that
-instead- of the PTE value, because I have issue on some ppc cases,
for I$/D$ coherency, where set_pte_at() may decide to mask out the
_PAGE_EXEC.
So, pass in the mapped page table pointer into update_mmu_cache(), and
remove the PTE value, updating all implementations and call sites to
suit.
Includes a fix from Stephen Rothwell:
sparc: fix fallout from update_mmu_cache API change
Signed-off-by: Stephen Rothwell <sfr@canb.auug.org.au>
Acked-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-12-18 17:40:18 +01:00
|
|
|
unsigned long,pte_t *);
|
2005-04-17 00:20:36 +02:00
|
|
|
extern pte_t *sun4c_pte_offset_kernel(pmd_t *,unsigned long);
|
|
|
|
struct task_struct *tsk = current;
|
|
|
|
struct mm_struct *mm = tsk->mm;
|
|
|
|
pgd_t *pgdp;
|
|
|
|
pte_t *ptep;
|
|
|
|
|
|
|
|
if (text_fault) {
|
|
|
|
address = regs->pc;
|
|
|
|
} else if (!write &&
|
|
|
|
!(regs->psr & PSR_PS)) {
|
|
|
|
unsigned int insn, __user *ip;
|
|
|
|
|
|
|
|
ip = (unsigned int __user *)regs->pc;
|
|
|
|
if (!get_user(insn, ip)) {
|
|
|
|
if ((insn & 0xc1680000) == 0xc0680000)
|
|
|
|
write = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!mm) {
|
|
|
|
/* We are oopsing. */
|
|
|
|
do_sparc_fault(regs, text_fault, write, address);
|
|
|
|
BUG(); /* P3 Oops already, you bitch */
|
|
|
|
}
|
|
|
|
|
|
|
|
pgdp = pgd_offset(mm, address);
|
|
|
|
ptep = sun4c_pte_offset_kernel((pmd_t *) pgdp, address);
|
|
|
|
|
|
|
|
if (pgd_val(*pgdp)) {
|
|
|
|
if (write) {
|
|
|
|
if ((pte_val(*ptep) & (_SUN4C_PAGE_WRITE|_SUN4C_PAGE_PRESENT))
|
|
|
|
== (_SUN4C_PAGE_WRITE|_SUN4C_PAGE_PRESENT)) {
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
*ptep = __pte(pte_val(*ptep) | _SUN4C_PAGE_ACCESSED |
|
|
|
|
_SUN4C_PAGE_MODIFIED |
|
|
|
|
_SUN4C_PAGE_VALID |
|
|
|
|
_SUN4C_PAGE_DIRTY);
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
if (sun4c_get_segmap(address) != invalid_segment) {
|
|
|
|
sun4c_put_pte(address, pte_val(*ptep));
|
|
|
|
local_irq_restore(flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
local_irq_restore(flags);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if ((pte_val(*ptep) & (_SUN4C_PAGE_READ|_SUN4C_PAGE_PRESENT))
|
|
|
|
== (_SUN4C_PAGE_READ|_SUN4C_PAGE_PRESENT)) {
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
*ptep = __pte(pte_val(*ptep) | _SUN4C_PAGE_ACCESSED |
|
|
|
|
_SUN4C_PAGE_VALID);
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
if (sun4c_get_segmap(address) != invalid_segment) {
|
|
|
|
sun4c_put_pte(address, pte_val(*ptep));
|
|
|
|
local_irq_restore(flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
local_irq_restore(flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This conditional is 'interesting'. */
|
|
|
|
if (pgd_val(*pgdp) && !(write && !(pte_val(*ptep) & _SUN4C_PAGE_WRITE))
|
|
|
|
&& (pte_val(*ptep) & _SUN4C_PAGE_VALID))
|
|
|
|
/* Note: It is safe to not grab the MMAP semaphore here because
|
|
|
|
* we know that update_mmu_cache() will not sleep for
|
|
|
|
* any reason (at least not in the current implementation)
|
|
|
|
* and therefore there is no danger of another thread getting
|
|
|
|
* on the CPU and doing a shrink_mmap() on this vma.
|
|
|
|
*/
|
|
|
|
sun4c_update_mmu_cache (find_vma(current->mm, address), address,
|
MM: Pass a PTE pointer to update_mmu_cache() rather than the PTE itself
On VIVT ARM, when we have multiple shared mappings of the same file
in the same MM, we need to ensure that we have coherency across all
copies. We do this via make_coherent() by making the pages
uncacheable.
This used to work fine, until we allowed highmem with highpte - we
now have a page table which is mapped as required, and is not available
for modification via update_mmu_cache().
Ralf Beache suggested getting rid of the PTE value passed to
update_mmu_cache():
On MIPS update_mmu_cache() calls __update_tlb() which walks pagetables
to construct a pointer to the pte again. Passing a pte_t * is much
more elegant. Maybe we might even replace the pte argument with the
pte_t?
Ben Herrenschmidt would also like the pte pointer for PowerPC:
Passing the ptep in there is exactly what I want. I want that
-instead- of the PTE value, because I have issue on some ppc cases,
for I$/D$ coherency, where set_pte_at() may decide to mask out the
_PAGE_EXEC.
So, pass in the mapped page table pointer into update_mmu_cache(), and
remove the PTE value, updating all implementations and call sites to
suit.
Includes a fix from Stephen Rothwell:
sparc: fix fallout from update_mmu_cache API change
Signed-off-by: Stephen Rothwell <sfr@canb.auug.org.au>
Acked-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-12-18 17:40:18 +01:00
|
|
|
ptep);
|
2005-04-17 00:20:36 +02:00
|
|
|
else
|
|
|
|
do_sparc_fault(regs, text_fault, write, address);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This always deals with user addresses. */
|
2008-06-05 20:41:51 +02:00
|
|
|
static void force_user_fault(unsigned long address, int write)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct vm_area_struct *vma;
|
|
|
|
struct task_struct *tsk = current;
|
|
|
|
struct mm_struct *mm = tsk->mm;
|
2010-03-01 09:02:23 +01:00
|
|
|
int code;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-03-01 09:02:23 +01:00
|
|
|
code = SEGV_MAPERR;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
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;
|
|
|
|
good_area:
|
2010-03-01 09:02:23 +01:00
|
|
|
code = SEGV_ACCERR;
|
2005-04-17 00:20:36 +02:00
|
|
|
if(write) {
|
|
|
|
if(!(vma->vm_flags & VM_WRITE))
|
|
|
|
goto bad_area;
|
|
|
|
} else {
|
|
|
|
if(!(vma->vm_flags & (VM_READ | VM_EXEC)))
|
|
|
|
goto bad_area;
|
|
|
|
}
|
2009-04-10 18:01:23 +02:00
|
|
|
switch (handle_mm_fault(mm, vma, address, write ? FAULT_FLAG_WRITE : 0)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
case VM_FAULT_SIGBUS:
|
|
|
|
case VM_FAULT_OOM:
|
|
|
|
goto do_sigbus;
|
|
|
|
}
|
|
|
|
up_read(&mm->mmap_sem);
|
|
|
|
return;
|
|
|
|
bad_area:
|
|
|
|
up_read(&mm->mmap_sem);
|
2010-03-01 09:02:23 +01:00
|
|
|
__do_fault_siginfo(code, SIGSEGV, tsk->thread.kregs, address);
|
2005-04-17 00:20:36 +02:00
|
|
|
return;
|
|
|
|
|
|
|
|
do_sigbus:
|
|
|
|
up_read(&mm->mmap_sem);
|
2010-03-01 09:02:23 +01:00
|
|
|
__do_fault_siginfo(BUS_ADRERR, SIGBUS, tsk->thread.kregs, address);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2010-09-24 07:06:47 +02:00
|
|
|
static void check_stack_aligned(unsigned long sp)
|
|
|
|
{
|
|
|
|
if (sp & 0x7UL)
|
|
|
|
force_sig(SIGILL, current);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
void window_overflow_fault(void)
|
|
|
|
{
|
|
|
|
unsigned long sp;
|
|
|
|
|
|
|
|
sp = current_thread_info()->rwbuf_stkptrs[0];
|
|
|
|
if(((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
|
|
|
|
force_user_fault(sp + 0x38, 1);
|
|
|
|
force_user_fault(sp, 1);
|
2010-09-24 07:06:47 +02:00
|
|
|
|
|
|
|
check_stack_aligned(sp);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void window_underflow_fault(unsigned long sp)
|
|
|
|
{
|
|
|
|
if(((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
|
|
|
|
force_user_fault(sp + 0x38, 0);
|
|
|
|
force_user_fault(sp, 0);
|
2010-09-24 07:06:47 +02:00
|
|
|
|
|
|
|
check_stack_aligned(sp);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void window_ret_fault(struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
unsigned long sp;
|
|
|
|
|
|
|
|
sp = regs->u_regs[UREG_FP];
|
|
|
|
if(((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
|
|
|
|
force_user_fault(sp + 0x38, 0);
|
|
|
|
force_user_fault(sp, 0);
|
2010-09-24 07:06:47 +02:00
|
|
|
|
|
|
|
check_stack_aligned(sp);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|