1 // TODO VM_EXEC flag work-around, cache aliasing
3 * arch/xtensa/mm/fault.c
5 * This file is subject to the terms and conditions of the GNU General Public
6 * License. See the file "COPYING" in the main directory of this archive
9 * Copyright (C) 2001 - 2010 Tensilica Inc.
11 * Chris Zankel <chris@zankel.net>
12 * Joe Taylor <joe@tensilica.com, joetylr@yahoo.com>
16 #include <linux/module.h>
17 #include <linux/hardirq.h>
18 #include <linux/perf_event.h>
19 #include <linux/uaccess.h>
20 #include <asm/mmu_context.h>
21 #include <asm/cacheflush.h>
22 #include <asm/hardirq.h>
23 #include <asm/pgalloc.h>
25 DEFINE_PER_CPU(unsigned long, asid_cache
) = ASID_USER_FIRST
;
26 void bad_page_fault(struct pt_regs
*, unsigned long, int);
28 #undef DEBUG_PAGE_FAULT
31 * This routine handles page faults. It determines the address,
32 * and the problem, and then passes it off to one of the appropriate
35 * Note: does not handle Miss and MultiHit.
38 void do_page_fault(struct pt_regs
*regs
)
40 struct vm_area_struct
* vma
;
41 struct mm_struct
*mm
= current
->mm
;
42 unsigned int exccause
= regs
->exccause
;
43 unsigned int address
= regs
->excvaddr
;
46 int is_write
, is_exec
;
48 unsigned int flags
= FAULT_FLAG_ALLOW_RETRY
| FAULT_FLAG_KILLABLE
;
50 info
.si_code
= SEGV_MAPERR
;
52 /* We fault-in kernel-space virtual memory on-demand. The
53 * 'reference' page table is init_mm.pgd.
55 if (address
>= TASK_SIZE
&& !user_mode(regs
))
58 /* If we're in an interrupt or have no user
59 * context, we must not take the fault..
61 if (faulthandler_disabled() || !mm
) {
62 bad_page_fault(regs
, address
, SIGSEGV
);
66 is_write
= (exccause
== EXCCAUSE_STORE_CACHE_ATTRIBUTE
) ? 1 : 0;
67 is_exec
= (exccause
== EXCCAUSE_ITLB_PRIVILEGE
||
68 exccause
== EXCCAUSE_ITLB_MISS
||
69 exccause
== EXCCAUSE_FETCH_CACHE_ATTRIBUTE
) ? 1 : 0;
71 #ifdef DEBUG_PAGE_FAULT
72 printk("[%s:%d:%08x:%d:%08x:%s%s]\n", current
->comm
, current
->pid
,
73 address
, exccause
, regs
->pc
, is_write
? "w":"", is_exec
? "x":"");
77 flags
|= FAULT_FLAG_USER
;
79 down_read(&mm
->mmap_sem
);
80 vma
= find_vma(mm
, address
);
84 if (vma
->vm_start
<= address
)
86 if (!(vma
->vm_flags
& VM_GROWSDOWN
))
88 if (expand_stack(vma
, address
))
91 /* Ok, we have a good vm_area for this memory access, so
96 info
.si_code
= SEGV_ACCERR
;
99 if (!(vma
->vm_flags
& VM_WRITE
))
101 flags
|= FAULT_FLAG_WRITE
;
102 } else if (is_exec
) {
103 if (!(vma
->vm_flags
& VM_EXEC
))
105 } else /* Allow read even from write-only pages. */
106 if (!(vma
->vm_flags
& (VM_READ
| VM_WRITE
)))
109 /* If for any reason at all we couldn't handle the fault,
110 * make sure we exit gracefully rather than endlessly redo
113 fault
= handle_mm_fault(mm
, vma
, address
, flags
);
115 if ((fault
& VM_FAULT_RETRY
) && fatal_signal_pending(current
))
118 if (unlikely(fault
& VM_FAULT_ERROR
)) {
119 if (fault
& VM_FAULT_OOM
)
121 else if (fault
& VM_FAULT_SIGSEGV
)
123 else if (fault
& VM_FAULT_SIGBUS
)
127 if (flags
& FAULT_FLAG_ALLOW_RETRY
) {
128 if (fault
& VM_FAULT_MAJOR
)
132 if (fault
& VM_FAULT_RETRY
) {
133 flags
&= ~FAULT_FLAG_ALLOW_RETRY
;
134 flags
|= FAULT_FLAG_TRIED
;
136 /* No need to up_read(&mm->mmap_sem) as we would
137 * have already released it in __lock_page_or_retry
145 up_read(&mm
->mmap_sem
);
146 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS
, 1, regs
, address
);
147 if (flags
& VM_FAULT_MAJOR
)
148 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ
, 1, regs
, address
);
149 else if (flags
& VM_FAULT_MINOR
)
150 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN
, 1, regs
, address
);
154 /* Something tried to access memory that isn't in our memory map..
155 * Fix it, but check if it's kernel or user first..
158 up_read(&mm
->mmap_sem
);
159 if (user_mode(regs
)) {
160 current
->thread
.bad_vaddr
= address
;
161 current
->thread
.error_code
= is_write
;
162 info
.si_signo
= SIGSEGV
;
164 /* info.si_code has been set above */
165 info
.si_addr
= (void *) address
;
166 force_sig_info(SIGSEGV
, &info
, current
);
169 bad_page_fault(regs
, address
, SIGSEGV
);
173 /* We ran out of memory, or some other thing happened to us that made
174 * us unable to handle the page fault gracefully.
177 up_read(&mm
->mmap_sem
);
178 if (!user_mode(regs
))
179 bad_page_fault(regs
, address
, SIGKILL
);
181 pagefault_out_of_memory();
185 up_read(&mm
->mmap_sem
);
187 /* Send a sigbus, regardless of whether we were in kernel
190 current
->thread
.bad_vaddr
= address
;
191 info
.si_code
= SIGBUS
;
193 info
.si_code
= BUS_ADRERR
;
194 info
.si_addr
= (void *) address
;
195 force_sig_info(SIGBUS
, &info
, current
);
197 /* Kernel mode? Handle exceptions or die */
198 if (!user_mode(regs
))
199 bad_page_fault(regs
, address
, SIGBUS
);
204 /* Synchronize this task's top level page-table
205 * with the 'reference' page table.
207 struct mm_struct
*act_mm
= current
->active_mm
;
208 int index
= pgd_index(address
);
216 pgd
= act_mm
->pgd
+ index
;
217 pgd_k
= init_mm
.pgd
+ index
;
219 if (!pgd_present(*pgd_k
))
222 pgd_val(*pgd
) = pgd_val(*pgd_k
);
224 pmd
= pmd_offset(pgd
, address
);
225 pmd_k
= pmd_offset(pgd_k
, address
);
226 if (!pmd_present(*pmd
) || !pmd_present(*pmd_k
))
229 pmd_val(*pmd
) = pmd_val(*pmd_k
);
230 pte_k
= pte_offset_kernel(pmd_k
, address
);
232 if (!pte_present(*pte_k
))
237 bad_page_fault(regs
, address
, SIGKILL
);
243 bad_page_fault(struct pt_regs
*regs
, unsigned long address
, int sig
)
245 extern void die(const char*, struct pt_regs
*, long);
246 const struct exception_table_entry
*entry
;
248 /* Are we prepared to handle this kernel fault? */
249 if ((entry
= search_exception_tables(regs
->pc
)) != NULL
) {
250 #ifdef DEBUG_PAGE_FAULT
251 printk(KERN_DEBUG
"%s: Exception at pc=%#010lx (%lx)\n",
252 current
->comm
, regs
->pc
, entry
->fixup
);
254 current
->thread
.bad_uaddr
= address
;
255 regs
->pc
= entry
->fixup
;
259 /* Oops. The kernel tried to access some bad page. We'll have to
260 * terminate things with extreme prejudice.
262 printk(KERN_ALERT
"Unable to handle kernel paging request at virtual "
263 "address %08lx\n pc = %08lx, ra = %08lx\n",
264 address
, regs
->pc
, regs
->areg
[0]);
265 die("Oops", regs
, sig
);