xref: /openbmc/linux/arch/powerpc/mm/fault.c (revision 5d0e4d78)
1 /*
2  *  PowerPC version
3  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
4  *
5  *  Derived from "arch/i386/mm/fault.c"
6  *    Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
7  *
8  *  Modified by Cort Dougan and Paul Mackerras.
9  *
10  *  Modified for PPC64 by Dave Engebretsen (engebret@ibm.com)
11  *
12  *  This program is free software; you can redistribute it and/or
13  *  modify it under the terms of the GNU General Public License
14  *  as published by the Free Software Foundation; either version
15  *  2 of the License, or (at your option) any later version.
16  */
17 
18 #include <linux/signal.h>
19 #include <linux/sched.h>
20 #include <linux/sched/task_stack.h>
21 #include <linux/kernel.h>
22 #include <linux/errno.h>
23 #include <linux/string.h>
24 #include <linux/types.h>
25 #include <linux/ptrace.h>
26 #include <linux/mman.h>
27 #include <linux/mm.h>
28 #include <linux/interrupt.h>
29 #include <linux/highmem.h>
30 #include <linux/extable.h>
31 #include <linux/kprobes.h>
32 #include <linux/kdebug.h>
33 #include <linux/perf_event.h>
34 #include <linux/ratelimit.h>
35 #include <linux/context_tracking.h>
36 #include <linux/hugetlb.h>
37 #include <linux/uaccess.h>
38 
39 #include <asm/firmware.h>
40 #include <asm/page.h>
41 #include <asm/pgtable.h>
42 #include <asm/mmu.h>
43 #include <asm/mmu_context.h>
44 #include <asm/tlbflush.h>
45 #include <asm/siginfo.h>
46 #include <asm/debug.h>
47 
48 #include "icswx.h"
49 
50 #ifdef CONFIG_KPROBES
51 static inline int notify_page_fault(struct pt_regs *regs)
52 {
53 	int ret = 0;
54 
55 	/* kprobe_running() needs smp_processor_id() */
56 	if (!user_mode(regs)) {
57 		preempt_disable();
58 		if (kprobe_running() && kprobe_fault_handler(regs, 11))
59 			ret = 1;
60 		preempt_enable();
61 	}
62 
63 	return ret;
64 }
65 #else
66 static inline int notify_page_fault(struct pt_regs *regs)
67 {
68 	return 0;
69 }
70 #endif
71 
72 /*
73  * Check whether the instruction at regs->nip is a store using
74  * an update addressing form which will update r1.
75  */
76 static int store_updates_sp(struct pt_regs *regs)
77 {
78 	unsigned int inst;
79 
80 	if (get_user(inst, (unsigned int __user *)regs->nip))
81 		return 0;
82 	/* check for 1 in the rA field */
83 	if (((inst >> 16) & 0x1f) != 1)
84 		return 0;
85 	/* check major opcode */
86 	switch (inst >> 26) {
87 	case 37:	/* stwu */
88 	case 39:	/* stbu */
89 	case 45:	/* sthu */
90 	case 53:	/* stfsu */
91 	case 55:	/* stfdu */
92 		return 1;
93 	case 62:	/* std or stdu */
94 		return (inst & 3) == 1;
95 	case 31:
96 		/* check minor opcode */
97 		switch ((inst >> 1) & 0x3ff) {
98 		case 181:	/* stdux */
99 		case 183:	/* stwux */
100 		case 247:	/* stbux */
101 		case 439:	/* sthux */
102 		case 695:	/* stfsux */
103 		case 759:	/* stfdux */
104 			return 1;
105 		}
106 	}
107 	return 0;
108 }
109 /*
110  * do_page_fault error handling helpers
111  */
112 
113 #define MM_FAULT_RETURN		0
114 #define MM_FAULT_CONTINUE	-1
115 #define MM_FAULT_ERR(sig)	(sig)
116 
117 static int do_sigbus(struct pt_regs *regs, unsigned long address,
118 		     unsigned int fault)
119 {
120 	siginfo_t info;
121 	unsigned int lsb = 0;
122 
123 	if (!user_mode(regs))
124 		return MM_FAULT_ERR(SIGBUS);
125 
126 	current->thread.trap_nr = BUS_ADRERR;
127 	info.si_signo = SIGBUS;
128 	info.si_errno = 0;
129 	info.si_code = BUS_ADRERR;
130 	info.si_addr = (void __user *)address;
131 #ifdef CONFIG_MEMORY_FAILURE
132 	if (fault & (VM_FAULT_HWPOISON|VM_FAULT_HWPOISON_LARGE)) {
133 		pr_err("MCE: Killing %s:%d due to hardware memory corruption fault at %lx\n",
134 			current->comm, current->pid, address);
135 		info.si_code = BUS_MCEERR_AR;
136 	}
137 
138 	if (fault & VM_FAULT_HWPOISON_LARGE)
139 		lsb = hstate_index_to_shift(VM_FAULT_GET_HINDEX(fault));
140 	if (fault & VM_FAULT_HWPOISON)
141 		lsb = PAGE_SHIFT;
142 #endif
143 	info.si_addr_lsb = lsb;
144 	force_sig_info(SIGBUS, &info, current);
145 	return MM_FAULT_RETURN;
146 }
147 
148 static int mm_fault_error(struct pt_regs *regs, unsigned long addr, int fault)
149 {
150 	/*
151 	 * Pagefault was interrupted by SIGKILL. We have no reason to
152 	 * continue the pagefault.
153 	 */
154 	if (fatal_signal_pending(current)) {
155 		/* Coming from kernel, we need to deal with uaccess fixups */
156 		if (user_mode(regs))
157 			return MM_FAULT_RETURN;
158 		return MM_FAULT_ERR(SIGKILL);
159 	}
160 
161 	/* No fault: be happy */
162 	if (!(fault & VM_FAULT_ERROR))
163 		return MM_FAULT_CONTINUE;
164 
165 	/* Out of memory */
166 	if (fault & VM_FAULT_OOM) {
167 		/*
168 		 * We ran out of memory, or some other thing happened to us that
169 		 * made us unable to handle the page fault gracefully.
170 		 */
171 		if (!user_mode(regs))
172 			return MM_FAULT_ERR(SIGKILL);
173 		pagefault_out_of_memory();
174 		return MM_FAULT_RETURN;
175 	}
176 
177 	if (fault & (VM_FAULT_SIGBUS|VM_FAULT_HWPOISON|VM_FAULT_HWPOISON_LARGE))
178 		return do_sigbus(regs, addr, fault);
179 
180 	/* We don't understand the fault code, this is fatal */
181 	BUG();
182 	return MM_FAULT_CONTINUE;
183 }
184 
185 /*
186  * For 600- and 800-family processors, the error_code parameter is DSISR
187  * for a data fault, SRR1 for an instruction fault. For 400-family processors
188  * the error_code parameter is ESR for a data fault, 0 for an instruction
189  * fault.
190  * For 64-bit processors, the error_code parameter is
191  *  - DSISR for a non-SLB data access fault,
192  *  - SRR1 & 0x08000000 for a non-SLB instruction access fault
193  *  - 0 any SLB fault.
194  *
195  * The return value is 0 if the fault was handled, or the signal
196  * number if this is a kernel fault that can't be handled here.
197  */
198 int do_page_fault(struct pt_regs *regs, unsigned long address,
199 			    unsigned long error_code)
200 {
201 	enum ctx_state prev_state = exception_enter();
202 	struct vm_area_struct * vma;
203 	struct mm_struct *mm = current->mm;
204 	unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
205 	int code = SEGV_MAPERR;
206 	int is_write = 0;
207 	int trap = TRAP(regs);
208  	int is_exec = trap == 0x400;
209 	int is_user = user_mode(regs);
210 	int fault;
211 	int rc = 0, store_update_sp = 0;
212 
213 #if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
214 	/*
215 	 * Fortunately the bit assignments in SRR1 for an instruction
216 	 * fault and DSISR for a data fault are mostly the same for the
217 	 * bits we are interested in.  But there are some bits which
218 	 * indicate errors in DSISR but can validly be set in SRR1.
219 	 */
220 	if (is_exec)
221 		error_code &= 0x48200000;
222 	else
223 		is_write = error_code & DSISR_ISSTORE;
224 #else
225 	is_write = error_code & ESR_DST;
226 #endif /* CONFIG_4xx || CONFIG_BOOKE */
227 
228 #ifdef CONFIG_PPC_ICSWX
229 	/*
230 	 * we need to do this early because this "data storage
231 	 * interrupt" does not update the DAR/DEAR so we don't want to
232 	 * look at it
233 	 */
234 	if (error_code & ICSWX_DSI_UCT) {
235 		rc = acop_handle_fault(regs, address, error_code);
236 		if (rc)
237 			goto bail;
238 	}
239 #endif /* CONFIG_PPC_ICSWX */
240 
241 	if (notify_page_fault(regs))
242 		goto bail;
243 
244 	if (unlikely(debugger_fault_handler(regs)))
245 		goto bail;
246 
247 	/*
248 	 * The kernel should never take an execute fault nor should it
249 	 * take a page fault to a kernel address.
250 	 */
251 	if (!is_user && (is_exec || (address >= TASK_SIZE))) {
252 		rc = SIGSEGV;
253 		goto bail;
254 	}
255 
256 #if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE) || \
257       defined(CONFIG_PPC_BOOK3S_64) || defined(CONFIG_PPC_8xx))
258   	if (error_code & DSISR_DABRMATCH) {
259 		/* breakpoint match */
260 		do_break(regs, address, error_code);
261 		goto bail;
262 	}
263 #endif
264 
265 	/* We restore the interrupt state now */
266 	if (!arch_irq_disabled_regs(regs))
267 		local_irq_enable();
268 
269 	if (faulthandler_disabled() || mm == NULL) {
270 		if (!is_user) {
271 			rc = SIGSEGV;
272 			goto bail;
273 		}
274 		/* faulthandler_disabled() in user mode is really bad,
275 		   as is current->mm == NULL. */
276 		printk(KERN_EMERG "Page fault in user mode with "
277 		       "faulthandler_disabled() = %d mm = %p\n",
278 		       faulthandler_disabled(), mm);
279 		printk(KERN_EMERG "NIP = %lx  MSR = %lx\n",
280 		       regs->nip, regs->msr);
281 		die("Weird page fault", regs, SIGSEGV);
282 	}
283 
284 	perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);
285 
286 	/*
287 	 * We want to do this outside mmap_sem, because reading code around nip
288 	 * can result in fault, which will cause a deadlock when called with
289 	 * mmap_sem held
290 	 */
291 	if (is_write && is_user)
292 		store_update_sp = store_updates_sp(regs);
293 
294 	if (is_user)
295 		flags |= FAULT_FLAG_USER;
296 
297 	/* When running in the kernel we expect faults to occur only to
298 	 * addresses in user space.  All other faults represent errors in the
299 	 * kernel and should generate an OOPS.  Unfortunately, in the case of an
300 	 * erroneous fault occurring in a code path which already holds mmap_sem
301 	 * we will deadlock attempting to validate the fault against the
302 	 * address space.  Luckily the kernel only validly references user
303 	 * space from well defined areas of code, which are listed in the
304 	 * exceptions table.
305 	 *
306 	 * As the vast majority of faults will be valid we will only perform
307 	 * the source reference check when there is a possibility of a deadlock.
308 	 * Attempt to lock the address space, if we cannot we then validate the
309 	 * source.  If this is invalid we can skip the address space check,
310 	 * thus avoiding the deadlock.
311 	 */
312 	if (!down_read_trylock(&mm->mmap_sem)) {
313 		if (!is_user && !search_exception_tables(regs->nip))
314 			goto bad_area_nosemaphore;
315 
316 retry:
317 		down_read(&mm->mmap_sem);
318 	} else {
319 		/*
320 		 * The above down_read_trylock() might have succeeded in
321 		 * which case we'll have missed the might_sleep() from
322 		 * down_read():
323 		 */
324 		might_sleep();
325 	}
326 
327 	vma = find_vma(mm, address);
328 	if (!vma)
329 		goto bad_area;
330 	if (vma->vm_start <= address)
331 		goto good_area;
332 	if (!(vma->vm_flags & VM_GROWSDOWN))
333 		goto bad_area;
334 
335 	/*
336 	 * N.B. The POWER/Open ABI allows programs to access up to
337 	 * 288 bytes below the stack pointer.
338 	 * The kernel signal delivery code writes up to about 1.5kB
339 	 * below the stack pointer (r1) before decrementing it.
340 	 * The exec code can write slightly over 640kB to the stack
341 	 * before setting the user r1.  Thus we allow the stack to
342 	 * expand to 1MB without further checks.
343 	 */
344 	if (address + 0x100000 < vma->vm_end) {
345 		/* get user regs even if this fault is in kernel mode */
346 		struct pt_regs *uregs = current->thread.regs;
347 		if (uregs == NULL)
348 			goto bad_area;
349 
350 		/*
351 		 * A user-mode access to an address a long way below
352 		 * the stack pointer is only valid if the instruction
353 		 * is one which would update the stack pointer to the
354 		 * address accessed if the instruction completed,
355 		 * i.e. either stwu rs,n(r1) or stwux rs,r1,rb
356 		 * (or the byte, halfword, float or double forms).
357 		 *
358 		 * If we don't check this then any write to the area
359 		 * between the last mapped region and the stack will
360 		 * expand the stack rather than segfaulting.
361 		 */
362 		if (address + 2048 < uregs->gpr[1] && !store_update_sp)
363 			goto bad_area;
364 	}
365 	if (expand_stack(vma, address))
366 		goto bad_area;
367 
368 good_area:
369 	code = SEGV_ACCERR;
370 #if defined(CONFIG_6xx)
371 	if (error_code & 0x95700000)
372 		/* an error such as lwarx to I/O controller space,
373 		   address matching DABR, eciwx, etc. */
374 		goto bad_area;
375 #endif /* CONFIG_6xx */
376 #if defined(CONFIG_8xx)
377         /* The MPC8xx seems to always set 0x80000000, which is
378          * "undefined".  Of those that can be set, this is the only
379          * one which seems bad.
380          */
381 	if (error_code & 0x10000000)
382                 /* Guarded storage error. */
383 		goto bad_area;
384 #endif /* CONFIG_8xx */
385 
386 	if (is_exec) {
387 		/*
388 		 * Allow execution from readable areas if the MMU does not
389 		 * provide separate controls over reading and executing.
390 		 *
391 		 * Note: That code used to not be enabled for 4xx/BookE.
392 		 * It is now as I/D cache coherency for these is done at
393 		 * set_pte_at() time and I see no reason why the test
394 		 * below wouldn't be valid on those processors. This -may-
395 		 * break programs compiled with a really old ABI though.
396 		 */
397 		if (!(vma->vm_flags & VM_EXEC) &&
398 		    (cpu_has_feature(CPU_FTR_NOEXECUTE) ||
399 		     !(vma->vm_flags & (VM_READ | VM_WRITE))))
400 			goto bad_area;
401 	/* a write */
402 	} else if (is_write) {
403 		if (!(vma->vm_flags & VM_WRITE))
404 			goto bad_area;
405 		flags |= FAULT_FLAG_WRITE;
406 	/* a read */
407 	} else {
408 		if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)))
409 			goto bad_area;
410 	}
411 #ifdef CONFIG_PPC_STD_MMU
412 	/*
413 	 * For hash translation mode, we should never get a
414 	 * PROTFAULT. Any update to pte to reduce access will result in us
415 	 * removing the hash page table entry, thus resulting in a DSISR_NOHPTE
416 	 * fault instead of DSISR_PROTFAULT.
417 	 *
418 	 * A pte update to relax the access will not result in a hash page table
419 	 * entry invalidate and hence can result in DSISR_PROTFAULT.
420 	 * ptep_set_access_flags() doesn't do a hpte flush. This is why we have
421 	 * the special !is_write in the below conditional.
422 	 *
423 	 * For platforms that doesn't supports coherent icache and do support
424 	 * per page noexec bit, we do setup things such that we do the
425 	 * sync between D/I cache via fault. But that is handled via low level
426 	 * hash fault code (hash_page_do_lazy_icache()) and we should not reach
427 	 * here in such case.
428 	 *
429 	 * For wrong access that can result in PROTFAULT, the above vma->vm_flags
430 	 * check should handle those and hence we should fall to the bad_area
431 	 * handling correctly.
432 	 *
433 	 * For embedded with per page exec support that doesn't support coherent
434 	 * icache we do get PROTFAULT and we handle that D/I cache sync in
435 	 * set_pte_at while taking the noexec/prot fault. Hence this is WARN_ON
436 	 * is conditional for server MMU.
437 	 *
438 	 * For radix, we can get prot fault for autonuma case, because radix
439 	 * page table will have them marked noaccess for user.
440 	 */
441 	if (!radix_enabled() && !is_write)
442 		WARN_ON_ONCE(error_code & DSISR_PROTFAULT);
443 #endif /* CONFIG_PPC_STD_MMU */
444 
445 	/*
446 	 * If for any reason at all we couldn't handle the fault,
447 	 * make sure we exit gracefully rather than endlessly redo
448 	 * the fault.
449 	 */
450 	fault = handle_mm_fault(vma, address, flags);
451 
452 	/*
453 	 * Handle the retry right now, the mmap_sem has been released in that
454 	 * case.
455 	 */
456 	if (unlikely(fault & VM_FAULT_RETRY)) {
457 		/* We retry only once */
458 		if (flags & FAULT_FLAG_ALLOW_RETRY) {
459 			/*
460 			 * Clear FAULT_FLAG_ALLOW_RETRY to avoid any risk
461 			 * of starvation.
462 			 */
463 			flags &= ~FAULT_FLAG_ALLOW_RETRY;
464 			flags |= FAULT_FLAG_TRIED;
465 			if (!fatal_signal_pending(current))
466 				goto retry;
467 		}
468 		/* We will enter mm_fault_error() below */
469 	} else
470 		up_read(&current->mm->mmap_sem);
471 
472 	if (unlikely(fault & (VM_FAULT_RETRY|VM_FAULT_ERROR))) {
473 		if (fault & VM_FAULT_SIGSEGV)
474 			goto bad_area_nosemaphore;
475 		rc = mm_fault_error(regs, address, fault);
476 		if (rc >= MM_FAULT_RETURN)
477 			goto bail;
478 		else
479 			rc = 0;
480 	}
481 
482 	/*
483 	 * Major/minor page fault accounting.
484 	 */
485 	if (fault & VM_FAULT_MAJOR) {
486 		current->maj_flt++;
487 		perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1,
488 			      regs, address);
489 #ifdef CONFIG_PPC_SMLPAR
490 		if (firmware_has_feature(FW_FEATURE_CMO)) {
491 			u32 page_ins;
492 
493 			preempt_disable();
494 			page_ins = be32_to_cpu(get_lppaca()->page_ins);
495 			page_ins += 1 << PAGE_FACTOR;
496 			get_lppaca()->page_ins = cpu_to_be32(page_ins);
497 			preempt_enable();
498 		}
499 #endif /* CONFIG_PPC_SMLPAR */
500 	} else {
501 		current->min_flt++;
502 		perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1,
503 			      regs, address);
504 	}
505 
506 	goto bail;
507 
508 bad_area:
509 	up_read(&mm->mmap_sem);
510 
511 bad_area_nosemaphore:
512 	/* User mode accesses cause a SIGSEGV */
513 	if (is_user) {
514 		_exception(SIGSEGV, regs, code, address);
515 		goto bail;
516 	}
517 
518 	if (is_exec && (error_code & DSISR_PROTFAULT))
519 		printk_ratelimited(KERN_CRIT "kernel tried to execute NX-protected"
520 				   " page (%lx) - exploit attempt? (uid: %d)\n",
521 				   address, from_kuid(&init_user_ns, current_uid()));
522 
523 	rc = SIGSEGV;
524 
525 bail:
526 	exception_exit(prev_state);
527 	return rc;
528 }
529 NOKPROBE_SYMBOL(do_page_fault);
530 
531 /*
532  * bad_page_fault is called when we have a bad access from the kernel.
533  * It is called from the DSI and ISI handlers in head.S and from some
534  * of the procedures in traps.c.
535  */
536 void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)
537 {
538 	const struct exception_table_entry *entry;
539 
540 	/* Are we prepared to handle this fault?  */
541 	if ((entry = search_exception_tables(regs->nip)) != NULL) {
542 		regs->nip = extable_fixup(entry);
543 		return;
544 	}
545 
546 	/* kernel has accessed a bad area */
547 
548 	switch (regs->trap) {
549 	case 0x300:
550 	case 0x380:
551 		printk(KERN_ALERT "Unable to handle kernel paging request for "
552 			"data at address 0x%08lx\n", regs->dar);
553 		break;
554 	case 0x400:
555 	case 0x480:
556 		printk(KERN_ALERT "Unable to handle kernel paging request for "
557 			"instruction fetch\n");
558 		break;
559 	case 0x600:
560 		printk(KERN_ALERT "Unable to handle kernel paging request for "
561 			"unaligned access at address 0x%08lx\n", regs->dar);
562 		break;
563 	default:
564 		printk(KERN_ALERT "Unable to handle kernel paging request for "
565 			"unknown fault\n");
566 		break;
567 	}
568 	printk(KERN_ALERT "Faulting instruction address: 0x%08lx\n",
569 		regs->nip);
570 
571 	if (task_stack_end_corrupted(current))
572 		printk(KERN_ALERT "Thread overran stack, or stack corrupted\n");
573 
574 	die("Kernel access of bad area", regs, sig);
575 }
576