1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *  linux/arch/m68k/mm/fault.c
4  *
5  *  Copyright (C) 1995  Hamish Macdonald
6  */
7 
8 #include <linux/mman.h>
9 #include <linux/mm.h>
10 #include <linux/kernel.h>
11 #include <linux/ptrace.h>
12 #include <linux/interrupt.h>
13 #include <linux/module.h>
14 #include <linux/uaccess.h>
15 #include <linux/perf_event.h>
16 
17 #include <asm/setup.h>
18 #include <asm/traps.h>
19 
20 extern void die_if_kernel(char *, struct pt_regs *, long);
21 
send_fault_sig(struct pt_regs * regs)22 int send_fault_sig(struct pt_regs *regs)
23 {
24 	int signo, si_code;
25 	void __user *addr;
26 
27 	signo = current->thread.signo;
28 	si_code = current->thread.code;
29 	addr = (void __user *)current->thread.faddr;
30 	pr_debug("send_fault_sig: %p,%d,%d\n", addr, signo, si_code);
31 
32 	if (user_mode(regs)) {
33 		force_sig_fault(signo, si_code, addr);
34 	} else {
35 		if (fixup_exception(regs))
36 			return -1;
37 
38 		//if (signo == SIGBUS)
39 		//	force_sig_fault(si_signo, si_code, addr);
40 
41 		/*
42 		 * Oops. The kernel tried to access some bad page. We'll have to
43 		 * terminate things with extreme prejudice.
44 		 */
45 		if ((unsigned long)addr < PAGE_SIZE)
46 			pr_alert("Unable to handle kernel NULL pointer dereference");
47 		else
48 			pr_alert("Unable to handle kernel access");
49 		pr_cont(" at virtual address %p\n", addr);
50 		die_if_kernel("Oops", regs, 0 /*error_code*/);
51 		do_exit(SIGKILL);
52 	}
53 
54 	return 1;
55 }
56 
57 /*
58  * This routine handles page faults.  It determines the problem, and
59  * then passes it off to one of the appropriate routines.
60  *
61  * error_code:
62  *	bit 0 == 0 means no page found, 1 means protection fault
63  *	bit 1 == 0 means read, 1 means write
64  *
65  * If this routine detects a bad access, it returns 1, otherwise it
66  * returns 0.
67  */
do_page_fault(struct pt_regs * regs,unsigned long address,unsigned long error_code)68 int do_page_fault(struct pt_regs *regs, unsigned long address,
69 			      unsigned long error_code)
70 {
71 	struct mm_struct *mm = current->mm;
72 	struct vm_area_struct * vma;
73 	vm_fault_t fault;
74 	unsigned int flags = FAULT_FLAG_DEFAULT;
75 
76 	pr_debug("do page fault:\nregs->sr=%#x, regs->pc=%#lx, address=%#lx, %ld, %p\n",
77 		regs->sr, regs->pc, address, error_code, mm ? mm->pgd : NULL);
78 
79 	/*
80 	 * If we're in an interrupt or have no user
81 	 * context, we must not take the fault..
82 	 */
83 	if (faulthandler_disabled() || !mm)
84 		goto no_context;
85 
86 	if (user_mode(regs))
87 		flags |= FAULT_FLAG_USER;
88 
89 	perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);
90 retry:
91 	mmap_read_lock(mm);
92 
93 	vma = find_vma(mm, address);
94 	if (!vma)
95 		goto map_err;
96 	if (vma->vm_flags & VM_IO)
97 		goto acc_err;
98 	if (vma->vm_start <= address)
99 		goto good_area;
100 	if (!(vma->vm_flags & VM_GROWSDOWN))
101 		goto map_err;
102 	if (user_mode(regs)) {
103 		/* Accessing the stack below usp is always a bug.  The
104 		   "+ 256" is there due to some instructions doing
105 		   pre-decrement on the stack and that doesn't show up
106 		   until later.  */
107 		if (address + 256 < rdusp())
108 			goto map_err;
109 	}
110 	if (expand_stack(vma, address))
111 		goto map_err;
112 
113 /*
114  * Ok, we have a good vm_area for this memory access, so
115  * we can handle it..
116  */
117 good_area:
118 	pr_debug("do_page_fault: good_area\n");
119 	switch (error_code & 3) {
120 		default:	/* 3: write, present */
121 			fallthrough;
122 		case 2:		/* write, not present */
123 			if (!(vma->vm_flags & VM_WRITE))
124 				goto acc_err;
125 			flags |= FAULT_FLAG_WRITE;
126 			break;
127 		case 1:		/* read, present */
128 			goto acc_err;
129 		case 0:		/* read, not present */
130 			if (unlikely(!vma_is_accessible(vma)))
131 				goto acc_err;
132 	}
133 
134 	/*
135 	 * If for any reason at all we couldn't handle the fault,
136 	 * make sure we exit gracefully rather than endlessly redo
137 	 * the fault.
138 	 */
139 
140 	fault = handle_mm_fault(vma, address, flags, regs);
141 	pr_debug("handle_mm_fault returns %x\n", fault);
142 
143 	if (fault_signal_pending(fault, regs))
144 		return 0;
145 
146 	if (unlikely(fault & VM_FAULT_ERROR)) {
147 		if (fault & VM_FAULT_OOM)
148 			goto out_of_memory;
149 		else if (fault & VM_FAULT_SIGSEGV)
150 			goto map_err;
151 		else if (fault & VM_FAULT_SIGBUS)
152 			goto bus_err;
153 		BUG();
154 	}
155 
156 	if (flags & FAULT_FLAG_ALLOW_RETRY) {
157 		if (fault & VM_FAULT_RETRY) {
158 			flags |= FAULT_FLAG_TRIED;
159 
160 			/*
161 			 * No need to mmap_read_unlock(mm) as we would
162 			 * have already released it in __lock_page_or_retry
163 			 * in mm/filemap.c.
164 			 */
165 
166 			goto retry;
167 		}
168 	}
169 
170 	mmap_read_unlock(mm);
171 	return 0;
172 
173 /*
174  * We ran out of memory, or some other thing happened to us that made
175  * us unable to handle the page fault gracefully.
176  */
177 out_of_memory:
178 	mmap_read_unlock(mm);
179 	if (!user_mode(regs))
180 		goto no_context;
181 	pagefault_out_of_memory();
182 	return 0;
183 
184 no_context:
185 	current->thread.signo = SIGBUS;
186 	current->thread.faddr = address;
187 	return send_fault_sig(regs);
188 
189 bus_err:
190 	current->thread.signo = SIGBUS;
191 	current->thread.code = BUS_ADRERR;
192 	current->thread.faddr = address;
193 	goto send_sig;
194 
195 map_err:
196 	current->thread.signo = SIGSEGV;
197 	current->thread.code = SEGV_MAPERR;
198 	current->thread.faddr = address;
199 	goto send_sig;
200 
201 acc_err:
202 	current->thread.signo = SIGSEGV;
203 	current->thread.code = SEGV_ACCERR;
204 	current->thread.faddr = address;
205 
206 send_sig:
207 	mmap_read_unlock(mm);
208 	return send_fault_sig(regs);
209 }
210