xref: /openbmc/linux/arch/s390/mm/fault.c (revision cd99b9eb) 
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *  S390 version
4  *    Copyright IBM Corp. 1999
5  *    Author(s): Hartmut Penner (hp@de.ibm.com)
6  *               Ulrich Weigand (uweigand@de.ibm.com)
7  *
8  *  Derived from "arch/i386/mm/fault.c"
9  *    Copyright (C) 1995  Linus Torvalds
10  */
11 
12 #include <linux/kernel_stat.h>
13 #include <linux/perf_event.h>
14 #include <linux/signal.h>
15 #include <linux/sched.h>
16 #include <linux/sched/debug.h>
17 #include <linux/kernel.h>
18 #include <linux/errno.h>
19 #include <linux/string.h>
20 #include <linux/types.h>
21 #include <linux/ptrace.h>
22 #include <linux/mman.h>
23 #include <linux/mm.h>
24 #include <linux/compat.h>
25 #include <linux/smp.h>
26 #include <linux/kdebug.h>
27 #include <linux/init.h>
28 #include <linux/console.h>
29 #include <linux/extable.h>
30 #include <linux/hardirq.h>
31 #include <linux/kprobes.h>
32 #include <linux/uaccess.h>
33 #include <linux/hugetlb.h>
34 #include <linux/kfence.h>
35 #include <asm/asm-extable.h>
36 #include <asm/asm-offsets.h>
37 #include <asm/diag.h>
38 #include <asm/gmap.h>
39 #include <asm/irq.h>
40 #include <asm/mmu_context.h>
41 #include <asm/facility.h>
42 #include <asm/uv.h>
43 #include "../kernel/entry.h"
44 
45 #define __FAIL_ADDR_MASK -4096L
46 
47 /*
48  * Allocate private vm_fault_reason from top.  Please make sure it won't
49  * collide with vm_fault_reason.
50  */
51 #define VM_FAULT_BADCONTEXT	((__force vm_fault_t)0x80000000)
52 #define VM_FAULT_BADMAP		((__force vm_fault_t)0x40000000)
53 #define VM_FAULT_BADACCESS	((__force vm_fault_t)0x20000000)
54 #define VM_FAULT_SIGNAL		((__force vm_fault_t)0x10000000)
55 #define VM_FAULT_PFAULT		((__force vm_fault_t)0x8000000)
56 
57 enum fault_type {
58 	KERNEL_FAULT,
59 	USER_FAULT,
60 	GMAP_FAULT,
61 };
62 
63 static unsigned long store_indication __read_mostly;
64 
65 static int __init fault_init(void)
66 {
67 	if (test_facility(75))
68 		store_indication = 0xc00;
69 	return 0;
70 }
71 early_initcall(fault_init);
72 
73 /*
74  * Find out which address space caused the exception.
75  */
76 static enum fault_type get_fault_type(struct pt_regs *regs)
77 {
78 	unsigned long trans_exc_code;
79 
80 	trans_exc_code = regs->int_parm_long & 3;
81 	if (likely(trans_exc_code == 0)) {
82 		/* primary space exception */
83 		if (user_mode(regs))
84 			return USER_FAULT;
85 		if (!IS_ENABLED(CONFIG_PGSTE))
86 			return KERNEL_FAULT;
87 		if (test_pt_regs_flag(regs, PIF_GUEST_FAULT))
88 			return GMAP_FAULT;
89 		return KERNEL_FAULT;
90 	}
91 	if (trans_exc_code == 2)
92 		return USER_FAULT;
93 	if (trans_exc_code == 1) {
94 		/* access register mode, not used in the kernel */
95 		return USER_FAULT;
96 	}
97 	/* home space exception -> access via kernel ASCE */
98 	return KERNEL_FAULT;
99 }
100 
101 static unsigned long get_fault_address(struct pt_regs *regs)
102 {
103 	unsigned long trans_exc_code = regs->int_parm_long;
104 
105 	return trans_exc_code & __FAIL_ADDR_MASK;
106 }
107 
108 static bool fault_is_write(struct pt_regs *regs)
109 {
110 	unsigned long trans_exc_code = regs->int_parm_long;
111 
112 	return (trans_exc_code & store_indication) == 0x400;
113 }
114 
115 static int bad_address(void *p)
116 {
117 	unsigned long dummy;
118 
119 	return get_kernel_nofault(dummy, (unsigned long *)p);
120 }
121 
122 static void dump_pagetable(unsigned long asce, unsigned long address)
123 {
124 	unsigned long *table = __va(asce & _ASCE_ORIGIN);
125 
126 	pr_alert("AS:%016lx ", asce);
127 	switch (asce & _ASCE_TYPE_MASK) {
128 	case _ASCE_TYPE_REGION1:
129 		table += (address & _REGION1_INDEX) >> _REGION1_SHIFT;
130 		if (bad_address(table))
131 			goto bad;
132 		pr_cont("R1:%016lx ", *table);
133 		if (*table & _REGION_ENTRY_INVALID)
134 			goto out;
135 		table = __va(*table & _REGION_ENTRY_ORIGIN);
136 		fallthrough;
137 	case _ASCE_TYPE_REGION2:
138 		table += (address & _REGION2_INDEX) >> _REGION2_SHIFT;
139 		if (bad_address(table))
140 			goto bad;
141 		pr_cont("R2:%016lx ", *table);
142 		if (*table & _REGION_ENTRY_INVALID)
143 			goto out;
144 		table = __va(*table & _REGION_ENTRY_ORIGIN);
145 		fallthrough;
146 	case _ASCE_TYPE_REGION3:
147 		table += (address & _REGION3_INDEX) >> _REGION3_SHIFT;
148 		if (bad_address(table))
149 			goto bad;
150 		pr_cont("R3:%016lx ", *table);
151 		if (*table & (_REGION_ENTRY_INVALID | _REGION3_ENTRY_LARGE))
152 			goto out;
153 		table = __va(*table & _REGION_ENTRY_ORIGIN);
154 		fallthrough;
155 	case _ASCE_TYPE_SEGMENT:
156 		table += (address & _SEGMENT_INDEX) >> _SEGMENT_SHIFT;
157 		if (bad_address(table))
158 			goto bad;
159 		pr_cont("S:%016lx ", *table);
160 		if (*table & (_SEGMENT_ENTRY_INVALID | _SEGMENT_ENTRY_LARGE))
161 			goto out;
162 		table = __va(*table & _SEGMENT_ENTRY_ORIGIN);
163 	}
164 	table += (address & _PAGE_INDEX) >> _PAGE_SHIFT;
165 	if (bad_address(table))
166 		goto bad;
167 	pr_cont("P:%016lx ", *table);
168 out:
169 	pr_cont("\n");
170 	return;
171 bad:
172 	pr_cont("BAD\n");
173 }
174 
175 static void dump_fault_info(struct pt_regs *regs)
176 {
177 	unsigned long asce;
178 
179 	pr_alert("Failing address: %016lx TEID: %016lx\n",
180 		 regs->int_parm_long & __FAIL_ADDR_MASK, regs->int_parm_long);
181 	pr_alert("Fault in ");
182 	switch (regs->int_parm_long & 3) {
183 	case 3:
184 		pr_cont("home space ");
185 		break;
186 	case 2:
187 		pr_cont("secondary space ");
188 		break;
189 	case 1:
190 		pr_cont("access register ");
191 		break;
192 	case 0:
193 		pr_cont("primary space ");
194 		break;
195 	}
196 	pr_cont("mode while using ");
197 	switch (get_fault_type(regs)) {
198 	case USER_FAULT:
199 		asce = S390_lowcore.user_asce;
200 		pr_cont("user ");
201 		break;
202 	case GMAP_FAULT:
203 		asce = ((struct gmap *) S390_lowcore.gmap)->asce;
204 		pr_cont("gmap ");
205 		break;
206 	case KERNEL_FAULT:
207 		asce = S390_lowcore.kernel_asce;
208 		pr_cont("kernel ");
209 		break;
210 	default:
211 		unreachable();
212 	}
213 	pr_cont("ASCE.\n");
214 	dump_pagetable(asce, regs->int_parm_long & __FAIL_ADDR_MASK);
215 }
216 
217 int show_unhandled_signals = 1;
218 
219 void report_user_fault(struct pt_regs *regs, long signr, int is_mm_fault)
220 {
221 	if ((task_pid_nr(current) > 1) && !show_unhandled_signals)
222 		return;
223 	if (!unhandled_signal(current, signr))
224 		return;
225 	if (!printk_ratelimit())
226 		return;
227 	printk(KERN_ALERT "User process fault: interruption code %04x ilc:%d ",
228 	       regs->int_code & 0xffff, regs->int_code >> 17);
229 	print_vma_addr(KERN_CONT "in ", regs->psw.addr);
230 	printk(KERN_CONT "\n");
231 	if (is_mm_fault)
232 		dump_fault_info(regs);
233 	show_regs(regs);
234 }
235 
236 /*
237  * Send SIGSEGV to task.  This is an external routine
238  * to keep the stack usage of do_page_fault small.
239  */
240 static noinline void do_sigsegv(struct pt_regs *regs, int si_code)
241 {
242 	report_user_fault(regs, SIGSEGV, 1);
243 	force_sig_fault(SIGSEGV, si_code,
244 			(void __user *)(regs->int_parm_long & __FAIL_ADDR_MASK));
245 }
246 
247 static noinline void do_no_context(struct pt_regs *regs, vm_fault_t fault)
248 {
249 	enum fault_type fault_type;
250 	unsigned long address;
251 	bool is_write;
252 
253 	if (fixup_exception(regs))
254 		return;
255 	fault_type = get_fault_type(regs);
256 	if ((fault_type == KERNEL_FAULT) && (fault == VM_FAULT_BADCONTEXT)) {
257 		address = get_fault_address(regs);
258 		is_write = fault_is_write(regs);
259 		if (kfence_handle_page_fault(address, is_write, regs))
260 			return;
261 	}
262 	/*
263 	 * Oops. The kernel tried to access some bad page. We'll have to
264 	 * terminate things with extreme prejudice.
265 	 */
266 	if (fault_type == KERNEL_FAULT)
267 		printk(KERN_ALERT "Unable to handle kernel pointer dereference"
268 		       " in virtual kernel address space\n");
269 	else
270 		printk(KERN_ALERT "Unable to handle kernel paging request"
271 		       " in virtual user address space\n");
272 	dump_fault_info(regs);
273 	die(regs, "Oops");
274 }
275 
276 static noinline void do_low_address(struct pt_regs *regs)
277 {
278 	/* Low-address protection hit in kernel mode means
279 	   NULL pointer write access in kernel mode.  */
280 	if (regs->psw.mask & PSW_MASK_PSTATE) {
281 		/* Low-address protection hit in user mode 'cannot happen'. */
282 		die (regs, "Low-address protection");
283 	}
284 
285 	do_no_context(regs, VM_FAULT_BADACCESS);
286 }
287 
288 static noinline void do_sigbus(struct pt_regs *regs)
289 {
290 	/*
291 	 * Send a sigbus, regardless of whether we were in kernel
292 	 * or user mode.
293 	 */
294 	force_sig_fault(SIGBUS, BUS_ADRERR,
295 			(void __user *)(regs->int_parm_long & __FAIL_ADDR_MASK));
296 }
297 
298 static noinline void do_fault_error(struct pt_regs *regs, vm_fault_t fault)
299 {
300 	int si_code;
301 
302 	switch (fault) {
303 	case VM_FAULT_BADACCESS:
304 	case VM_FAULT_BADMAP:
305 		/* Bad memory access. Check if it is kernel or user space. */
306 		if (user_mode(regs)) {
307 			/* User mode accesses just cause a SIGSEGV */
308 			si_code = (fault == VM_FAULT_BADMAP) ?
309 				SEGV_MAPERR : SEGV_ACCERR;
310 			do_sigsegv(regs, si_code);
311 			break;
312 		}
313 		fallthrough;
314 	case VM_FAULT_BADCONTEXT:
315 	case VM_FAULT_PFAULT:
316 		do_no_context(regs, fault);
317 		break;
318 	case VM_FAULT_SIGNAL:
319 		if (!user_mode(regs))
320 			do_no_context(regs, fault);
321 		break;
322 	default: /* fault & VM_FAULT_ERROR */
323 		if (fault & VM_FAULT_OOM) {
324 			if (!user_mode(regs))
325 				do_no_context(regs, fault);
326 			else
327 				pagefault_out_of_memory();
328 		} else if (fault & VM_FAULT_SIGSEGV) {
329 			/* Kernel mode? Handle exceptions or die */
330 			if (!user_mode(regs))
331 				do_no_context(regs, fault);
332 			else
333 				do_sigsegv(regs, SEGV_MAPERR);
334 		} else if (fault & VM_FAULT_SIGBUS) {
335 			/* Kernel mode? Handle exceptions or die */
336 			if (!user_mode(regs))
337 				do_no_context(regs, fault);
338 			else
339 				do_sigbus(regs);
340 		} else
341 			BUG();
342 		break;
343 	}
344 }
345 
346 /*
347  * This routine handles page faults.  It determines the address,
348  * and the problem, and then passes it off to one of the appropriate
349  * routines.
350  *
351  * interruption code (int_code):
352  *   04       Protection           ->  Write-Protection  (suppression)
353  *   10       Segment translation  ->  Not present       (nullification)
354  *   11       Page translation     ->  Not present       (nullification)
355  *   3b       Region third trans.  ->  Not present       (nullification)
356  */
357 static inline vm_fault_t do_exception(struct pt_regs *regs, int access)
358 {
359 	struct gmap *gmap;
360 	struct task_struct *tsk;
361 	struct mm_struct *mm;
362 	struct vm_area_struct *vma;
363 	enum fault_type type;
364 	unsigned long address;
365 	unsigned int flags;
366 	vm_fault_t fault;
367 	bool is_write;
368 
369 	tsk = current;
370 	/*
371 	 * The instruction that caused the program check has
372 	 * been nullified. Don't signal single step via SIGTRAP.
373 	 */
374 	clear_thread_flag(TIF_PER_TRAP);
375 
376 	if (kprobe_page_fault(regs, 14))
377 		return 0;
378 
379 	mm = tsk->mm;
380 	address = get_fault_address(regs);
381 	is_write = fault_is_write(regs);
382 
383 	/*
384 	 * Verify that the fault happened in user space, that
385 	 * we are not in an interrupt and that there is a
386 	 * user context.
387 	 */
388 	fault = VM_FAULT_BADCONTEXT;
389 	type = get_fault_type(regs);
390 	switch (type) {
391 	case KERNEL_FAULT:
392 		goto out;
393 	case USER_FAULT:
394 	case GMAP_FAULT:
395 		if (faulthandler_disabled() || !mm)
396 			goto out;
397 		break;
398 	}
399 
400 	perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);
401 	flags = FAULT_FLAG_DEFAULT;
402 	if (user_mode(regs))
403 		flags |= FAULT_FLAG_USER;
404 	if (is_write)
405 		access = VM_WRITE;
406 	if (access == VM_WRITE)
407 		flags |= FAULT_FLAG_WRITE;
408 	if (!(flags & FAULT_FLAG_USER))
409 		goto lock_mmap;
410 	vma = lock_vma_under_rcu(mm, address);
411 	if (!vma)
412 		goto lock_mmap;
413 	if (!(vma->vm_flags & access)) {
414 		vma_end_read(vma);
415 		goto lock_mmap;
416 	}
417 	fault = handle_mm_fault(vma, address, flags | FAULT_FLAG_VMA_LOCK, regs);
418 	if (!(fault & (VM_FAULT_RETRY | VM_FAULT_COMPLETED)))
419 		vma_end_read(vma);
420 	if (!(fault & VM_FAULT_RETRY)) {
421 		count_vm_vma_lock_event(VMA_LOCK_SUCCESS);
422 		if (likely(!(fault & VM_FAULT_ERROR)))
423 			fault = 0;
424 		goto out;
425 	}
426 	count_vm_vma_lock_event(VMA_LOCK_RETRY);
427 	/* Quick path to respond to signals */
428 	if (fault_signal_pending(fault, regs)) {
429 		fault = VM_FAULT_SIGNAL;
430 		goto out;
431 	}
432 lock_mmap:
433 	mmap_read_lock(mm);
434 
435 	gmap = NULL;
436 	if (IS_ENABLED(CONFIG_PGSTE) && type == GMAP_FAULT) {
437 		gmap = (struct gmap *) S390_lowcore.gmap;
438 		current->thread.gmap_addr = address;
439 		current->thread.gmap_write_flag = !!(flags & FAULT_FLAG_WRITE);
440 		current->thread.gmap_int_code = regs->int_code & 0xffff;
441 		address = __gmap_translate(gmap, address);
442 		if (address == -EFAULT) {
443 			fault = VM_FAULT_BADMAP;
444 			goto out_up;
445 		}
446 		if (gmap->pfault_enabled)
447 			flags |= FAULT_FLAG_RETRY_NOWAIT;
448 	}
449 
450 retry:
451 	fault = VM_FAULT_BADMAP;
452 	vma = find_vma(mm, address);
453 	if (!vma)
454 		goto out_up;
455 
456 	if (unlikely(vma->vm_start > address)) {
457 		if (!(vma->vm_flags & VM_GROWSDOWN))
458 			goto out_up;
459 		vma = expand_stack(mm, address);
460 		if (!vma)
461 			goto out;
462 	}
463 
464 	/*
465 	 * Ok, we have a good vm_area for this memory access, so
466 	 * we can handle it..
467 	 */
468 	fault = VM_FAULT_BADACCESS;
469 	if (unlikely(!(vma->vm_flags & access)))
470 		goto out_up;
471 
472 	/*
473 	 * If for any reason at all we couldn't handle the fault,
474 	 * make sure we exit gracefully rather than endlessly redo
475 	 * the fault.
476 	 */
477 	fault = handle_mm_fault(vma, address, flags, regs);
478 	if (fault_signal_pending(fault, regs)) {
479 		fault = VM_FAULT_SIGNAL;
480 		if (flags & FAULT_FLAG_RETRY_NOWAIT)
481 			goto out_up;
482 		goto out;
483 	}
484 
485 	/* The fault is fully completed (including releasing mmap lock) */
486 	if (fault & VM_FAULT_COMPLETED) {
487 		if (gmap) {
488 			mmap_read_lock(mm);
489 			goto out_gmap;
490 		}
491 		fault = 0;
492 		goto out;
493 	}
494 
495 	if (unlikely(fault & VM_FAULT_ERROR))
496 		goto out_up;
497 
498 	if (fault & VM_FAULT_RETRY) {
499 		if (IS_ENABLED(CONFIG_PGSTE) && gmap &&
500 			(flags & FAULT_FLAG_RETRY_NOWAIT)) {
501 			/*
502 			 * FAULT_FLAG_RETRY_NOWAIT has been set, mmap_lock has
503 			 * not been released
504 			 */
505 			current->thread.gmap_pfault = 1;
506 			fault = VM_FAULT_PFAULT;
507 			goto out_up;
508 		}
509 		flags &= ~FAULT_FLAG_RETRY_NOWAIT;
510 		flags |= FAULT_FLAG_TRIED;
511 		mmap_read_lock(mm);
512 		goto retry;
513 	}
514 out_gmap:
515 	if (IS_ENABLED(CONFIG_PGSTE) && gmap) {
516 		address =  __gmap_link(gmap, current->thread.gmap_addr,
517 				       address);
518 		if (address == -EFAULT) {
519 			fault = VM_FAULT_BADMAP;
520 			goto out_up;
521 		}
522 		if (address == -ENOMEM) {
523 			fault = VM_FAULT_OOM;
524 			goto out_up;
525 		}
526 	}
527 	fault = 0;
528 out_up:
529 	mmap_read_unlock(mm);
530 out:
531 	return fault;
532 }
533 
534 void do_protection_exception(struct pt_regs *regs)
535 {
536 	unsigned long trans_exc_code;
537 	int access;
538 	vm_fault_t fault;
539 
540 	trans_exc_code = regs->int_parm_long;
541 	/*
542 	 * Protection exceptions are suppressing, decrement psw address.
543 	 * The exception to this rule are aborted transactions, for these
544 	 * the PSW already points to the correct location.
545 	 */
546 	if (!(regs->int_code & 0x200))
547 		regs->psw.addr = __rewind_psw(regs->psw, regs->int_code >> 16);
548 	/*
549 	 * Check for low-address protection.  This needs to be treated
550 	 * as a special case because the translation exception code
551 	 * field is not guaranteed to contain valid data in this case.
552 	 */
553 	if (unlikely(!(trans_exc_code & 4))) {
554 		do_low_address(regs);
555 		return;
556 	}
557 	if (unlikely(MACHINE_HAS_NX && (trans_exc_code & 0x80))) {
558 		regs->int_parm_long = (trans_exc_code & ~PAGE_MASK) |
559 					(regs->psw.addr & PAGE_MASK);
560 		access = VM_EXEC;
561 		fault = VM_FAULT_BADACCESS;
562 	} else {
563 		access = VM_WRITE;
564 		fault = do_exception(regs, access);
565 	}
566 	if (unlikely(fault))
567 		do_fault_error(regs, fault);
568 }
569 NOKPROBE_SYMBOL(do_protection_exception);
570 
571 void do_dat_exception(struct pt_regs *regs)
572 {
573 	int access;
574 	vm_fault_t fault;
575 
576 	access = VM_ACCESS_FLAGS;
577 	fault = do_exception(regs, access);
578 	if (unlikely(fault))
579 		do_fault_error(regs, fault);
580 }
581 NOKPROBE_SYMBOL(do_dat_exception);
582 
583 #if IS_ENABLED(CONFIG_PGSTE)
584 
585 void do_secure_storage_access(struct pt_regs *regs)
586 {
587 	unsigned long addr = regs->int_parm_long & __FAIL_ADDR_MASK;
588 	struct vm_area_struct *vma;
589 	struct mm_struct *mm;
590 	struct page *page;
591 	struct gmap *gmap;
592 	int rc;
593 
594 	/*
595 	 * bit 61 tells us if the address is valid, if it's not we
596 	 * have a major problem and should stop the kernel or send a
597 	 * SIGSEGV to the process. Unfortunately bit 61 is not
598 	 * reliable without the misc UV feature so we need to check
599 	 * for that as well.
600 	 */
601 	if (test_bit_inv(BIT_UV_FEAT_MISC, &uv_info.uv_feature_indications) &&
602 	    !test_bit_inv(61, &regs->int_parm_long)) {
603 		/*
604 		 * When this happens, userspace did something that it
605 		 * was not supposed to do, e.g. branching into secure
606 		 * memory. Trigger a segmentation fault.
607 		 */
608 		if (user_mode(regs)) {
609 			send_sig(SIGSEGV, current, 0);
610 			return;
611 		}
612 
613 		/*
614 		 * The kernel should never run into this case and we
615 		 * have no way out of this situation.
616 		 */
617 		panic("Unexpected PGM 0x3d with TEID bit 61=0");
618 	}
619 
620 	switch (get_fault_type(regs)) {
621 	case GMAP_FAULT:
622 		mm = current->mm;
623 		gmap = (struct gmap *)S390_lowcore.gmap;
624 		mmap_read_lock(mm);
625 		addr = __gmap_translate(gmap, addr);
626 		mmap_read_unlock(mm);
627 		if (IS_ERR_VALUE(addr)) {
628 			do_fault_error(regs, VM_FAULT_BADMAP);
629 			break;
630 		}
631 		fallthrough;
632 	case USER_FAULT:
633 		mm = current->mm;
634 		mmap_read_lock(mm);
635 		vma = find_vma(mm, addr);
636 		if (!vma) {
637 			mmap_read_unlock(mm);
638 			do_fault_error(regs, VM_FAULT_BADMAP);
639 			break;
640 		}
641 		page = follow_page(vma, addr, FOLL_WRITE | FOLL_GET);
642 		if (IS_ERR_OR_NULL(page)) {
643 			mmap_read_unlock(mm);
644 			break;
645 		}
646 		if (arch_make_page_accessible(page))
647 			send_sig(SIGSEGV, current, 0);
648 		put_page(page);
649 		mmap_read_unlock(mm);
650 		break;
651 	case KERNEL_FAULT:
652 		page = phys_to_page(addr);
653 		if (unlikely(!try_get_page(page)))
654 			break;
655 		rc = arch_make_page_accessible(page);
656 		put_page(page);
657 		if (rc)
658 			BUG();
659 		break;
660 	default:
661 		do_fault_error(regs, VM_FAULT_BADMAP);
662 		WARN_ON_ONCE(1);
663 	}
664 }
665 NOKPROBE_SYMBOL(do_secure_storage_access);
666 
667 void do_non_secure_storage_access(struct pt_regs *regs)
668 {
669 	unsigned long gaddr = regs->int_parm_long & __FAIL_ADDR_MASK;
670 	struct gmap *gmap = (struct gmap *)S390_lowcore.gmap;
671 
672 	if (get_fault_type(regs) != GMAP_FAULT) {
673 		do_fault_error(regs, VM_FAULT_BADMAP);
674 		WARN_ON_ONCE(1);
675 		return;
676 	}
677 
678 	if (gmap_convert_to_secure(gmap, gaddr) == -EINVAL)
679 		send_sig(SIGSEGV, current, 0);
680 }
681 NOKPROBE_SYMBOL(do_non_secure_storage_access);
682 
683 void do_secure_storage_violation(struct pt_regs *regs)
684 {
685 	unsigned long gaddr = regs->int_parm_long & __FAIL_ADDR_MASK;
686 	struct gmap *gmap = (struct gmap *)S390_lowcore.gmap;
687 
688 	/*
689 	 * If the VM has been rebooted, its address space might still contain
690 	 * secure pages from the previous boot.
691 	 * Clear the page so it can be reused.
692 	 */
693 	if (!gmap_destroy_page(gmap, gaddr))
694 		return;
695 	/*
696 	 * Either KVM messed up the secure guest mapping or the same
697 	 * page is mapped into multiple secure guests.
698 	 *
699 	 * This exception is only triggered when a guest 2 is running
700 	 * and can therefore never occur in kernel context.
701 	 */
702 	printk_ratelimited(KERN_WARNING
703 			   "Secure storage violation in task: %s, pid %d\n",
704 			   current->comm, current->pid);
705 	send_sig(SIGSEGV, current, 0);
706 }
707 
708 #endif /* CONFIG_PGSTE */
709