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" | |
21 | #include "user_util.h" | |
22 | #include "kern_util.h" | |
23 | #include "kern.h" | |
24 | #include "chan_kern.h" | |
25 | #include "mconsole_kern.h" | |
26 | #include "2_5compat.h" | |
27 | #include "mem.h" | |
28 | #include "mem_kern.h" | |
29 | ||
30 | int handle_page_fault(unsigned long address, unsigned long ip, | |
31 | int is_write, int is_user, int *code_out) | |
32 | { | |
33 | struct mm_struct *mm = current->mm; | |
34 | struct vm_area_struct *vma; | |
35 | pgd_t *pgd; | |
36 | pud_t *pud; | |
37 | pmd_t *pmd; | |
38 | pte_t *pte; | |
39 | unsigned long page; | |
40 | int err = -EFAULT; | |
41 | ||
42 | *code_out = SEGV_MAPERR; | |
43 | down_read(&mm->mmap_sem); | |
44 | vma = find_vma(mm, address); | |
45 | if(!vma) | |
46 | goto out; | |
47 | else if(vma->vm_start <= address) | |
48 | goto good_area; | |
49 | else if(!(vma->vm_flags & VM_GROWSDOWN)) | |
50 | goto out; | |
51 | else if(!ARCH_IS_STACKGROW(address)) | |
52 | goto out; | |
53 | else if(expand_stack(vma, address)) | |
54 | goto out; | |
55 | ||
56 | good_area: | |
57 | *code_out = SEGV_ACCERR; | |
58 | if(is_write && !(vma->vm_flags & VM_WRITE)) | |
59 | goto out; | |
60 | page = address & PAGE_MASK; | |
61 | pgd = pgd_offset(mm, page); | |
62 | pud = pud_offset(pgd, page); | |
63 | pmd = pmd_offset(pud, page); | |
64 | do { | |
65 | survive: | |
66 | switch (handle_mm_fault(mm, vma, address, is_write)){ | |
67 | case VM_FAULT_MINOR: | |
68 | current->min_flt++; | |
69 | break; | |
70 | case VM_FAULT_MAJOR: | |
71 | current->maj_flt++; | |
72 | break; | |
73 | case VM_FAULT_SIGBUS: | |
74 | err = -EACCES; | |
75 | goto out; | |
76 | case VM_FAULT_OOM: | |
77 | err = -ENOMEM; | |
78 | goto out_of_memory; | |
79 | default: | |
80 | BUG(); | |
81 | } | |
82 | pgd = pgd_offset(mm, page); | |
83 | pud = pud_offset(pgd, page); | |
84 | pmd = pmd_offset(pud, page); | |
85 | pte = pte_offset_kernel(pmd, page); | |
86 | } while(!pte_present(*pte)); | |
87 | err = 0; | |
88 | *pte = pte_mkyoung(*pte); | |
89 | if(pte_write(*pte)) *pte = pte_mkdirty(*pte); | |
90 | flush_tlb_page(vma, page); | |
91 | out: | |
92 | up_read(&mm->mmap_sem); | |
93 | return(err); | |
94 | ||
95 | /* | |
96 | * We ran out of memory, or some other thing happened to us that made | |
97 | * us unable to handle the page fault gracefully. | |
98 | */ | |
99 | out_of_memory: | |
100 | if (current->pid == 1) { | |
101 | up_read(&mm->mmap_sem); | |
102 | yield(); | |
103 | down_read(&mm->mmap_sem); | |
104 | goto survive; | |
105 | } | |
106 | goto out; | |
107 | } | |
108 | ||
109 | LIST_HEAD(physmem_remappers); | |
110 | ||
111 | void register_remapper(struct remapper *info) | |
112 | { | |
113 | list_add(&info->list, &physmem_remappers); | |
114 | } | |
115 | ||
116 | static int check_remapped_addr(unsigned long address, int is_write) | |
117 | { | |
118 | struct remapper *remapper; | |
119 | struct list_head *ele; | |
120 | __u64 offset; | |
121 | int fd; | |
122 | ||
123 | fd = phys_mapping(__pa(address), &offset); | |
124 | if(fd == -1) | |
125 | return(0); | |
126 | ||
127 | list_for_each(ele, &physmem_remappers){ | |
128 | remapper = list_entry(ele, struct remapper, list); | |
129 | if((*remapper->proc)(fd, address, is_write, offset)) | |
130 | return(1); | |
131 | } | |
132 | ||
133 | return(0); | |
134 | } | |
135 | ||
c578455a BS |
136 | /* |
137 | * We give a *copy* of the faultinfo in the regs to segv. | |
138 | * This must be done, since nesting SEGVs could overwrite | |
139 | * the info in the regs. A pointer to the info then would | |
140 | * give us bad data! | |
141 | */ | |
142 | unsigned long segv(struct faultinfo fi, unsigned long ip, int is_user, void *sc) | |
1da177e4 LT |
143 | { |
144 | struct siginfo si; | |
145 | void *catcher; | |
146 | int err; | |
c578455a BS |
147 | int is_write = FAULT_WRITE(fi); |
148 | unsigned long address = FAULT_ADDRESS(fi); | |
1da177e4 LT |
149 | |
150 | if(!is_user && (address >= start_vm) && (address < end_vm)){ | |
151 | flush_tlb_kernel_vm(); | |
152 | return(0); | |
153 | } | |
154 | else if(check_remapped_addr(address & PAGE_MASK, is_write)) | |
155 | return(0); | |
156 | else if(current->mm == NULL) | |
157 | panic("Segfault with no mm"); | |
158 | err = handle_page_fault(address, ip, is_write, is_user, &si.si_code); | |
159 | ||
160 | catcher = current->thread.fault_catcher; | |
161 | if(!err) | |
162 | return(0); | |
163 | else if(catcher != NULL){ | |
164 | current->thread.fault_addr = (void *) address; | |
165 | do_longjmp(catcher, 1); | |
166 | } | |
167 | else if(current->thread.fault_addr != NULL) | |
168 | panic("fault_addr set but no fault catcher"); | |
c578455a | 169 | else if(!is_user && arch_fixup(ip, sc)) |
1da177e4 LT |
170 | return(0); |
171 | ||
172 | if(!is_user) | |
173 | panic("Kernel mode fault at addr 0x%lx, ip 0x%lx", | |
174 | address, ip); | |
175 | ||
176 | if(err == -EACCES){ | |
177 | si.si_signo = SIGBUS; | |
178 | si.si_errno = 0; | |
179 | si.si_code = BUS_ADRERR; | |
180 | si.si_addr = (void *)address; | |
c578455a | 181 | current->thread.arch.faultinfo = fi; |
1da177e4 LT |
182 | force_sig_info(SIGBUS, &si, current); |
183 | } | |
184 | else if(err == -ENOMEM){ | |
185 | printk("VM: killing process %s\n", current->comm); | |
186 | do_exit(SIGKILL); | |
187 | } | |
188 | else { | |
189 | si.si_signo = SIGSEGV; | |
190 | si.si_addr = (void *) address; | |
c578455a | 191 | current->thread.arch.faultinfo = fi; |
1da177e4 LT |
192 | force_sig_info(SIGSEGV, &si, current); |
193 | } | |
194 | return(0); | |
195 | } | |
196 | ||
c578455a | 197 | void bad_segv(struct faultinfo fi, unsigned long ip) |
1da177e4 LT |
198 | { |
199 | struct siginfo si; | |
200 | ||
201 | si.si_signo = SIGSEGV; | |
202 | si.si_code = SEGV_ACCERR; | |
c578455a BS |
203 | si.si_addr = (void *) FAULT_ADDRESS(fi); |
204 | current->thread.arch.faultinfo = fi; | |
1da177e4 LT |
205 | force_sig_info(SIGSEGV, &si, current); |
206 | } | |
207 | ||
208 | void relay_signal(int sig, union uml_pt_regs *regs) | |
209 | { | |
210 | if(arch_handle_signal(sig, regs)) return; | |
211 | if(!UPT_IS_USER(regs)) | |
212 | panic("Kernel mode signal %d", sig); | |
c578455a | 213 | current->thread.arch.faultinfo = *UPT_FAULTINFO(regs); |
1da177e4 LT |
214 | force_sig(sig, current); |
215 | } | |
216 | ||
217 | void bus_handler(int sig, union uml_pt_regs *regs) | |
218 | { | |
219 | if(current->thread.fault_catcher != NULL) | |
220 | do_longjmp(current->thread.fault_catcher, 1); | |
221 | else relay_signal(sig, regs); | |
222 | } | |
223 | ||
224 | void winch(int sig, union uml_pt_regs *regs) | |
225 | { | |
226 | do_IRQ(WINCH_IRQ, regs); | |
227 | } | |
228 | ||
229 | void trap_init(void) | |
230 | { | |
231 | } | |
232 | ||
233 | DEFINE_SPINLOCK(trap_lock); | |
234 | ||
235 | static int trap_index = 0; | |
236 | ||
237 | int next_trap_index(int limit) | |
238 | { | |
239 | int ret; | |
240 | ||
241 | spin_lock(&trap_lock); | |
242 | ret = trap_index; | |
243 | if(++trap_index == limit) | |
244 | trap_index = 0; | |
245 | spin_unlock(&trap_lock); | |
246 | return(ret); | |
247 | } | |
248 | ||
249 | /* | |
250 | * Overrides for Emacs so that we follow Linus's tabbing style. | |
251 | * Emacs will notice this stuff at the end of the file and automatically | |
252 | * adjust the settings for this buffer only. This must remain at the end | |
253 | * of the file. | |
254 | * --------------------------------------------------------------------------- | |
255 | * Local variables: | |
256 | * c-file-style: "linux" | |
257 | * End: | |
258 | */ |