]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Copyright (C) 2000, 2001 Jeff Dike (jdike@karaya.com) | |
3 | * Licensed under the GPL | |
4 | */ | |
5 | ||
6 | #include "linux/kernel.h" | |
7 | #include "asm/errno.h" | |
8 | #include "linux/sched.h" | |
9 | #include "linux/mm.h" | |
10 | #include "linux/spinlock.h" | |
11 | #include "linux/config.h" | |
12 | #include "linux/init.h" | |
13 | #include "linux/ptrace.h" | |
14 | #include "asm/semaphore.h" | |
15 | #include "asm/pgtable.h" | |
16 | #include "asm/pgalloc.h" | |
17 | #include "asm/tlbflush.h" | |
18 | #include "asm/a.out.h" | |
19 | #include "asm/current.h" | |
20 | #include "asm/irq.h" | |
546fe1cb | 21 | #include "sysdep/sigcontext.h" |
1da177e4 LT |
22 | #include "user_util.h" |
23 | #include "kern_util.h" | |
24 | #include "kern.h" | |
25 | #include "chan_kern.h" | |
26 | #include "mconsole_kern.h" | |
1da177e4 LT |
27 | #include "mem.h" |
28 | #include "mem_kern.h" | |
be662a18 PBG |
29 | #ifdef CONFIG_MODE_SKAS |
30 | #include "skas.h" | |
31 | #endif | |
1da177e4 | 32 | |
3b52166c | 33 | /* Note this is constrained to return 0, -EFAULT, -EACCESS, -ENOMEM by segv(). */ |
1da177e4 LT |
34 | int handle_page_fault(unsigned long address, unsigned long ip, |
35 | int is_write, int is_user, int *code_out) | |
36 | { | |
37 | struct mm_struct *mm = current->mm; | |
38 | struct vm_area_struct *vma; | |
39 | pgd_t *pgd; | |
40 | pud_t *pud; | |
41 | pmd_t *pmd; | |
42 | pte_t *pte; | |
1da177e4 LT |
43 | int err = -EFAULT; |
44 | ||
45 | *code_out = SEGV_MAPERR; | |
fea03cb4 PBG |
46 | |
47 | /* If the fault was during atomic operation, don't take the fault, just | |
48 | * fail. */ | |
49 | if (in_atomic()) | |
50 | goto out_nosemaphore; | |
51 | ||
1da177e4 LT |
52 | down_read(&mm->mmap_sem); |
53 | vma = find_vma(mm, address); | |
54 | if(!vma) | |
55 | goto out; | |
56 | else if(vma->vm_start <= address) | |
57 | goto good_area; | |
58 | else if(!(vma->vm_flags & VM_GROWSDOWN)) | |
59 | goto out; | |
2d58cc9a | 60 | else if(is_user && !ARCH_IS_STACKGROW(address)) |
1da177e4 LT |
61 | goto out; |
62 | else if(expand_stack(vma, address)) | |
63 | goto out; | |
64 | ||
3b52166c | 65 | good_area: |
1da177e4 LT |
66 | *code_out = SEGV_ACCERR; |
67 | if(is_write && !(vma->vm_flags & VM_WRITE)) | |
68 | goto out; | |
13479d52 | 69 | |
d129f312 PBG |
70 | /* Don't require VM_READ|VM_EXEC for write faults! */ |
71 | if(!is_write && !(vma->vm_flags & (VM_READ | VM_EXEC))) | |
13479d52 JD |
72 | goto out; |
73 | ||
1da177e4 | 74 | do { |
3b52166c | 75 | survive: |
1da177e4 LT |
76 | switch (handle_mm_fault(mm, vma, address, is_write)){ |
77 | case VM_FAULT_MINOR: | |
78 | current->min_flt++; | |
79 | break; | |
80 | case VM_FAULT_MAJOR: | |
81 | current->maj_flt++; | |
82 | break; | |
83 | case VM_FAULT_SIGBUS: | |
84 | err = -EACCES; | |
85 | goto out; | |
86 | case VM_FAULT_OOM: | |
87 | err = -ENOMEM; | |
88 | goto out_of_memory; | |
89 | default: | |
90 | BUG(); | |
91 | } | |
3b52166c PBG |
92 | pgd = pgd_offset(mm, address); |
93 | pud = pud_offset(pgd, address); | |
94 | pmd = pmd_offset(pud, address); | |
95 | pte = pte_offset_kernel(pmd, address); | |
1da177e4 LT |
96 | } while(!pte_present(*pte)); |
97 | err = 0; | |
16b03678 | 98 | WARN_ON(!pte_young(*pte) || (is_write && !pte_dirty(*pte))); |
3b52166c PBG |
99 | flush_tlb_page(vma, address); |
100 | out: | |
1da177e4 | 101 | up_read(&mm->mmap_sem); |
fea03cb4 | 102 | out_nosemaphore: |
1da177e4 LT |
103 | return(err); |
104 | ||
105 | /* | |
106 | * We ran out of memory, or some other thing happened to us that made | |
107 | * us unable to handle the page fault gracefully. | |
108 | */ | |
109 | out_of_memory: | |
110 | if (current->pid == 1) { | |
111 | up_read(&mm->mmap_sem); | |
112 | yield(); | |
113 | down_read(&mm->mmap_sem); | |
114 | goto survive; | |
115 | } | |
116 | goto out; | |
117 | } | |
118 | ||
c578455a BS |
119 | /* |
120 | * We give a *copy* of the faultinfo in the regs to segv. | |
121 | * This must be done, since nesting SEGVs could overwrite | |
122 | * the info in the regs. A pointer to the info then would | |
123 | * give us bad data! | |
124 | */ | |
125 | unsigned long segv(struct faultinfo fi, unsigned long ip, int is_user, void *sc) | |
1da177e4 LT |
126 | { |
127 | struct siginfo si; | |
128 | void *catcher; | |
129 | int err; | |
c578455a BS |
130 | int is_write = FAULT_WRITE(fi); |
131 | unsigned long address = FAULT_ADDRESS(fi); | |
1da177e4 LT |
132 | |
133 | if(!is_user && (address >= start_vm) && (address < end_vm)){ | |
134 | flush_tlb_kernel_vm(); | |
135 | return(0); | |
136 | } | |
1da177e4 LT |
137 | else if(current->mm == NULL) |
138 | panic("Segfault with no mm"); | |
546fe1cb | 139 | |
be662a18 | 140 | if (SEGV_IS_FIXABLE(&fi) || SEGV_MAYBE_FIXABLE(&fi)) |
546fe1cb PBG |
141 | err = handle_page_fault(address, ip, is_write, is_user, &si.si_code); |
142 | else { | |
143 | err = -EFAULT; | |
144 | /* A thread accessed NULL, we get a fault, but CR2 is invalid. | |
145 | * This code is used in __do_copy_from_user() of TT mode. */ | |
146 | address = 0; | |
147 | } | |
1da177e4 LT |
148 | |
149 | catcher = current->thread.fault_catcher; | |
150 | if(!err) | |
151 | return(0); | |
152 | else if(catcher != NULL){ | |
153 | current->thread.fault_addr = (void *) address; | |
154 | do_longjmp(catcher, 1); | |
155 | } | |
156 | else if(current->thread.fault_addr != NULL) | |
157 | panic("fault_addr set but no fault catcher"); | |
c578455a | 158 | else if(!is_user && arch_fixup(ip, sc)) |
1da177e4 LT |
159 | return(0); |
160 | ||
161 | if(!is_user) | |
162 | panic("Kernel mode fault at addr 0x%lx, ip 0x%lx", | |
163 | address, ip); | |
164 | ||
3b52166c | 165 | if (err == -EACCES) { |
1da177e4 LT |
166 | si.si_signo = SIGBUS; |
167 | si.si_errno = 0; | |
168 | si.si_code = BUS_ADRERR; | |
169 | si.si_addr = (void *)address; | |
c578455a | 170 | current->thread.arch.faultinfo = fi; |
1da177e4 | 171 | force_sig_info(SIGBUS, &si, current); |
3b52166c | 172 | } else if (err == -ENOMEM) { |
1da177e4 LT |
173 | printk("VM: killing process %s\n", current->comm); |
174 | do_exit(SIGKILL); | |
3b52166c PBG |
175 | } else { |
176 | BUG_ON(err != -EFAULT); | |
1da177e4 LT |
177 | si.si_signo = SIGSEGV; |
178 | si.si_addr = (void *) address; | |
c578455a | 179 | current->thread.arch.faultinfo = fi; |
1da177e4 LT |
180 | force_sig_info(SIGSEGV, &si, current); |
181 | } | |
182 | return(0); | |
183 | } | |
184 | ||
c578455a | 185 | void bad_segv(struct faultinfo fi, unsigned long ip) |
1da177e4 LT |
186 | { |
187 | struct siginfo si; | |
188 | ||
189 | si.si_signo = SIGSEGV; | |
190 | si.si_code = SEGV_ACCERR; | |
c578455a BS |
191 | si.si_addr = (void *) FAULT_ADDRESS(fi); |
192 | current->thread.arch.faultinfo = fi; | |
1da177e4 LT |
193 | force_sig_info(SIGSEGV, &si, current); |
194 | } | |
195 | ||
196 | void relay_signal(int sig, union uml_pt_regs *regs) | |
197 | { | |
198 | if(arch_handle_signal(sig, regs)) return; | |
199 | if(!UPT_IS_USER(regs)) | |
200 | panic("Kernel mode signal %d", sig); | |
c578455a | 201 | current->thread.arch.faultinfo = *UPT_FAULTINFO(regs); |
1da177e4 LT |
202 | force_sig(sig, current); |
203 | } | |
204 | ||
205 | void bus_handler(int sig, union uml_pt_regs *regs) | |
206 | { | |
207 | if(current->thread.fault_catcher != NULL) | |
208 | do_longjmp(current->thread.fault_catcher, 1); | |
209 | else relay_signal(sig, regs); | |
210 | } | |
211 | ||
212 | void winch(int sig, union uml_pt_regs *regs) | |
213 | { | |
214 | do_IRQ(WINCH_IRQ, regs); | |
215 | } | |
216 | ||
217 | void trap_init(void) | |
218 | { | |
219 | } |