xref: /openbmc/linux/arch/arc/mm/fault.c (revision 6774def6)
1 /* Page Fault Handling for ARC (TLB Miss / ProtV)
2  *
3  * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation.
8  */
9 
10 #include <linux/signal.h>
11 #include <linux/interrupt.h>
12 #include <linux/sched.h>
13 #include <linux/errno.h>
14 #include <linux/ptrace.h>
15 #include <linux/uaccess.h>
16 #include <linux/kdebug.h>
17 #include <asm/pgalloc.h>
18 #include <asm/mmu.h>
19 
20 static int handle_vmalloc_fault(unsigned long address)
21 {
22 	/*
23 	 * Synchronize this task's top level page-table
24 	 * with the 'reference' page table.
25 	 */
26 	pgd_t *pgd, *pgd_k;
27 	pud_t *pud, *pud_k;
28 	pmd_t *pmd, *pmd_k;
29 
30 	pgd = pgd_offset_fast(current->active_mm, address);
31 	pgd_k = pgd_offset_k(address);
32 
33 	if (!pgd_present(*pgd_k))
34 		goto bad_area;
35 
36 	pud = pud_offset(pgd, address);
37 	pud_k = pud_offset(pgd_k, address);
38 	if (!pud_present(*pud_k))
39 		goto bad_area;
40 
41 	pmd = pmd_offset(pud, address);
42 	pmd_k = pmd_offset(pud_k, address);
43 	if (!pmd_present(*pmd_k))
44 		goto bad_area;
45 
46 	set_pmd(pmd, *pmd_k);
47 
48 	/* XXX: create the TLB entry here */
49 	return 0;
50 
51 bad_area:
52 	return 1;
53 }
54 
55 void do_page_fault(unsigned long address, struct pt_regs *regs)
56 {
57 	struct vm_area_struct *vma = NULL;
58 	struct task_struct *tsk = current;
59 	struct mm_struct *mm = tsk->mm;
60 	siginfo_t info;
61 	int fault, ret;
62 	int write = regs->ecr_cause & ECR_C_PROTV_STORE;  /* ST/EX */
63 	unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
64 
65 	/*
66 	 * We fault-in kernel-space virtual memory on-demand. The
67 	 * 'reference' page table is init_mm.pgd.
68 	 *
69 	 * NOTE! We MUST NOT take any locks for this case. We may
70 	 * be in an interrupt or a critical region, and should
71 	 * only copy the information from the master page table,
72 	 * nothing more.
73 	 */
74 	if (address >= VMALLOC_START && address <= VMALLOC_END) {
75 		ret = handle_vmalloc_fault(address);
76 		if (unlikely(ret))
77 			goto bad_area_nosemaphore;
78 		else
79 			return;
80 	}
81 
82 	info.si_code = SEGV_MAPERR;
83 
84 	/*
85 	 * If we're in an interrupt or have no user
86 	 * context, we must not take the fault..
87 	 */
88 	if (in_atomic() || !mm)
89 		goto no_context;
90 
91 	if (user_mode(regs))
92 		flags |= FAULT_FLAG_USER;
93 retry:
94 	down_read(&mm->mmap_sem);
95 	vma = find_vma(mm, address);
96 	if (!vma)
97 		goto bad_area;
98 	if (vma->vm_start <= address)
99 		goto good_area;
100 	if (!(vma->vm_flags & VM_GROWSDOWN))
101 		goto bad_area;
102 	if (expand_stack(vma, address))
103 		goto bad_area;
104 
105 	/*
106 	 * Ok, we have a good vm_area for this memory access, so
107 	 * we can handle it..
108 	 */
109 good_area:
110 	info.si_code = SEGV_ACCERR;
111 
112 	/* Handle protection violation, execute on heap or stack */
113 
114 	if ((regs->ecr_vec == ECR_V_PROTV) &&
115 	    (regs->ecr_cause == ECR_C_PROTV_INST_FETCH))
116 		goto bad_area;
117 
118 	if (write) {
119 		if (!(vma->vm_flags & VM_WRITE))
120 			goto bad_area;
121 		flags |= FAULT_FLAG_WRITE;
122 	} else {
123 		if (!(vma->vm_flags & (VM_READ | VM_EXEC)))
124 			goto bad_area;
125 	}
126 
127 	/*
128 	 * If for any reason at all we couldn't handle the fault,
129 	 * make sure we exit gracefully rather than endlessly redo
130 	 * the fault.
131 	 */
132 	fault = handle_mm_fault(mm, vma, address, flags);
133 
134 	/* If Pagefault was interrupted by SIGKILL, exit page fault "early" */
135 	if (unlikely(fatal_signal_pending(current))) {
136 		if ((fault & VM_FAULT_ERROR) && !(fault & VM_FAULT_RETRY))
137 			up_read(&mm->mmap_sem);
138 		if (user_mode(regs))
139 			return;
140 	}
141 
142 	if (likely(!(fault & VM_FAULT_ERROR))) {
143 		if (flags & FAULT_FLAG_ALLOW_RETRY) {
144 			/* To avoid updating stats twice for retry case */
145 			if (fault & VM_FAULT_MAJOR)
146 				tsk->maj_flt++;
147 			else
148 				tsk->min_flt++;
149 
150 			if (fault & VM_FAULT_RETRY) {
151 				flags &= ~FAULT_FLAG_ALLOW_RETRY;
152 				flags |= FAULT_FLAG_TRIED;
153 				goto retry;
154 			}
155 		}
156 
157 		/* Fault Handled Gracefully */
158 		up_read(&mm->mmap_sem);
159 		return;
160 	}
161 
162 	if (fault & VM_FAULT_OOM)
163 		goto out_of_memory;
164 	else if (fault & VM_FAULT_SIGBUS)
165 		goto do_sigbus;
166 
167 	/* no man's land */
168 	BUG();
169 
170 	/*
171 	 * Something tried to access memory that isn't in our memory map..
172 	 * Fix it, but check if it's kernel or user first..
173 	 */
174 bad_area:
175 	up_read(&mm->mmap_sem);
176 
177 bad_area_nosemaphore:
178 	/* User mode accesses just cause a SIGSEGV */
179 	if (user_mode(regs)) {
180 		tsk->thread.fault_address = address;
181 		info.si_signo = SIGSEGV;
182 		info.si_errno = 0;
183 		/* info.si_code has been set above */
184 		info.si_addr = (void __user *)address;
185 		force_sig_info(SIGSEGV, &info, tsk);
186 		return;
187 	}
188 
189 no_context:
190 	/* Are we prepared to handle this kernel fault?
191 	 *
192 	 * (The kernel has valid exception-points in the source
193 	 *  when it acesses user-memory. When it fails in one
194 	 *  of those points, we find it in a table and do a jump
195 	 *  to some fixup code that loads an appropriate error
196 	 *  code)
197 	 */
198 	if (fixup_exception(regs))
199 		return;
200 
201 	die("Oops", regs, address);
202 
203 out_of_memory:
204 	up_read(&mm->mmap_sem);
205 
206 	if (user_mode(regs)) {
207 		pagefault_out_of_memory();
208 		return;
209 	}
210 
211 	goto no_context;
212 
213 do_sigbus:
214 	up_read(&mm->mmap_sem);
215 
216 	if (!user_mode(regs))
217 		goto no_context;
218 
219 	tsk->thread.fault_address = address;
220 	info.si_signo = SIGBUS;
221 	info.si_errno = 0;
222 	info.si_code = BUS_ADRERR;
223 	info.si_addr = (void __user *)address;
224 	force_sig_info(SIGBUS, &info, tsk);
225 }
226