1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
7 #include <linux/sched/signal.h>
8 #include <linux/hardirq.h>
9 #include <linux/module.h>
10 #include <linux/uaccess.h>
11 #include <linux/sched/debug.h>
12 #include <asm/current.h>
13 #include <asm/pgtable.h>
14 #include <asm/tlbflush.h>
16 #include <as-layout.h>
17 #include <kern_util.h>
22 * Note this is constrained to return 0, -EFAULT, -EACCES, -ENOMEM by
25 int handle_page_fault(unsigned long address, unsigned long ip,
26 int is_write, int is_user, int *code_out)
28 struct mm_struct *mm = current->mm;
29 struct vm_area_struct *vma;
36 unsigned int flags = FAULT_FLAG_DEFAULT;
38 *code_out = SEGV_MAPERR;
41 * If the fault was with pagefaults disabled, don't take the fault, just
44 if (faulthandler_disabled())
48 flags |= FAULT_FLAG_USER;
50 down_read(&mm->mmap_sem);
51 vma = find_vma(mm, address);
54 else if (vma->vm_start <= address)
56 else if (!(vma->vm_flags & VM_GROWSDOWN))
58 else if (is_user && !ARCH_IS_STACKGROW(address))
60 else if (expand_stack(vma, address))
64 *code_out = SEGV_ACCERR;
66 if (!(vma->vm_flags & VM_WRITE))
68 flags |= FAULT_FLAG_WRITE;
70 /* Don't require VM_READ|VM_EXEC for write faults! */
71 if (!(vma->vm_flags & (VM_READ | VM_EXEC)))
78 fault = handle_mm_fault(vma, address, flags);
80 if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current))
83 if (unlikely(fault & VM_FAULT_ERROR)) {
84 if (fault & VM_FAULT_OOM) {
86 } else if (fault & VM_FAULT_SIGSEGV) {
88 } else if (fault & VM_FAULT_SIGBUS) {
94 if (flags & FAULT_FLAG_ALLOW_RETRY) {
95 if (fault & VM_FAULT_MAJOR)
99 if (fault & VM_FAULT_RETRY) {
100 flags |= FAULT_FLAG_TRIED;
106 pgd = pgd_offset(mm, address);
107 p4d = p4d_offset(pgd, address);
108 pud = pud_offset(p4d, address);
109 pmd = pmd_offset(pud, address);
110 pte = pte_offset_kernel(pmd, address);
111 } while (!pte_present(*pte));
114 * The below warning was added in place of
115 * pte_mkyoung(); if (is_write) pte_mkdirty();
116 * If it's triggered, we'd see normally a hang here (a clean pte is
117 * marked read-only to emulate the dirty bit).
118 * However, the generic code can mark a PTE writable but clean on a
119 * concurrent read fault, triggering this harmlessly. So comment it out.
122 WARN_ON(!pte_young(*pte) || (is_write && !pte_dirty(*pte)));
124 flush_tlb_page(vma, address);
126 up_read(&mm->mmap_sem);
132 * We ran out of memory, call the OOM killer, and return the userspace
133 * (which will retry the fault, or kill us if we got oom-killed).
135 up_read(&mm->mmap_sem);
137 goto out_nosemaphore;
138 pagefault_out_of_memory();
141 EXPORT_SYMBOL(handle_page_fault);
143 static void show_segv_info(struct uml_pt_regs *regs)
145 struct task_struct *tsk = current;
146 struct faultinfo *fi = UPT_FAULTINFO(regs);
148 if (!unhandled_signal(tsk, SIGSEGV))
151 if (!printk_ratelimit())
154 printk("%s%s[%d]: segfault at %lx ip %px sp %px error %x",
155 task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG,
156 tsk->comm, task_pid_nr(tsk), FAULT_ADDRESS(*fi),
157 (void *)UPT_IP(regs), (void *)UPT_SP(regs),
160 print_vma_addr(KERN_CONT " in ", UPT_IP(regs));
161 printk(KERN_CONT "\n");
164 static void bad_segv(struct faultinfo fi, unsigned long ip)
166 current->thread.arch.faultinfo = fi;
167 force_sig_fault(SIGSEGV, SEGV_ACCERR, (void __user *) FAULT_ADDRESS(fi));
170 void fatal_sigsegv(void)
172 force_sigsegv(SIGSEGV);
173 do_signal(¤t->thread.regs);
175 * This is to tell gcc that we're not returning - do_signal
176 * can, in general, return, but in this case, it's not, since
177 * we just got a fatal SIGSEGV queued.
183 * segv_handler() - the SIGSEGV handler
184 * @sig: the signal number
185 * @unused_si: the signal info struct; unused in this handler
186 * @regs: the ptrace register information
188 * The handler first extracts the faultinfo from the UML ptrace regs struct.
189 * If the userfault did not happen in an UML userspace process, bad_segv is called.
190 * Otherwise the signal did happen in a cloned userspace process, handle it.
192 void segv_handler(int sig, struct siginfo *unused_si, struct uml_pt_regs *regs)
194 struct faultinfo * fi = UPT_FAULTINFO(regs);
196 if (UPT_IS_USER(regs) && !SEGV_IS_FIXABLE(fi)) {
197 show_segv_info(regs);
198 bad_segv(*fi, UPT_IP(regs));
201 segv(*fi, UPT_IP(regs), UPT_IS_USER(regs), regs);
205 * We give a *copy* of the faultinfo in the regs to segv.
206 * This must be done, since nesting SEGVs could overwrite
207 * the info in the regs. A pointer to the info then would
210 unsigned long segv(struct faultinfo fi, unsigned long ip, int is_user,
211 struct uml_pt_regs *regs)
216 int is_write = FAULT_WRITE(fi);
217 unsigned long address = FAULT_ADDRESS(fi);
219 if (!is_user && regs)
220 current->thread.segv_regs = container_of(regs, struct pt_regs, regs);
222 if (!is_user && (address >= start_vm) && (address < end_vm)) {
223 flush_tlb_kernel_vm();
226 else if (current->mm == NULL) {
227 show_regs(container_of(regs, struct pt_regs, regs));
228 panic("Segfault with no mm");
230 else if (!is_user && address > PAGE_SIZE && address < TASK_SIZE) {
231 show_regs(container_of(regs, struct pt_regs, regs));
232 panic("Kernel tried to access user memory at addr 0x%lx, ip 0x%lx",
236 if (SEGV_IS_FIXABLE(&fi))
237 err = handle_page_fault(address, ip, is_write, is_user,
242 * A thread accessed NULL, we get a fault, but CR2 is invalid.
243 * This code is used in __do_copy_from_user() of TT mode.
244 * XXX tt mode is gone, so maybe this isn't needed any more
249 catcher = current->thread.fault_catcher;
252 else if (catcher != NULL) {
253 current->thread.fault_addr = (void *) address;
254 UML_LONGJMP(catcher, 1);
256 else if (current->thread.fault_addr != NULL)
257 panic("fault_addr set but no fault catcher");
258 else if (!is_user && arch_fixup(ip, regs))
262 show_regs(container_of(regs, struct pt_regs, regs));
263 panic("Kernel mode fault at addr 0x%lx, ip 0x%lx",
267 show_segv_info(regs);
269 if (err == -EACCES) {
270 current->thread.arch.faultinfo = fi;
271 force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address);
273 BUG_ON(err != -EFAULT);
274 current->thread.arch.faultinfo = fi;
275 force_sig_fault(SIGSEGV, si_code, (void __user *) address);
280 current->thread.segv_regs = NULL;
285 void relay_signal(int sig, struct siginfo *si, struct uml_pt_regs *regs)
288 if (!UPT_IS_USER(regs)) {
290 printk(KERN_ERR "Bus error - the host /dev/shm or /tmp "
291 "mount likely just ran out of space\n");
292 panic("Kernel mode signal %d", sig);
295 arch_examine_signal(sig, regs);
297 /* Is the signal layout for the signal known?
298 * Signal data must be scrubbed to prevent information leaks.
302 if ((err == 0) && (siginfo_layout(sig, code) == SIL_FAULT)) {
303 struct faultinfo *fi = UPT_FAULTINFO(regs);
304 current->thread.arch.faultinfo = *fi;
305 force_sig_fault(sig, code, (void __user *)FAULT_ADDRESS(*fi));
307 printk(KERN_ERR "Attempted to relay unknown signal %d (si_code = %d) with errno %d\n",
313 void bus_handler(int sig, struct siginfo *si, struct uml_pt_regs *regs)
315 if (current->thread.fault_catcher != NULL)
316 UML_LONGJMP(current->thread.fault_catcher, 1);
318 relay_signal(sig, si, regs);
321 void winch(int sig, struct siginfo *unused_si, struct uml_pt_regs *regs)
323 do_IRQ(WINCH_IRQ, regs);