blob: 6f90e7ef66ac98688b0d6f8a0ea67e35e5f23a32 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
4 * for more details.
5 *
6 * Copyright (C) 1995 - 2000 by Ralf Baechle
7 */
8#include <linux/signal.h>
9#include <linux/sched.h>
10#include <linux/interrupt.h>
11#include <linux/kernel.h>
12#include <linux/errno.h>
13#include <linux/string.h>
14#include <linux/types.h>
15#include <linux/ptrace.h>
16#include <linux/mman.h>
17#include <linux/mm.h>
18#include <linux/smp.h>
19#include <linux/smp_lock.h>
20#include <linux/vt_kern.h> /* For unblank_screen() */
21#include <linux/module.h>
22
23#include <asm/branch.h>
24#include <asm/mmu_context.h>
25#include <asm/system.h>
26#include <asm/uaccess.h>
27#include <asm/ptrace.h>
Thiemo Seufer16033d62005-02-19 13:56:04 +000028#include <asm/highmem.h> /* For VMALLOC_END */
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
30/*
31 * This routine handles page faults. It determines the address,
32 * and the problem, and then passes it off to one of the appropriate
33 * routines.
34 */
35asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long write,
36 unsigned long address)
37{
38 struct vm_area_struct * vma = NULL;
39 struct task_struct *tsk = current;
40 struct mm_struct *mm = tsk->mm;
41 const int field = sizeof(unsigned long) * 2;
42 siginfo_t info;
43
44#if 0
45 printk("Cpu%d[%s:%d:%0*lx:%ld:%0*lx]\n", smp_processor_id(),
46 current->comm, current->pid, field, address, write,
47 field, regs->cp0_epc);
48#endif
49
50 info.si_code = SEGV_MAPERR;
51
52 /*
53 * We fault-in kernel-space virtual memory on-demand. The
54 * 'reference' page table is init_mm.pgd.
55 *
56 * NOTE! We MUST NOT take any locks for this case. We may
57 * be in an interrupt or a critical region, and should
58 * only copy the information from the master page table,
59 * nothing more.
60 */
Thiemo Seufer16033d62005-02-19 13:56:04 +000061 if (unlikely(address >= VMALLOC_START && address <= VMALLOC_END))
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 goto vmalloc_fault;
Atsushi Nemoto656be922006-10-26 00:08:31 +090063#ifdef MODULE_START
64 if (unlikely(address >= MODULE_START && address < MODULE_END))
65 goto vmalloc_fault;
66#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
68 /*
69 * If we're in an interrupt or have no user
70 * context, we must not take the fault..
71 */
72 if (in_atomic() || !mm)
73 goto bad_area_nosemaphore;
74
75 down_read(&mm->mmap_sem);
76 vma = find_vma(mm, address);
77 if (!vma)
78 goto bad_area;
79 if (vma->vm_start <= address)
80 goto good_area;
81 if (!(vma->vm_flags & VM_GROWSDOWN))
82 goto bad_area;
83 if (expand_stack(vma, address))
84 goto bad_area;
85/*
86 * Ok, we have a good vm_area for this memory access, so
87 * we can handle it..
88 */
89good_area:
90 info.si_code = SEGV_ACCERR;
91
92 if (write) {
93 if (!(vma->vm_flags & VM_WRITE))
94 goto bad_area;
95 } else {
Ralf Baechle00932ba2006-09-16 01:29:37 +010096 if (!(vma->vm_flags & (VM_READ | VM_WRITE | VM_EXEC)))
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 goto bad_area;
98 }
99
100survive:
101 /*
102 * If for any reason at all we couldn't handle the fault,
103 * make sure we exit gracefully rather than endlessly redo
104 * the fault.
105 */
106 switch (handle_mm_fault(mm, vma, address, write)) {
107 case VM_FAULT_MINOR:
108 tsk->min_flt++;
109 break;
110 case VM_FAULT_MAJOR:
111 tsk->maj_flt++;
112 break;
113 case VM_FAULT_SIGBUS:
114 goto do_sigbus;
115 case VM_FAULT_OOM:
116 goto out_of_memory;
117 default:
118 BUG();
119 }
120
121 up_read(&mm->mmap_sem);
122 return;
123
124/*
125 * Something tried to access memory that isn't in our memory map..
126 * Fix it, but check if it's kernel or user first..
127 */
128bad_area:
129 up_read(&mm->mmap_sem);
130
131bad_area_nosemaphore:
132 /* User mode accesses just cause a SIGSEGV */
133 if (user_mode(regs)) {
134 tsk->thread.cp0_badvaddr = address;
135 tsk->thread.error_code = write;
136#if 0
137 printk("do_page_fault() #2: sending SIGSEGV to %s for "
138 "invalid %s\n%0*lx (epc == %0*lx, ra == %0*lx)\n",
139 tsk->comm,
140 write ? "write access to" : "read access from",
141 field, address,
142 field, (unsigned long) regs->cp0_epc,
143 field, (unsigned long) regs->regs[31]);
144#endif
145 info.si_signo = SIGSEGV;
146 info.si_errno = 0;
147 /* info.si_code has been set above */
Ralf Baechlefe00f942005-03-01 19:22:29 +0000148 info.si_addr = (void __user *) address;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 force_sig_info(SIGSEGV, &info, tsk);
150 return;
151 }
152
153no_context:
154 /* Are we prepared to handle this kernel fault? */
155 if (fixup_exception(regs)) {
156 current->thread.cp0_baduaddr = address;
157 return;
158 }
159
160 /*
161 * Oops. The kernel tried to access some bad page. We'll have to
162 * terminate things with extreme prejudice.
163 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 bust_spinlocks(1);
165
166 printk(KERN_ALERT "CPU %d Unable to handle kernel paging request at "
167 "virtual address %0*lx, epc == %0*lx, ra == %0*lx\n",
168 smp_processor_id(), field, address, field, regs->cp0_epc,
169 field, regs->regs[31]);
170 die("Oops", regs);
171
172/*
173 * We ran out of memory, or some other thing happened to us that made
174 * us unable to handle the page fault gracefully.
175 */
176out_of_memory:
177 up_read(&mm->mmap_sem);
Sukadev Bhattiproluf400e192006-09-29 02:00:07 -0700178 if (is_init(tsk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 yield();
180 down_read(&mm->mmap_sem);
181 goto survive;
182 }
183 printk("VM: killing process %s\n", tsk->comm);
184 if (user_mode(regs))
185 do_exit(SIGKILL);
186 goto no_context;
187
188do_sigbus:
189 up_read(&mm->mmap_sem);
190
191 /* Kernel mode? Handle exceptions or die */
192 if (!user_mode(regs))
193 goto no_context;
Ralf Baechle41c594a2006-04-05 09:45:45 +0100194 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 /*
196 * Send a sigbus, regardless of whether we were in kernel
197 * or user mode.
198 */
Ralf Baechle41c594a2006-04-05 09:45:45 +0100199#if 0
200 printk("do_page_fault() #3: sending SIGBUS to %s for "
201 "invalid %s\n%0*lx (epc == %0*lx, ra == %0*lx)\n",
202 tsk->comm,
203 write ? "write access to" : "read access from",
204 field, address,
205 field, (unsigned long) regs->cp0_epc,
206 field, (unsigned long) regs->regs[31]);
207#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 tsk->thread.cp0_badvaddr = address;
209 info.si_signo = SIGBUS;
210 info.si_errno = 0;
211 info.si_code = BUS_ADRERR;
Ralf Baechlefe00f942005-03-01 19:22:29 +0000212 info.si_addr = (void __user *) address;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 force_sig_info(SIGBUS, &info, tsk);
214
215 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216vmalloc_fault:
217 {
218 /*
219 * Synchronize this task's top level page-table
220 * with the 'reference' page table.
221 *
222 * Do _not_ use "tsk" here. We might be inside
223 * an interrupt in the middle of a task switch..
224 */
225 int offset = __pgd_offset(address);
226 pgd_t *pgd, *pgd_k;
Ralf Baechlec6e8b582005-02-10 12:19:59 +0000227 pud_t *pud, *pud_k;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 pmd_t *pmd, *pmd_k;
229 pte_t *pte_k;
230
231 pgd = (pgd_t *) pgd_current[smp_processor_id()] + offset;
232 pgd_k = init_mm.pgd + offset;
233
234 if (!pgd_present(*pgd_k))
235 goto no_context;
236 set_pgd(pgd, *pgd_k);
237
Ralf Baechlec6e8b582005-02-10 12:19:59 +0000238 pud = pud_offset(pgd, address);
239 pud_k = pud_offset(pgd_k, address);
240 if (!pud_present(*pud_k))
241 goto no_context;
242
243 pmd = pmd_offset(pud, address);
244 pmd_k = pmd_offset(pud_k, address);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 if (!pmd_present(*pmd_k))
246 goto no_context;
247 set_pmd(pmd, *pmd_k);
248
249 pte_k = pte_offset_kernel(pmd_k, address);
250 if (!pte_present(*pte_k))
251 goto no_context;
252 return;
253 }
254}