blob: ca70fad2fc924d4999f8a2997491278cb01f4772 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * S390 version
Heiko Carstensa53c8fa2012-07-20 11:15:04 +02003 * Copyright IBM Corp. 1999
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * Author(s): Hartmut Penner (hp@de.ibm.com)
5 * Ulrich Weigand (uweigand@de.ibm.com)
6 *
7 * Derived from "arch/i386/mm/fault.c"
8 * Copyright (C) 1995 Linus Torvalds
9 */
10
Heiko Carstens052ff462011-01-05 12:47:28 +010011#include <linux/kernel_stat.h>
Ingo Molnarcdd6c482009-09-21 12:02:48 +020012#include <linux/perf_event.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/signal.h>
14#include <linux/sched.h>
15#include <linux/kernel.h>
16#include <linux/errno.h>
17#include <linux/string.h>
18#include <linux/types.h>
19#include <linux/ptrace.h>
20#include <linux/mman.h>
21#include <linux/mm.h>
Heiko Carstens77575912009-06-12 10:26:25 +020022#include <linux/compat.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/smp.h>
Christoph Hellwig1eeb66a2007-05-08 00:27:03 -070024#include <linux/kdebug.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/init.h>
26#include <linux/console.h>
27#include <linux/module.h>
28#include <linux/hardirq.h>
Michael Grundy4ba069b2006-09-20 15:58:39 +020029#include <linux/kprobes.h>
Martin Schwidefskybe5ec362007-04-27 16:01:44 +020030#include <linux/uaccess.h>
Gerald Schaefer53492b12008-04-30 13:38:46 +020031#include <linux/hugetlb.h>
Heiko Carstenscbb870c2010-02-26 22:37:43 +010032#include <asm/asm-offsets.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <asm/pgtable.h>
Heiko Carstensd7b250e2011-05-26 09:48:24 +020034#include <asm/irq.h>
Martin Schwidefsky6252d702008-02-09 18:24:37 +010035#include <asm/mmu_context.h>
David Howellsa0616cd2012-03-28 18:30:02 +010036#include <asm/facility.h>
Heiko Carstensa8061702008-04-17 07:46:26 +020037#include "../kernel/entry.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
Martin Schwidefsky347a8dc2006-01-06 00:19:28 -080039#ifndef CONFIG_64BIT
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#define __FAIL_ADDR_MASK 0x7ffff000
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#define __SUBCODE_MASK 0x0200
42#define __PF_RES_FIELD 0ULL
Martin Schwidefsky347a8dc2006-01-06 00:19:28 -080043#else /* CONFIG_64BIT */
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#define __FAIL_ADDR_MASK -4096L
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#define __SUBCODE_MASK 0x0600
46#define __PF_RES_FIELD 0x8000000000000000ULL
Martin Schwidefsky347a8dc2006-01-06 00:19:28 -080047#endif /* CONFIG_64BIT */
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Martin Schwidefsky50d72802009-12-07 12:51:45 +010049#define VM_FAULT_BADCONTEXT 0x010000
50#define VM_FAULT_BADMAP 0x020000
51#define VM_FAULT_BADACCESS 0x040000
Heiko Carstensa4f32bd2012-10-30 14:49:37 +010052#define VM_FAULT_SIGNAL 0x080000
Dominik Dingel24eb3a82013-06-17 16:25:18 +020053#define VM_FAULT_PFAULT 0x100000
Martin Schwidefsky50d72802009-12-07 12:51:45 +010054
Heiko Carstensa4f32bd2012-10-30 14:49:37 +010055static unsigned long store_indication __read_mostly;
Martin Schwidefsky92f842e2010-10-25 16:10:13 +020056
Heiko Carstensa4f32bd2012-10-30 14:49:37 +010057#ifdef CONFIG_64BIT
58static int __init fault_init(void)
Martin Schwidefsky92f842e2010-10-25 16:10:13 +020059{
Heiko Carstensa4f32bd2012-10-30 14:49:37 +010060 if (test_facility(75))
Martin Schwidefsky92f842e2010-10-25 16:10:13 +020061 store_indication = 0xc00;
Heiko Carstensa4f32bd2012-10-30 14:49:37 +010062 return 0;
Martin Schwidefsky92f842e2010-10-25 16:10:13 +020063}
Heiko Carstensa4f32bd2012-10-30 14:49:37 +010064early_initcall(fault_init);
65#endif
Martin Schwidefsky92f842e2010-10-25 16:10:13 +020066
Martin Schwidefsky7ecb3442009-12-07 12:51:44 +010067static inline int notify_page_fault(struct pt_regs *regs)
Martin Schwidefsky10c10312007-04-27 16:01:43 +020068{
Christoph Hellwig33464e32007-05-04 18:47:46 +020069 int ret = 0;
70
71 /* kprobe_running() needs smp_processor_id() */
Heiko Carstens22e0a042010-02-26 22:37:45 +010072 if (kprobes_built_in() && !user_mode(regs)) {
Christoph Hellwig33464e32007-05-04 18:47:46 +020073 preempt_disable();
74 if (kprobe_running() && kprobe_fault_handler(regs, 14))
75 ret = 1;
76 preempt_enable();
77 }
Christoph Hellwig33464e32007-05-04 18:47:46 +020078 return ret;
Michael Grundy4ba069b2006-09-20 15:58:39 +020079}
Michael Grundy4ba069b2006-09-20 15:58:39 +020080
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
82/*
83 * Unlock any spinlocks which will prevent us from getting the
Kirill Korotaevcefc8be2007-02-10 01:46:18 -080084 * message out.
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 */
86void bust_spinlocks(int yes)
87{
88 if (yes) {
89 oops_in_progress = 1;
90 } else {
91 int loglevel_save = console_loglevel;
92 console_unblank();
93 oops_in_progress = 0;
94 /*
95 * OK, the message is on the console. Now we call printk()
96 * without oops_in_progress set so that printk will give klogd
97 * a poke. Hold onto your hats...
98 */
99 console_loglevel = 15;
100 printk(" ");
101 console_loglevel = loglevel_save;
102 }
103}
104
105/*
Gerald Schaefer482b05d2007-03-05 23:35:54 +0100106 * Returns the address space associated with the fault.
Martin Schwidefsky61365e12009-12-07 12:51:42 +0100107 * Returns 0 for kernel space and 1 for user space.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 */
Heiko Carstens457f2182014-03-21 10:42:25 +0100109static inline int user_space_fault(struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110{
Heiko Carstens457f2182014-03-21 10:42:25 +0100111 unsigned long trans_exc_code;
112
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 /*
Martin Schwidefsky61365e12009-12-07 12:51:42 +0100114 * The lowest two bits of the translation exception
115 * identification indicate which paging table was used.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 */
Heiko Carstens457f2182014-03-21 10:42:25 +0100117 trans_exc_code = regs->int_parm_long & 3;
118 if (trans_exc_code == 3) /* home space -> kernel */
119 return 0;
120 if (user_mode(regs))
121 return 1;
122 if (trans_exc_code == 2) /* secondary space -> set_fs */
Martin Schwidefsky61365e12009-12-07 12:51:42 +0100123 return current->thread.mm_segment.ar4;
Heiko Carstens457f2182014-03-21 10:42:25 +0100124 if (current->flags & PF_VCPU)
125 return 1;
126 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127}
128
Heiko Carstens3b7df342014-04-07 10:20:40 +0200129static int bad_address(void *p)
130{
131 unsigned long dummy;
132
133 return probe_kernel_address((unsigned long *)p, dummy);
134}
135
136#ifdef CONFIG_64BIT
137static void dump_pagetable(unsigned long asce, unsigned long address)
138{
139 unsigned long *table = __va(asce & PAGE_MASK);
140
141 pr_alert("AS:%016lx ", asce);
142 switch (asce & _ASCE_TYPE_MASK) {
143 case _ASCE_TYPE_REGION1:
144 table = table + ((address >> 53) & 0x7ff);
145 if (bad_address(table))
146 goto bad;
147 pr_cont("R1:%016lx ", *table);
148 if (*table & _REGION_ENTRY_INVALID)
149 goto out;
150 table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
151 /* fallthrough */
152 case _ASCE_TYPE_REGION2:
153 table = table + ((address >> 42) & 0x7ff);
154 if (bad_address(table))
155 goto bad;
156 pr_cont("R2:%016lx ", *table);
157 if (*table & _REGION_ENTRY_INVALID)
158 goto out;
159 table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
160 /* fallthrough */
161 case _ASCE_TYPE_REGION3:
162 table = table + ((address >> 31) & 0x7ff);
163 if (bad_address(table))
164 goto bad;
165 pr_cont("R3:%016lx ", *table);
166 if (*table & (_REGION_ENTRY_INVALID | _REGION3_ENTRY_LARGE))
167 goto out;
168 table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
169 /* fallthrough */
170 case _ASCE_TYPE_SEGMENT:
171 table = table + ((address >> 20) & 0x7ff);
172 if (bad_address(table))
173 goto bad;
174 pr_cont(KERN_CONT "S:%016lx ", *table);
175 if (*table & (_SEGMENT_ENTRY_INVALID | _SEGMENT_ENTRY_LARGE))
176 goto out;
177 table = (unsigned long *)(*table & _SEGMENT_ENTRY_ORIGIN);
178 }
179 table = table + ((address >> 12) & 0xff);
180 if (bad_address(table))
181 goto bad;
182 pr_cont("P:%016lx ", *table);
183out:
184 pr_cont("\n");
185 return;
186bad:
187 pr_cont("BAD\n");
188}
189
190#else /* CONFIG_64BIT */
191
192static void dump_pagetable(unsigned long asce, unsigned long address)
193{
194 unsigned long *table = __va(asce & PAGE_MASK);
195
196 pr_alert("AS:%08lx ", asce);
197 table = table + ((address >> 20) & 0x7ff);
198 if (bad_address(table))
199 goto bad;
200 pr_cont("S:%08lx ", *table);
201 if (*table & _SEGMENT_ENTRY_INVALID)
202 goto out;
203 table = (unsigned long *)(*table & _SEGMENT_ENTRY_ORIGIN);
204 table = table + ((address >> 12) & 0xff);
205 if (bad_address(table))
206 goto bad;
207 pr_cont("P:%08lx ", *table);
208out:
209 pr_cont("\n");
210 return;
211bad:
212 pr_cont("BAD\n");
213}
214
215#endif /* CONFIG_64BIT */
216
217static void dump_fault_info(struct pt_regs *regs)
218{
219 unsigned long asce;
220
221 pr_alert("Fault in ");
222 switch (regs->int_parm_long & 3) {
223 case 3:
224 pr_cont("home space ");
225 break;
226 case 2:
227 pr_cont("secondary space ");
228 break;
229 case 1:
230 pr_cont("access register ");
231 break;
232 case 0:
233 pr_cont("primary space ");
234 break;
235 }
236 pr_cont("mode while using ");
237 if (!user_space_fault(regs)) {
238 asce = S390_lowcore.kernel_asce;
239 pr_cont("kernel ");
240 }
241#ifdef CONFIG_PGSTE
242 else if ((current->flags & PF_VCPU) && S390_lowcore.gmap) {
243 struct gmap *gmap = (struct gmap *)S390_lowcore.gmap;
244 asce = gmap->asce;
245 pr_cont("gmap ");
246 }
247#endif
248 else {
249 asce = S390_lowcore.user_asce;
250 pr_cont("user ");
251 }
252 pr_cont("ASCE.\n");
253 dump_pagetable(asce, regs->int_parm_long & __FAIL_ADDR_MASK);
254}
255
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100256static inline void report_user_fault(struct pt_regs *regs, long signr)
Heiko Carstensab3c68e2010-05-17 10:00:21 +0200257{
258 if ((task_pid_nr(current) > 1) && !show_unhandled_signals)
259 return;
260 if (!unhandled_signal(current, signr))
261 return;
262 if (!printk_ratelimit())
263 return;
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100264 printk(KERN_ALERT "User process fault: interruption code 0x%X ",
265 regs->int_code);
Heiko Carstensab3c68e2010-05-17 10:00:21 +0200266 print_vma_addr(KERN_CONT "in ", regs->psw.addr & PSW_ADDR_INSN);
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100267 printk(KERN_CONT "\n");
Heiko Carstens3b7df342014-04-07 10:20:40 +0200268 printk(KERN_ALERT "failing address: %016lx TEID: %016lx\n",
269 regs->int_parm_long & __FAIL_ADDR_MASK, regs->int_parm_long);
270 dump_fault_info(regs);
Heiko Carstensab3c68e2010-05-17 10:00:21 +0200271 show_regs(regs);
272}
273
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274/*
275 * Send SIGSEGV to task. This is an external routine
276 * to keep the stack usage of do_page_fault small.
277 */
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100278static noinline void do_sigsegv(struct pt_regs *regs, int si_code)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279{
280 struct siginfo si;
281
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100282 report_user_fault(regs, SIGSEGV);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 si.si_signo = SIGSEGV;
284 si.si_code = si_code;
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100285 si.si_addr = (void __user *)(regs->int_parm_long & __FAIL_ADDR_MASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 force_sig_info(SIGSEGV, &si, current);
287}
288
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100289static noinline void do_no_context(struct pt_regs *regs)
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200290{
291 const struct exception_table_entry *fixup;
Martin Schwidefsky61365e12009-12-07 12:51:42 +0100292 unsigned long address;
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200293
294 /* Are we prepared to handle this kernel fault? */
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100295 fixup = search_exception_tables(regs->psw.addr & PSW_ADDR_INSN);
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200296 if (fixup) {
Heiko Carstenseb608fb2012-09-05 13:26:11 +0200297 regs->psw.addr = extable_fixup(fixup) | PSW_ADDR_AMODE;
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200298 return;
299 }
300
301 /*
302 * Oops. The kernel tried to access some bad page. We'll have to
303 * terminate things with extreme prejudice.
304 */
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100305 address = regs->int_parm_long & __FAIL_ADDR_MASK;
Heiko Carstens457f2182014-03-21 10:42:25 +0100306 if (!user_space_fault(regs))
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200307 printk(KERN_ALERT "Unable to handle kernel pointer dereference"
Heiko Carstens3b7df342014-04-07 10:20:40 +0200308 " in virtual kernel address space\n");
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200309 else
310 printk(KERN_ALERT "Unable to handle kernel paging request"
Heiko Carstens3b7df342014-04-07 10:20:40 +0200311 " in virtual user address space\n");
312 printk(KERN_ALERT "failing address: %016lx TEID: %016lx\n",
313 regs->int_parm_long & __FAIL_ADDR_MASK, regs->int_parm_long);
314 dump_fault_info(regs);
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100315 die(regs, "Oops");
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200316 do_exit(SIGKILL);
317}
318
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100319static noinline void do_low_address(struct pt_regs *regs)
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200320{
321 /* Low-address protection hit in kernel mode means
322 NULL pointer write access in kernel mode. */
323 if (regs->psw.mask & PSW_MASK_PSTATE) {
324 /* Low-address protection hit in user mode 'cannot happen'. */
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100325 die (regs, "Low-address protection");
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200326 do_exit(SIGKILL);
327 }
328
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100329 do_no_context(regs);
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200330}
331
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100332static noinline void do_sigbus(struct pt_regs *regs)
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200333{
334 struct task_struct *tsk = current;
Martin Schwidefsky36bf9682010-10-25 16:10:35 +0200335 struct siginfo si;
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200336
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200337 /*
338 * Send a sigbus, regardless of whether we were in kernel
339 * or user mode.
340 */
Martin Schwidefsky36bf9682010-10-25 16:10:35 +0200341 si.si_signo = SIGBUS;
342 si.si_errno = 0;
343 si.si_code = BUS_ADRERR;
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100344 si.si_addr = (void __user *)(regs->int_parm_long & __FAIL_ADDR_MASK);
Martin Schwidefsky36bf9682010-10-25 16:10:35 +0200345 force_sig_info(SIGBUS, &si, tsk);
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200346}
347
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100348static noinline void do_fault_error(struct pt_regs *regs, int fault)
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100349{
350 int si_code;
351
352 switch (fault) {
353 case VM_FAULT_BADACCESS:
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100354 case VM_FAULT_BADMAP:
355 /* Bad memory access. Check if it is kernel or user space. */
Heiko Carstens7d256172012-07-27 10:31:12 +0200356 if (user_mode(regs)) {
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100357 /* User mode accesses just cause a SIGSEGV */
358 si_code = (fault == VM_FAULT_BADMAP) ?
359 SEGV_MAPERR : SEGV_ACCERR;
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100360 do_sigsegv(regs, si_code);
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100361 return;
362 }
363 case VM_FAULT_BADCONTEXT:
Dominik Dingel24eb3a82013-06-17 16:25:18 +0200364 case VM_FAULT_PFAULT:
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100365 do_no_context(regs);
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100366 break;
Heiko Carstensf2c76e32012-07-27 08:54:20 +0200367 case VM_FAULT_SIGNAL:
368 if (!user_mode(regs))
369 do_no_context(regs);
370 break;
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100371 default: /* fault & VM_FAULT_ERROR */
Heiko Carstens99583182011-05-26 09:48:29 +0200372 if (fault & VM_FAULT_OOM) {
Heiko Carstens7d256172012-07-27 10:31:12 +0200373 if (!user_mode(regs))
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100374 do_no_context(regs);
Heiko Carstens99583182011-05-26 09:48:29 +0200375 else
376 pagefault_out_of_memory();
377 } else if (fault & VM_FAULT_SIGBUS) {
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100378 /* Kernel mode? Handle exceptions or die */
Heiko Carstens7d256172012-07-27 10:31:12 +0200379 if (!user_mode(regs))
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100380 do_no_context(regs);
Martin Schwidefsky36bf9682010-10-25 16:10:35 +0200381 else
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100382 do_sigbus(regs);
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100383 } else
384 BUG();
385 break;
386 }
387}
388
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389/*
390 * This routine handles page faults. It determines the address,
391 * and the problem, and then passes it off to one of the appropriate
392 * routines.
393 *
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100394 * interruption code (int_code):
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 * 04 Protection -> Write-Protection (suprression)
396 * 10 Segment translation -> Not present (nullification)
397 * 11 Page translation -> Not present (nullification)
398 * 3b Region third trans. -> Not present (nullification)
399 */
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100400static inline int do_exception(struct pt_regs *regs, int access)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401{
Dominik Dingel24eb3a82013-06-17 16:25:18 +0200402#ifdef CONFIG_PGSTE
403 struct gmap *gmap;
404#endif
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200405 struct task_struct *tsk;
406 struct mm_struct *mm;
407 struct vm_area_struct *vma;
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100408 unsigned long trans_exc_code;
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200409 unsigned long address;
Heiko Carstens33ce6142011-05-26 09:48:30 +0200410 unsigned int flags;
411 int fault;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
Martin Schwidefsky39efd4e2012-11-21 16:36:27 +0100413 tsk = current;
414 /*
415 * The instruction that caused the program check has
416 * been nullified. Don't signal single step via SIGTRAP.
417 */
Martin Schwidefskyd3a73ac2014-04-15 12:55:07 +0200418 clear_pt_regs_flag(regs, PIF_PER_TRAP);
Martin Schwidefsky39efd4e2012-11-21 16:36:27 +0100419
Martin Schwidefsky7ecb3442009-12-07 12:51:44 +0100420 if (notify_page_fault(regs))
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100421 return 0;
Michael Grundy4ba069b2006-09-20 15:58:39 +0200422
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200423 mm = tsk->mm;
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100424 trans_exc_code = regs->int_parm_long;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 /*
427 * Verify that the fault happened in user space, that
428 * we are not in an interrupt and that there is a
429 * user context.
430 */
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100431 fault = VM_FAULT_BADCONTEXT;
Heiko Carstens457f2182014-03-21 10:42:25 +0100432 if (unlikely(!user_space_fault(regs) || in_atomic() || !mm))
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100433 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
Martin Schwidefsky61365e12009-12-07 12:51:42 +0100435 address = trans_exc_code & __FAIL_ADDR_MASK;
Peter Zijlstraa8b0ca12011-06-27 14:41:57 +0200436 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);
Heiko Carstensf2c76e32012-07-27 08:54:20 +0200437 flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
Johannes Weiner759496b2013-09-12 15:13:39 -0700438 if (user_mode(regs))
439 flags |= FAULT_FLAG_USER;
Heiko Carstens33ce6142011-05-26 09:48:30 +0200440 if (access == VM_WRITE || (trans_exc_code & store_indication) == 0x400)
441 flags |= FAULT_FLAG_WRITE;
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200442 down_read(&mm->mmap_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443
Martin Schwidefskye5992f22011-07-24 10:48:20 +0200444#ifdef CONFIG_PGSTE
Martin Schwidefsky527e30b2014-04-30 16:04:25 +0200445 gmap = (current->flags & PF_VCPU) ?
446 (struct gmap *) S390_lowcore.gmap : NULL;
Dominik Dingel24eb3a82013-06-17 16:25:18 +0200447 if (gmap) {
Martin Schwidefsky527e30b2014-04-30 16:04:25 +0200448 current->thread.gmap_addr = address;
449 address = __gmap_translate(gmap, address);
Martin Schwidefskye5992f22011-07-24 10:48:20 +0200450 if (address == -EFAULT) {
451 fault = VM_FAULT_BADMAP;
452 goto out_up;
453 }
Dominik Dingel24eb3a82013-06-17 16:25:18 +0200454 if (gmap->pfault_enabled)
455 flags |= FAULT_FLAG_RETRY_NOWAIT;
Martin Schwidefskye5992f22011-07-24 10:48:20 +0200456 }
457#endif
458
459retry:
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100460 fault = VM_FAULT_BADMAP;
Gerald Schaefer482b05d2007-03-05 23:35:54 +0100461 vma = find_vma(mm, address);
462 if (!vma)
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100463 goto out_up;
Gerald Schaeferc1821c22007-02-05 21:18:17 +0100464
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100465 if (unlikely(vma->vm_start > address)) {
466 if (!(vma->vm_flags & VM_GROWSDOWN))
467 goto out_up;
468 if (expand_stack(vma, address))
469 goto out_up;
470 }
471
472 /*
473 * Ok, we have a good vm_area for this memory access, so
474 * we can handle it..
475 */
476 fault = VM_FAULT_BADACCESS;
Martin Schwidefsky1ab947d2009-12-07 12:51:46 +0100477 if (unlikely(!(vma->vm_flags & access)))
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100478 goto out_up;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479
Gerald Schaefer53492b12008-04-30 13:38:46 +0200480 if (is_vm_hugetlb_page(vma))
481 address &= HPAGE_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 /*
483 * If for any reason at all we couldn't handle the fault,
484 * make sure we exit gracefully rather than endlessly redo
485 * the fault.
486 */
Heiko Carstens33ce6142011-05-26 09:48:30 +0200487 fault = handle_mm_fault(mm, vma, address, flags);
Heiko Carstensf2c76e32012-07-27 08:54:20 +0200488 /* No reason to continue if interrupted by SIGKILL. */
489 if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current)) {
490 fault = VM_FAULT_SIGNAL;
491 goto out;
492 }
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100493 if (unlikely(fault & VM_FAULT_ERROR))
494 goto out_up;
495
Heiko Carstens33ce6142011-05-26 09:48:30 +0200496 /*
497 * Major/minor page fault accounting is only done on the
498 * initial attempt. If we go through a retry, it is extremely
499 * likely that the page will be found in page cache at that point.
500 */
501 if (flags & FAULT_FLAG_ALLOW_RETRY) {
502 if (fault & VM_FAULT_MAJOR) {
503 tsk->maj_flt++;
Peter Zijlstraa8b0ca12011-06-27 14:41:57 +0200504 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1,
Heiko Carstens33ce6142011-05-26 09:48:30 +0200505 regs, address);
506 } else {
507 tsk->min_flt++;
Peter Zijlstraa8b0ca12011-06-27 14:41:57 +0200508 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1,
Heiko Carstens33ce6142011-05-26 09:48:30 +0200509 regs, address);
510 }
511 if (fault & VM_FAULT_RETRY) {
Dominik Dingel24eb3a82013-06-17 16:25:18 +0200512#ifdef CONFIG_PGSTE
513 if (gmap && (flags & FAULT_FLAG_RETRY_NOWAIT)) {
514 /* FAULT_FLAG_RETRY_NOWAIT has been set,
515 * mmap_sem has not been released */
516 current->thread.gmap_pfault = 1;
517 fault = VM_FAULT_PFAULT;
518 goto out_up;
519 }
520#endif
Heiko Carstens33ce6142011-05-26 09:48:30 +0200521 /* Clear FAULT_FLAG_ALLOW_RETRY to avoid any risk
522 * of starvation. */
Dominik Dingel24eb3a82013-06-17 16:25:18 +0200523 flags &= ~(FAULT_FLAG_ALLOW_RETRY |
524 FAULT_FLAG_RETRY_NOWAIT);
Shaohua Li45cac652012-10-08 16:32:19 -0700525 flags |= FAULT_FLAG_TRIED;
Martin Schwidefskye5992f22011-07-24 10:48:20 +0200526 down_read(&mm->mmap_sem);
Heiko Carstens33ce6142011-05-26 09:48:30 +0200527 goto retry;
528 }
Heiko Carstensbde69af2009-09-11 10:29:06 +0200529 }
Martin Schwidefsky527e30b2014-04-30 16:04:25 +0200530#ifdef CONFIG_PGSTE
531 if (gmap) {
532 address = __gmap_link(gmap, current->thread.gmap_addr,
533 address);
534 if (address == -EFAULT) {
535 fault = VM_FAULT_BADMAP;
536 goto out_up;
537 }
538 if (address == -ENOMEM) {
539 fault = VM_FAULT_OOM;
540 goto out_up;
541 }
542 }
543#endif
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100544 fault = 0;
545out_up:
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200546 up_read(&mm->mmap_sem);
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100547out:
548 return fault;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549}
550
Heiko Carstens7a5388d2014-10-22 12:42:38 +0200551void do_protection_exception(struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552{
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100553 unsigned long trans_exc_code;
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100554 int fault;
Martin Schwidefsky61365e12009-12-07 12:51:42 +0100555
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100556 trans_exc_code = regs->int_parm_long;
Martin Schwidefskyf752ac42013-04-16 13:25:06 +0200557 /*
558 * Protection exceptions are suppressing, decrement psw address.
559 * The exception to this rule are aborted transactions, for these
560 * the PSW already points to the correct location.
561 */
562 if (!(regs->int_code & 0x200))
563 regs->psw.addr = __rewind_psw(regs->psw, regs->int_code >> 16);
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200564 /*
565 * Check for low-address protection. This needs to be treated
566 * as a special case because the translation exception code
567 * field is not guaranteed to contain valid data in this case.
568 */
Martin Schwidefsky61365e12009-12-07 12:51:42 +0100569 if (unlikely(!(trans_exc_code & 4))) {
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100570 do_low_address(regs);
Martin Schwidefsky10c10312007-04-27 16:01:43 +0200571 return;
572 }
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100573 fault = do_exception(regs, VM_WRITE);
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100574 if (unlikely(fault))
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100575 do_fault_error(regs, fault);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576}
Heiko Carstens7a5388d2014-10-22 12:42:38 +0200577NOKPROBE_SYMBOL(do_protection_exception);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578
Heiko Carstens7a5388d2014-10-22 12:42:38 +0200579void do_dat_exception(struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580{
Martin Schwidefsky1ab947d2009-12-07 12:51:46 +0100581 int access, fault;
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100582
Martin Schwidefsky1ab947d2009-12-07 12:51:46 +0100583 access = VM_READ | VM_EXEC | VM_WRITE;
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100584 fault = do_exception(regs, access);
Martin Schwidefsky50d72802009-12-07 12:51:45 +0100585 if (unlikely(fault))
Martin Schwidefskyaa33c8c2011-12-27 11:27:18 +0100586 do_fault_error(regs, fault);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587}
Heiko Carstens7a5388d2014-10-22 12:42:38 +0200588NOKPROBE_SYMBOL(do_dat_exception);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590#ifdef CONFIG_PFAULT
591/*
592 * 'pfault' pseudo page faults routines.
593 */
Heiko Carstensfb0a9d72011-01-05 12:47:39 +0100594static int pfault_disable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
596static int __init nopfault(char *str)
597{
598 pfault_disable = 1;
599 return 1;
600}
601
602__setup("nopfault", nopfault);
603
Heiko Carstens7dd8fe12011-05-23 10:24:35 +0200604struct pfault_refbk {
605 u16 refdiagc;
606 u16 reffcode;
607 u16 refdwlen;
608 u16 refversn;
609 u64 refgaddr;
610 u64 refselmk;
611 u64 refcmpmk;
612 u64 reserved;
613} __attribute__ ((packed, aligned(8)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
615int pfault_init(void)
616{
Heiko Carstens7dd8fe12011-05-23 10:24:35 +0200617 struct pfault_refbk refbk = {
618 .refdiagc = 0x258,
619 .reffcode = 0,
620 .refdwlen = 5,
621 .refversn = 2,
622 .refgaddr = __LC_CURRENT_PID,
623 .refselmk = 1ULL << 48,
624 .refcmpmk = 1ULL << 48,
625 .reserved = __PF_RES_FIELD };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 int rc;
627
Carsten Ottef32269a2011-12-27 11:27:11 +0100628 if (pfault_disable)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 return -1;
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200630 asm volatile(
631 " diag %1,%0,0x258\n"
632 "0: j 2f\n"
633 "1: la %0,8\n"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 "2:\n"
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200635 EX_TABLE(0b,1b)
636 : "=d" (rc) : "a" (&refbk), "m" (refbk) : "cc");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 return rc;
638}
639
640void pfault_fini(void)
641{
Heiko Carstens7dd8fe12011-05-23 10:24:35 +0200642 struct pfault_refbk refbk = {
643 .refdiagc = 0x258,
644 .reffcode = 1,
645 .refdwlen = 5,
646 .refversn = 2,
647 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648
Carsten Ottef32269a2011-12-27 11:27:11 +0100649 if (pfault_disable)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 return;
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200651 asm volatile(
652 " diag %0,0,0x258\n"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 "0:\n"
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200654 EX_TABLE(0b,0b)
655 : : "a" (&refbk), "m" (refbk) : "cc");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656}
657
Heiko Carstensf2db2e62011-05-23 10:24:34 +0200658static DEFINE_SPINLOCK(pfault_lock);
659static LIST_HEAD(pfault_list);
660
Heiko Carstensfde15c32012-03-11 11:59:31 -0400661static void pfault_interrupt(struct ext_code ext_code,
Martin Schwidefskyf6649a72010-10-25 16:10:38 +0200662 unsigned int param32, unsigned long param64)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663{
664 struct task_struct *tsk;
665 __u16 subcode;
Heiko Carstensf2db2e62011-05-23 10:24:34 +0200666 pid_t pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667
668 /*
669 * Get the external interruption subcode & pfault
670 * initial/completion signal bit. VM stores this
671 * in the 'cpu address' field associated with the
672 * external interrupt.
673 */
Heiko Carstensfde15c32012-03-11 11:59:31 -0400674 subcode = ext_code.subcode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 if ((subcode & 0xff00) != __SUBCODE_MASK)
676 return;
Heiko Carstens420f42e2013-01-02 15:18:18 +0100677 inc_irq_stat(IRQEXT_PFL);
Heiko Carstens54c27792012-05-10 09:44:35 +0200678 /* Get the token (= pid of the affected task). */
679 pid = sizeof(void *) == 4 ? param32 : param64;
680 rcu_read_lock();
681 tsk = find_task_by_pid_ns(pid, &init_pid_ns);
682 if (tsk)
683 get_task_struct(tsk);
684 rcu_read_unlock();
685 if (!tsk)
686 return;
Heiko Carstensf2db2e62011-05-23 10:24:34 +0200687 spin_lock(&pfault_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 if (subcode & 0x0080) {
689 /* signal bit is set -> a page has been swapped in by VM */
Heiko Carstensf2db2e62011-05-23 10:24:34 +0200690 if (tsk->thread.pfault_wait == 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 /* Initial interrupt was faster than the completion
692 * interrupt. pfault_wait is valid. Set pfault_wait
693 * back to zero and wake up the process. This can
694 * safely be done because the task is still sleeping
Martin Schwidefskyb6d09442005-09-03 15:58:02 -0700695 * and can't produce new pfaults. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 tsk->thread.pfault_wait = 0;
Heiko Carstensf2db2e62011-05-23 10:24:34 +0200697 list_del(&tsk->thread.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 wake_up_process(tsk);
Heiko Carstensd5e50a52012-05-09 09:37:30 +0200699 put_task_struct(tsk);
Heiko Carstensf2db2e62011-05-23 10:24:34 +0200700 } else {
701 /* Completion interrupt was faster than initial
702 * interrupt. Set pfault_wait to -1 so the initial
Heiko Carstensfa2fb2f2011-11-14 11:19:01 +0100703 * interrupt doesn't put the task to sleep.
704 * If the task is not running, ignore the completion
705 * interrupt since it must be a leftover of a PFAULT
706 * CANCEL operation which didn't remove all pending
707 * completion interrupts. */
708 if (tsk->state == TASK_RUNNING)
709 tsk->thread.pfault_wait = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 }
711 } else {
712 /* signal bit not set -> a real page is missing. */
Heiko Carstensd49f47f2012-05-10 10:47:21 +0200713 if (WARN_ON_ONCE(tsk != current))
714 goto out;
Heiko Carstensd5e50a52012-05-09 09:37:30 +0200715 if (tsk->thread.pfault_wait == 1) {
716 /* Already on the list with a reference: put to sleep */
Heiko Carstens0a16ba72012-05-10 09:56:34 +0200717 __set_task_state(tsk, TASK_UNINTERRUPTIBLE);
Heiko Carstensd5e50a52012-05-09 09:37:30 +0200718 set_tsk_need_resched(tsk);
719 } else if (tsk->thread.pfault_wait == -1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 /* Completion interrupt was faster than the initial
Heiko Carstensf2db2e62011-05-23 10:24:34 +0200721 * interrupt (pfault_wait == -1). Set pfault_wait
722 * back to zero and exit. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 tsk->thread.pfault_wait = 0;
Heiko Carstensf2db2e62011-05-23 10:24:34 +0200724 } else {
725 /* Initial interrupt arrived before completion
Heiko Carstensd5e50a52012-05-09 09:37:30 +0200726 * interrupt. Let the task sleep.
727 * An extra task reference is needed since a different
728 * cpu may set the task state to TASK_RUNNING again
729 * before the scheduler is reached. */
730 get_task_struct(tsk);
Heiko Carstensf2db2e62011-05-23 10:24:34 +0200731 tsk->thread.pfault_wait = 1;
732 list_add(&tsk->thread.list, &pfault_list);
Heiko Carstens0a16ba72012-05-10 09:56:34 +0200733 __set_task_state(tsk, TASK_UNINTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 set_tsk_need_resched(tsk);
Heiko Carstensf2db2e62011-05-23 10:24:34 +0200735 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 }
Heiko Carstensd49f47f2012-05-10 10:47:21 +0200737out:
Heiko Carstensf2db2e62011-05-23 10:24:34 +0200738 spin_unlock(&pfault_lock);
Heiko Carstens54c27792012-05-10 09:44:35 +0200739 put_task_struct(tsk);
Heiko Carstensf2db2e62011-05-23 10:24:34 +0200740}
741
Paul Gortmakere2741f12013-06-18 17:04:52 -0400742static int pfault_cpu_notify(struct notifier_block *self, unsigned long action,
743 void *hcpu)
Heiko Carstensf2db2e62011-05-23 10:24:34 +0200744{
745 struct thread_struct *thread, *next;
746 struct task_struct *tsk;
747
Heiko Carstens1c725922012-08-27 15:43:49 +0200748 switch (action & ~CPU_TASKS_FROZEN) {
Heiko Carstensf2db2e62011-05-23 10:24:34 +0200749 case CPU_DEAD:
Heiko Carstensf2db2e62011-05-23 10:24:34 +0200750 spin_lock_irq(&pfault_lock);
751 list_for_each_entry_safe(thread, next, &pfault_list, list) {
752 thread->pfault_wait = 0;
753 list_del(&thread->list);
754 tsk = container_of(thread, struct task_struct, thread);
755 wake_up_process(tsk);
Heiko Carstensd5e50a52012-05-09 09:37:30 +0200756 put_task_struct(tsk);
Heiko Carstensf2db2e62011-05-23 10:24:34 +0200757 }
758 spin_unlock_irq(&pfault_lock);
759 break;
760 default:
761 break;
762 }
763 return NOTIFY_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
Heiko Carstensfb0a9d72011-01-05 12:47:39 +0100766static int __init pfault_irq_init(void)
Heiko Carstens29b08d22006-12-04 15:40:40 +0100767{
Heiko Carstensfb0a9d72011-01-05 12:47:39 +0100768 int rc;
Heiko Carstens29b08d22006-12-04 15:40:40 +0100769
Thomas Huth1dad0932014-03-31 15:24:08 +0200770 rc = register_external_irq(EXT_IRQ_CP_SERVICE, pfault_interrupt);
Heiko Carstens7dd8fe12011-05-23 10:24:35 +0200771 if (rc)
772 goto out_extint;
773 rc = pfault_init() == 0 ? 0 : -EOPNOTSUPP;
774 if (rc)
775 goto out_pfault;
Heiko Carstens82003c32013-09-04 13:35:45 +0200776 irq_subclass_register(IRQ_SUBCLASS_SERVICE_SIGNAL);
Heiko Carstens7dd8fe12011-05-23 10:24:35 +0200777 hotcpu_notifier(pfault_cpu_notify, 0);
Heiko Carstensfb0a9d72011-01-05 12:47:39 +0100778 return 0;
Heiko Carstens7dd8fe12011-05-23 10:24:35 +0200779
780out_pfault:
Thomas Huth1dad0932014-03-31 15:24:08 +0200781 unregister_external_irq(EXT_IRQ_CP_SERVICE, pfault_interrupt);
Heiko Carstens7dd8fe12011-05-23 10:24:35 +0200782out_extint:
783 pfault_disable = 1;
784 return rc;
Heiko Carstens29b08d22006-12-04 15:40:40 +0100785}
Heiko Carstensfb0a9d72011-01-05 12:47:39 +0100786early_initcall(pfault_irq_init);
787
Heiko Carstens7dd8fe12011-05-23 10:24:35 +0200788#endif /* CONFIG_PFAULT */