PageRenderTime 26ms CodeModel.GetById 11ms app.highlight 12ms RepoModel.GetById 1ms app.codeStats 0ms

/arch/arm26/mm/fault.c

https://bitbucket.org/evzijst/gittest
C | 318 lines | 194 code | 44 blank | 80 comment | 26 complexity | a05df4a891bb9f5d60260cace666e10a MD5 | raw file
  1/*
  2 *  linux/arch/arm26/mm/fault.c
  3 *
  4 *  Copyright (C) 1995  Linus Torvalds
  5 *  Modifications for ARM processor (c) 1995-2001 Russell King
  6 *
  7 * This program is free software; you can redistribute it and/or modify
  8 * it under the terms of the GNU General Public License version 2 as
  9 * published by the Free Software Foundation.
 10 */
 11#include <linux/config.h>
 12#include <linux/signal.h>
 13#include <linux/sched.h>
 14#include <linux/kernel.h>
 15#include <linux/errno.h>
 16#include <linux/string.h>
 17#include <linux/types.h>
 18#include <linux/ptrace.h>
 19#include <linux/mman.h>
 20#include <linux/mm.h>
 21#include <linux/interrupt.h>
 22#include <linux/proc_fs.h>
 23#include <linux/init.h>
 24
 25#include <asm/system.h>
 26#include <asm/pgtable.h>
 27#include <asm/uaccess.h> //FIXME this header may be bogusly included
 28
 29#include "fault.h"
 30
 31#define FAULT_CODE_LDRSTRPOST   0x80
 32#define FAULT_CODE_LDRSTRPRE    0x40
 33#define FAULT_CODE_LDRSTRREG    0x20
 34#define FAULT_CODE_LDMSTM       0x10
 35#define FAULT_CODE_LDCSTC       0x08
 36#define FAULT_CODE_PREFETCH     0x04
 37#define FAULT_CODE_WRITE        0x02
 38#define FAULT_CODE_FORCECOW     0x01
 39
 40#define DO_COW(m)               ((m) & (FAULT_CODE_WRITE|FAULT_CODE_FORCECOW))
 41#define READ_FAULT(m)           (!((m) & FAULT_CODE_WRITE))
 42#define DEBUG
 43/*
 44 * This is useful to dump out the page tables associated with
 45 * 'addr' in mm 'mm'.
 46 */
 47void show_pte(struct mm_struct *mm, unsigned long addr)
 48{
 49	pgd_t *pgd;
 50
 51	if (!mm)
 52		mm = &init_mm;
 53
 54	printk(KERN_ALERT "pgd = %p\n", mm->pgd);
 55	pgd = pgd_offset(mm, addr);
 56	printk(KERN_ALERT "[%08lx] *pgd=%08lx", addr, pgd_val(*pgd));
 57
 58	do {
 59		pmd_t *pmd;
 60		pte_t *pte;
 61
 62		pmd = pmd_offset(pgd, addr);
 63
 64		if (pmd_none(*pmd))
 65			break;
 66
 67		if (pmd_bad(*pmd)) {
 68			printk("(bad)");
 69			break;
 70		}
 71
 72		/* We must not map this if we have highmem enabled */
 73		/* FIXME */
 74		pte = pte_offset_map(pmd, addr);
 75		printk(", *pte=%08lx", pte_val(*pte));
 76		pte_unmap(pte);
 77	} while(0);
 78
 79	printk("\n");
 80}
 81
 82/*
 83 * Oops.  The kernel tried to access some page that wasn't present.
 84 */
 85static void
 86__do_kernel_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr,
 87		  struct pt_regs *regs)
 88{
 89	/*
 90         * Are we prepared to handle this kernel fault?
 91         */
 92        if (fixup_exception(regs))
 93                return;
 94
 95	/*
 96	 * No handler, we'll have to terminate things with extreme prejudice.
 97	 */
 98	bust_spinlocks(1);
 99	printk(KERN_ALERT
100		"Unable to handle kernel %s at virtual address %08lx\n",
101		(addr < PAGE_SIZE) ? "NULL pointer dereference" :
102		"paging request", addr);
103
104	show_pte(mm, addr);
105	die("Oops", regs, fsr);
106	bust_spinlocks(0);
107	do_exit(SIGKILL);
108}
109
110/*
111 * Something tried to access memory that isn't in our memory map..
112 * User mode accesses just cause a SIGSEGV
113 */
114static void
115__do_user_fault(struct task_struct *tsk, unsigned long addr,
116		unsigned int fsr, int code, struct pt_regs *regs)
117{
118	struct siginfo si;
119
120#ifdef CONFIG_DEBUG_USER
121	printk("%s: unhandled page fault at 0x%08lx, code 0x%03x\n",
122	       tsk->comm, addr, fsr);
123	show_pte(tsk->mm, addr);
124	show_regs(regs);
125	//dump_backtrace(regs, tsk); // FIXME ARM32 dropped this - why?
126	while(1); //FIXME - hack to stop debug going nutso
127#endif
128
129	tsk->thread.address = addr;
130	tsk->thread.error_code = fsr;
131	tsk->thread.trap_no = 14;
132	si.si_signo = SIGSEGV;
133	si.si_errno = 0;
134	si.si_code = code;
135	si.si_addr = (void *)addr;
136	force_sig_info(SIGSEGV, &si, tsk);
137}
138
139static int
140__do_page_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr,
141		struct task_struct *tsk)
142{
143	struct vm_area_struct *vma;
144	int fault, mask;
145
146	vma = find_vma(mm, addr);
147	fault = -2; /* bad map area */
148	if (!vma)
149		goto out;
150	if (vma->vm_start > addr)
151		goto check_stack;
152
153	/*
154	 * Ok, we have a good vm_area for this
155	 * memory access, so we can handle it.
156	 */
157good_area:
158	if (READ_FAULT(fsr)) /* read? */
159		mask = VM_READ|VM_EXEC;
160	else
161		mask = VM_WRITE;
162
163	fault = -1; /* bad access type */
164	if (!(vma->vm_flags & mask))
165		goto out;
166
167	/*
168	 * If for any reason at all we couldn't handle
169	 * the fault, make sure we exit gracefully rather
170	 * than endlessly redo the fault.
171	 */
172survive:
173	fault = handle_mm_fault(mm, vma, addr & PAGE_MASK, DO_COW(fsr));
174
175	/*
176	 * Handle the "normal" cases first - successful and sigbus
177	 */
178	switch (fault) {
179	case 2:
180		tsk->maj_flt++;
181		return fault;
182	case 1:
183		tsk->min_flt++;
184	case 0:
185		return fault;
186	}
187
188	fault = -3; /* out of memory */
189	if (tsk->pid != 1)
190		goto out;
191
192	/*
193	 * If we are out of memory for pid1,
194	 * sleep for a while and retry
195	 */
196	yield();
197	goto survive;
198
199check_stack:
200	if (vma->vm_flags & VM_GROWSDOWN && !expand_stack(vma, addr))
201		goto good_area;
202out:
203	return fault;
204}
205
206int do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
207{
208	struct task_struct *tsk;
209	struct mm_struct *mm;
210	int fault;
211
212	tsk = current;
213	mm  = tsk->mm;
214
215	/*
216	 * If we're in an interrupt or have no user
217	 * context, we must not take the fault..
218	 */
219	if (in_interrupt() || !mm)
220		goto no_context;
221
222	down_read(&mm->mmap_sem);
223	fault = __do_page_fault(mm, addr, fsr, tsk);
224	up_read(&mm->mmap_sem);
225
226	/*
227	 * Handle the "normal" case first
228	 */
229	if (fault > 0)
230		return 0;
231
232	/*
233	 * We had some memory, but were unable to
234	 * successfully fix up this page fault.
235	 */
236	if (fault == 0){
237		goto do_sigbus;
238	}
239
240	/*
241	 * If we are in kernel mode at this point, we
242	 * have no context to handle this fault with.
243         * FIXME - is this test right?
244	 */
245	if (!user_mode(regs)){
246		goto no_context;
247	}
248
249	if (fault == -3) {
250		/*
251		 * We ran out of memory, or some other thing happened to
252		 * us that made us unable to handle the page fault gracefully.
253		 */
254		printk("VM: killing process %s\n", tsk->comm);
255		do_exit(SIGKILL);
256	}
257	else{
258		__do_user_fault(tsk, addr, fsr, fault == -1 ? SEGV_ACCERR : SEGV_MAPERR, regs);
259	}
260
261	return 0;
262
263
264/*
265 * We ran out of memory, or some other thing happened to us that made
266 * us unable to handle the page fault gracefully.
267 */
268do_sigbus:
269	/*
270	 * Send a sigbus, regardless of whether we were in kernel
271	 * or user mode.
272	 */
273	tsk->thread.address = addr;  //FIXME - need other bits setting?
274	tsk->thread.error_code = fsr;
275	tsk->thread.trap_no = 14;
276	force_sig(SIGBUS, tsk);
277#ifdef CONFIG_DEBUG_USER
278	printk(KERN_DEBUG "%s: sigbus at 0x%08lx, pc=0x%08lx\n",
279		current->comm, addr, instruction_pointer(regs));
280#endif
281
282	/* Kernel mode? Handle exceptions or die */
283	if (user_mode(regs))
284		return 0;
285
286no_context:
287	__do_kernel_fault(mm, addr, fsr, regs);
288	return 0;
289}
290
291/*
292 * Handle a data abort.  Note that we have to handle a range of addresses
293 * on ARM2/3 for ldm.  If both pages are zero-mapped, then we have to force
294 * a copy-on-write.  However, on the second page, we always force COW.
295 */
296asmlinkage void
297do_DataAbort(unsigned long min_addr, unsigned long max_addr, int mode, struct pt_regs *regs)
298{
299        do_page_fault(min_addr, mode, regs);
300
301        if ((min_addr ^ max_addr) >> PAGE_SHIFT){
302               do_page_fault(max_addr, mode | FAULT_CODE_FORCECOW, regs);
303	}
304}
305
306asmlinkage int
307do_PrefetchAbort(unsigned long addr, struct pt_regs *regs)
308{
309#if 0
310        if (the memc mapping for this page exists) {
311                printk ("Page in, but got abort (undefined instruction?)\n");
312                return 0;
313        }
314#endif
315        do_page_fault(addr, FAULT_CODE_PREFETCH, regs);
316        return 1;
317}
318