diff options
author | Michael Grundy <grundym@us.ibm.com> | 2006-09-20 09:58:39 -0400 |
---|---|---|
committer | Martin Schwidefsky <schwidefsky@de.ibm.com> | 2006-09-20 09:58:39 -0400 |
commit | 4ba069b802c29eee066385f9826e2d83716626b4 (patch) | |
tree | 663159a4d05a49b4133bb9145fc41fb95a6d4132 /arch/s390 | |
parent | 5432114baf0300286a6ca1b0aea549492a379432 (diff) |
[S390] add kprobes support.
Signed-off-by: Michael Grundy <grundym@us.ibm.com>
Signed-off-by: David Wilder <dwilder@us.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Diffstat (limited to 'arch/s390')
-rw-r--r-- | arch/s390/Kconfig | 14 | ||||
-rw-r--r-- | arch/s390/kernel/Makefile | 1 | ||||
-rw-r--r-- | arch/s390/kernel/entry.S | 12 | ||||
-rw-r--r-- | arch/s390/kernel/entry64.S | 12 | ||||
-rw-r--r-- | arch/s390/kernel/kprobes.c | 657 | ||||
-rw-r--r-- | arch/s390/kernel/traps.c | 31 | ||||
-rw-r--r-- | arch/s390/kernel/vmlinux.lds.S | 1 | ||||
-rw-r--r-- | arch/s390/mm/fault.c | 40 |
8 files changed, 764 insertions, 4 deletions
diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig index 2f4f70c4dbb2..76122ce1e6cb 100644 --- a/arch/s390/Kconfig +++ b/arch/s390/Kconfig | |||
@@ -487,8 +487,22 @@ source "drivers/net/Kconfig" | |||
487 | 487 | ||
488 | source "fs/Kconfig" | 488 | source "fs/Kconfig" |
489 | 489 | ||
490 | menu "Instrumentation Support" | ||
491 | |||
490 | source "arch/s390/oprofile/Kconfig" | 492 | source "arch/s390/oprofile/Kconfig" |
491 | 493 | ||
494 | config KPROBES | ||
495 | bool "Kprobes (EXPERIMENTAL)" | ||
496 | depends on EXPERIMENTAL && MODULES | ||
497 | help | ||
498 | Kprobes allows you to trap at almost any kernel address and | ||
499 | execute a callback function. register_kprobe() establishes | ||
500 | a probepoint and specifies the callback. Kprobes is useful | ||
501 | for kernel debugging, non-intrusive instrumentation and testing. | ||
502 | If in doubt, say "N". | ||
503 | |||
504 | endmenu | ||
505 | |||
492 | source "arch/s390/Kconfig.debug" | 506 | source "arch/s390/Kconfig.debug" |
493 | 507 | ||
494 | source "security/Kconfig" | 508 | source "security/Kconfig" |
diff --git a/arch/s390/kernel/Makefile b/arch/s390/kernel/Makefile index 9a33ed6ca696..33a5069c0e16 100644 --- a/arch/s390/kernel/Makefile +++ b/arch/s390/kernel/Makefile | |||
@@ -24,6 +24,7 @@ obj-$(CONFIG_COMPAT) += compat_linux.o compat_signal.o \ | |||
24 | 24 | ||
25 | obj-$(CONFIG_VIRT_TIMER) += vtime.o | 25 | obj-$(CONFIG_VIRT_TIMER) += vtime.o |
26 | obj-$(CONFIG_STACKTRACE) += stacktrace.o | 26 | obj-$(CONFIG_STACKTRACE) += stacktrace.o |
27 | obj-$(CONFIG_KPROBES) += kprobes.o | ||
27 | 28 | ||
28 | # Kexec part | 29 | # Kexec part |
29 | S390_KEXEC_OBJS := machine_kexec.o crash.o | 30 | S390_KEXEC_OBJS := machine_kexec.o crash.o |
diff --git a/arch/s390/kernel/entry.S b/arch/s390/kernel/entry.S index 5b5799ac8f83..0c712b78a7e8 100644 --- a/arch/s390/kernel/entry.S +++ b/arch/s390/kernel/entry.S | |||
@@ -505,6 +505,8 @@ pgm_no_vtime2: | |||
505 | mvc __THREAD_per+__PER_address(4,%r1),__LC_PER_ADDRESS | 505 | mvc __THREAD_per+__PER_address(4,%r1),__LC_PER_ADDRESS |
506 | mvc __THREAD_per+__PER_access_id(1,%r1),__LC_PER_ACCESS_ID | 506 | mvc __THREAD_per+__PER_access_id(1,%r1),__LC_PER_ACCESS_ID |
507 | oi __TI_flags+3(%r9),_TIF_SINGLE_STEP # set TIF_SINGLE_STEP | 507 | oi __TI_flags+3(%r9),_TIF_SINGLE_STEP # set TIF_SINGLE_STEP |
508 | tm SP_PSW+1(%r15),0x01 # kernel per event ? | ||
509 | bz BASED(kernel_per) | ||
508 | l %r3,__LC_PGM_ILC # load program interruption code | 510 | l %r3,__LC_PGM_ILC # load program interruption code |
509 | la %r8,0x7f | 511 | la %r8,0x7f |
510 | nr %r8,%r3 # clear per-event-bit and ilc | 512 | nr %r8,%r3 # clear per-event-bit and ilc |
@@ -536,6 +538,16 @@ pgm_no_vtime3: | |||
536 | stosm __SF_EMPTY(%r15),0x03 # reenable interrupts | 538 | stosm __SF_EMPTY(%r15),0x03 # reenable interrupts |
537 | b BASED(sysc_do_svc) | 539 | b BASED(sysc_do_svc) |
538 | 540 | ||
541 | # | ||
542 | # per was called from kernel, must be kprobes | ||
543 | # | ||
544 | kernel_per: | ||
545 | mvi SP_TRAP+1(%r15),0x28 # set trap indication to pgm check | ||
546 | la %r2,SP_PTREGS(%r15) # address of register-save area | ||
547 | l %r1,BASED(.Lhandle_per) # load adr. of per handler | ||
548 | la %r14,BASED(sysc_leave) # load adr. of system return | ||
549 | br %r1 # branch to do_single_step | ||
550 | |||
539 | /* | 551 | /* |
540 | * IO interrupt handler routine | 552 | * IO interrupt handler routine |
541 | */ | 553 | */ |
diff --git a/arch/s390/kernel/entry64.S b/arch/s390/kernel/entry64.S index 56f5f613b868..8b956d1538f5 100644 --- a/arch/s390/kernel/entry64.S +++ b/arch/s390/kernel/entry64.S | |||
@@ -518,6 +518,8 @@ pgm_no_vtime2: | |||
518 | #endif | 518 | #endif |
519 | lg %r9,__LC_THREAD_INFO # load pointer to thread_info struct | 519 | lg %r9,__LC_THREAD_INFO # load pointer to thread_info struct |
520 | lg %r1,__TI_task(%r9) | 520 | lg %r1,__TI_task(%r9) |
521 | tm SP_PSW+1(%r15),0x01 # kernel per event ? | ||
522 | jz kernel_per | ||
521 | mvc __THREAD_per+__PER_atmid(2,%r1),__LC_PER_ATMID | 523 | mvc __THREAD_per+__PER_atmid(2,%r1),__LC_PER_ATMID |
522 | mvc __THREAD_per+__PER_address(8,%r1),__LC_PER_ADDRESS | 524 | mvc __THREAD_per+__PER_address(8,%r1),__LC_PER_ADDRESS |
523 | mvc __THREAD_per+__PER_access_id(1,%r1),__LC_PER_ACCESS_ID | 525 | mvc __THREAD_per+__PER_access_id(1,%r1),__LC_PER_ACCESS_ID |
@@ -553,6 +555,16 @@ pgm_no_vtime3: | |||
553 | stosm __SF_EMPTY(%r15),0x03 # reenable interrupts | 555 | stosm __SF_EMPTY(%r15),0x03 # reenable interrupts |
554 | j sysc_do_svc | 556 | j sysc_do_svc |
555 | 557 | ||
558 | # | ||
559 | # per was called from kernel, must be kprobes | ||
560 | # | ||
561 | kernel_per: | ||
562 | lhi %r0,__LC_PGM_OLD_PSW | ||
563 | sth %r0,SP_TRAP(%r15) # set trap indication to pgm check | ||
564 | la %r2,SP_PTREGS(%r15) # address of register-save area | ||
565 | larl %r14,sysc_leave # load adr. of system ret, no work | ||
566 | jg do_single_step # branch to do_single_step | ||
567 | |||
556 | /* | 568 | /* |
557 | * IO interrupt handler routine | 569 | * IO interrupt handler routine |
558 | */ | 570 | */ |
diff --git a/arch/s390/kernel/kprobes.c b/arch/s390/kernel/kprobes.c new file mode 100644 index 000000000000..ca28fb0b3790 --- /dev/null +++ b/arch/s390/kernel/kprobes.c | |||
@@ -0,0 +1,657 @@ | |||
1 | /* | ||
2 | * Kernel Probes (KProbes) | ||
3 | * | ||
4 | * This program is free software; you can redistribute it and/or modify | ||
5 | * it under the terms of the GNU General Public License as published by | ||
6 | * the Free Software Foundation; either version 2 of the License, or | ||
7 | * (at your option) any later version. | ||
8 | * | ||
9 | * This program is distributed in the hope that it will be useful, | ||
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
12 | * GNU General Public License for more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU General Public License | ||
15 | * along with this program; if not, write to the Free Software | ||
16 | * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | ||
17 | * | ||
18 | * Copyright (C) IBM Corporation, 2002, 2006 | ||
19 | * | ||
20 | * s390 port, used ppc64 as template. Mike Grundy <grundym@us.ibm.com> | ||
21 | */ | ||
22 | |||
23 | #include <linux/config.h> | ||
24 | #include <linux/kprobes.h> | ||
25 | #include <linux/ptrace.h> | ||
26 | #include <linux/preempt.h> | ||
27 | #include <linux/stop_machine.h> | ||
28 | #include <asm/cacheflush.h> | ||
29 | #include <asm/kdebug.h> | ||
30 | #include <asm/sections.h> | ||
31 | #include <asm/uaccess.h> | ||
32 | #include <linux/module.h> | ||
33 | |||
34 | DEFINE_PER_CPU(struct kprobe *, current_kprobe) = NULL; | ||
35 | DEFINE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk); | ||
36 | |||
37 | int __kprobes arch_prepare_kprobe(struct kprobe *p) | ||
38 | { | ||
39 | /* Make sure the probe isn't going on a difficult instruction */ | ||
40 | if (is_prohibited_opcode((kprobe_opcode_t *) p->addr)) | ||
41 | return -EINVAL; | ||
42 | |||
43 | if ((unsigned long)p->addr & 0x01) { | ||
44 | printk("Attempt to register kprobe at an unaligned address\n"); | ||
45 | return -EINVAL; | ||
46 | } | ||
47 | |||
48 | /* Use the get_insn_slot() facility for correctness */ | ||
49 | if (!(p->ainsn.insn = get_insn_slot())) | ||
50 | return -ENOMEM; | ||
51 | |||
52 | memcpy(p->ainsn.insn, p->addr, MAX_INSN_SIZE * sizeof(kprobe_opcode_t)); | ||
53 | |||
54 | get_instruction_type(&p->ainsn); | ||
55 | p->opcode = *p->addr; | ||
56 | return 0; | ||
57 | } | ||
58 | |||
59 | int __kprobes is_prohibited_opcode(kprobe_opcode_t *instruction) | ||
60 | { | ||
61 | switch (*(__u8 *) instruction) { | ||
62 | case 0x0c: /* bassm */ | ||
63 | case 0x0b: /* bsm */ | ||
64 | case 0x83: /* diag */ | ||
65 | case 0x44: /* ex */ | ||
66 | return -EINVAL; | ||
67 | } | ||
68 | switch (*(__u16 *) instruction) { | ||
69 | case 0x0101: /* pr */ | ||
70 | case 0xb25a: /* bsa */ | ||
71 | case 0xb240: /* bakr */ | ||
72 | case 0xb258: /* bsg */ | ||
73 | case 0xb218: /* pc */ | ||
74 | case 0xb228: /* pt */ | ||
75 | return -EINVAL; | ||
76 | } | ||
77 | return 0; | ||
78 | } | ||
79 | |||
80 | void __kprobes get_instruction_type(struct arch_specific_insn *ainsn) | ||
81 | { | ||
82 | /* default fixup method */ | ||
83 | ainsn->fixup = FIXUP_PSW_NORMAL; | ||
84 | |||
85 | /* save r1 operand */ | ||
86 | ainsn->reg = (*ainsn->insn & 0xf0) >> 4; | ||
87 | |||
88 | /* save the instruction length (pop 5-5) in bytes */ | ||
89 | switch (*(__u8 *) (ainsn->insn) >> 4) { | ||
90 | case 0: | ||
91 | ainsn->ilen = 2; | ||
92 | break; | ||
93 | case 1: | ||
94 | case 2: | ||
95 | ainsn->ilen = 4; | ||
96 | break; | ||
97 | case 3: | ||
98 | ainsn->ilen = 6; | ||
99 | break; | ||
100 | } | ||
101 | |||
102 | switch (*(__u8 *) ainsn->insn) { | ||
103 | case 0x05: /* balr */ | ||
104 | case 0x0d: /* basr */ | ||
105 | ainsn->fixup = FIXUP_RETURN_REGISTER; | ||
106 | /* if r2 = 0, no branch will be taken */ | ||
107 | if ((*ainsn->insn & 0x0f) == 0) | ||
108 | ainsn->fixup |= FIXUP_BRANCH_NOT_TAKEN; | ||
109 | break; | ||
110 | case 0x06: /* bctr */ | ||
111 | case 0x07: /* bcr */ | ||
112 | ainsn->fixup = FIXUP_BRANCH_NOT_TAKEN; | ||
113 | break; | ||
114 | case 0x45: /* bal */ | ||
115 | case 0x4d: /* bas */ | ||
116 | ainsn->fixup = FIXUP_RETURN_REGISTER; | ||
117 | break; | ||
118 | case 0x47: /* bc */ | ||
119 | case 0x46: /* bct */ | ||
120 | case 0x86: /* bxh */ | ||
121 | case 0x87: /* bxle */ | ||
122 | ainsn->fixup = FIXUP_BRANCH_NOT_TAKEN; | ||
123 | break; | ||
124 | case 0x82: /* lpsw */ | ||
125 | ainsn->fixup = FIXUP_NOT_REQUIRED; | ||
126 | break; | ||
127 | case 0xb2: /* lpswe */ | ||
128 | if (*(((__u8 *) ainsn->insn) + 1) == 0xb2) { | ||
129 | ainsn->fixup = FIXUP_NOT_REQUIRED; | ||
130 | } | ||
131 | break; | ||
132 | case 0xa7: /* bras */ | ||
133 | if ((*ainsn->insn & 0x0f) == 0x05) { | ||
134 | ainsn->fixup |= FIXUP_RETURN_REGISTER; | ||
135 | } | ||
136 | break; | ||
137 | case 0xc0: | ||
138 | if ((*ainsn->insn & 0x0f) == 0x00 /* larl */ | ||
139 | || (*ainsn->insn & 0x0f) == 0x05) /* brasl */ | ||
140 | ainsn->fixup |= FIXUP_RETURN_REGISTER; | ||
141 | break; | ||
142 | case 0xeb: | ||
143 | if (*(((__u8 *) ainsn->insn) + 5 ) == 0x44 || /* bxhg */ | ||
144 | *(((__u8 *) ainsn->insn) + 5) == 0x45) {/* bxleg */ | ||
145 | ainsn->fixup = FIXUP_BRANCH_NOT_TAKEN; | ||
146 | } | ||
147 | break; | ||
148 | case 0xe3: /* bctg */ | ||
149 | if (*(((__u8 *) ainsn->insn) + 5) == 0x46) { | ||
150 | ainsn->fixup = FIXUP_BRANCH_NOT_TAKEN; | ||
151 | } | ||
152 | break; | ||
153 | } | ||
154 | } | ||
155 | |||
156 | static int __kprobes swap_instruction(void *aref) | ||
157 | { | ||
158 | struct ins_replace_args *args = aref; | ||
159 | int err = -EFAULT; | ||
160 | |||
161 | asm volatile( | ||
162 | "0: mvc 0(2,%2),0(%3)\n" | ||
163 | "1: la %0,0\n" | ||
164 | "2:\n" | ||
165 | EX_TABLE(0b,2b) | ||
166 | : "+d" (err), "=m" (*args->ptr) | ||
167 | : "a" (args->ptr), "a" (&args->new), "m" (args->new)); | ||
168 | return err; | ||
169 | } | ||
170 | |||
171 | void __kprobes arch_arm_kprobe(struct kprobe *p) | ||
172 | { | ||
173 | struct kprobe_ctlblk *kcb = get_kprobe_ctlblk(); | ||
174 | unsigned long status = kcb->kprobe_status; | ||
175 | struct ins_replace_args args; | ||
176 | |||
177 | args.ptr = p->addr; | ||
178 | args.old = p->opcode; | ||
179 | args.new = BREAKPOINT_INSTRUCTION; | ||
180 | |||
181 | kcb->kprobe_status = KPROBE_SWAP_INST; | ||
182 | stop_machine_run(swap_instruction, &args, NR_CPUS); | ||
183 | kcb->kprobe_status = status; | ||
184 | } | ||
185 | |||
186 | void __kprobes arch_disarm_kprobe(struct kprobe *p) | ||
187 | { | ||
188 | struct kprobe_ctlblk *kcb = get_kprobe_ctlblk(); | ||
189 | unsigned long status = kcb->kprobe_status; | ||
190 | struct ins_replace_args args; | ||
191 | |||
192 | args.ptr = p->addr; | ||
193 | args.old = BREAKPOINT_INSTRUCTION; | ||
194 | args.new = p->opcode; | ||
195 | |||
196 | kcb->kprobe_status = KPROBE_SWAP_INST; | ||
197 | stop_machine_run(swap_instruction, &args, NR_CPUS); | ||
198 | kcb->kprobe_status = status; | ||
199 | } | ||
200 | |||
201 | void __kprobes arch_remove_kprobe(struct kprobe *p) | ||
202 | { | ||
203 | mutex_lock(&kprobe_mutex); | ||
204 | free_insn_slot(p->ainsn.insn); | ||
205 | mutex_unlock(&kprobe_mutex); | ||
206 | } | ||
207 | |||
208 | static void __kprobes prepare_singlestep(struct kprobe *p, struct pt_regs *regs) | ||
209 | { | ||
210 | per_cr_bits kprobe_per_regs[1]; | ||
211 | |||
212 | memset(kprobe_per_regs, 0, sizeof(per_cr_bits)); | ||
213 | regs->psw.addr = (unsigned long)p->ainsn.insn | PSW_ADDR_AMODE; | ||
214 | |||
215 | /* Set up the per control reg info, will pass to lctl */ | ||
216 | kprobe_per_regs[0].em_instruction_fetch = 1; | ||
217 | kprobe_per_regs[0].starting_addr = (unsigned long)p->ainsn.insn; | ||
218 | kprobe_per_regs[0].ending_addr = (unsigned long)p->ainsn.insn + 1; | ||
219 | |||
220 | /* Set the PER control regs, turns on single step for this address */ | ||
221 | __ctl_load(kprobe_per_regs, 9, 11); | ||
222 | regs->psw.mask |= PSW_MASK_PER; | ||
223 | regs->psw.mask &= ~(PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK); | ||
224 | } | ||
225 | |||
226 | static void __kprobes save_previous_kprobe(struct kprobe_ctlblk *kcb) | ||
227 | { | ||
228 | kcb->prev_kprobe.kp = kprobe_running(); | ||
229 | kcb->prev_kprobe.status = kcb->kprobe_status; | ||
230 | kcb->prev_kprobe.kprobe_saved_imask = kcb->kprobe_saved_imask; | ||
231 | memcpy(kcb->prev_kprobe.kprobe_saved_ctl, kcb->kprobe_saved_ctl, | ||
232 | sizeof(kcb->kprobe_saved_ctl)); | ||
233 | } | ||
234 | |||
235 | static void __kprobes restore_previous_kprobe(struct kprobe_ctlblk *kcb) | ||
236 | { | ||
237 | __get_cpu_var(current_kprobe) = kcb->prev_kprobe.kp; | ||
238 | kcb->kprobe_status = kcb->prev_kprobe.status; | ||
239 | kcb->kprobe_saved_imask = kcb->prev_kprobe.kprobe_saved_imask; | ||
240 | memcpy(kcb->kprobe_saved_ctl, kcb->prev_kprobe.kprobe_saved_ctl, | ||
241 | sizeof(kcb->kprobe_saved_ctl)); | ||
242 | } | ||
243 | |||
244 | static void __kprobes set_current_kprobe(struct kprobe *p, struct pt_regs *regs, | ||
245 | struct kprobe_ctlblk *kcb) | ||
246 | { | ||
247 | __get_cpu_var(current_kprobe) = p; | ||
248 | /* Save the interrupt and per flags */ | ||
249 | kcb->kprobe_saved_imask = regs->psw.mask & | ||
250 | (PSW_MASK_PER | PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK); | ||
251 | /* Save the control regs that govern PER */ | ||
252 | __ctl_store(kcb->kprobe_saved_ctl, 9, 11); | ||
253 | } | ||
254 | |||
255 | /* Called with kretprobe_lock held */ | ||
256 | void __kprobes arch_prepare_kretprobe(struct kretprobe *rp, | ||
257 | struct pt_regs *regs) | ||
258 | { | ||
259 | struct kretprobe_instance *ri; | ||
260 | |||
261 | if ((ri = get_free_rp_inst(rp)) != NULL) { | ||
262 | ri->rp = rp; | ||
263 | ri->task = current; | ||
264 | ri->ret_addr = (kprobe_opcode_t *) regs->gprs[14]; | ||
265 | |||
266 | /* Replace the return addr with trampoline addr */ | ||
267 | regs->gprs[14] = (unsigned long)&kretprobe_trampoline; | ||
268 | |||
269 | add_rp_inst(ri); | ||
270 | } else { | ||
271 | rp->nmissed++; | ||
272 | } | ||
273 | } | ||
274 | |||
275 | static int __kprobes kprobe_handler(struct pt_regs *regs) | ||
276 | { | ||
277 | struct kprobe *p; | ||
278 | int ret = 0; | ||
279 | unsigned long *addr = (unsigned long *) | ||
280 | ((regs->psw.addr & PSW_ADDR_INSN) - 2); | ||
281 | struct kprobe_ctlblk *kcb; | ||
282 | |||
283 | /* | ||
284 | * We don't want to be preempted for the entire | ||
285 | * duration of kprobe processing | ||
286 | */ | ||
287 | preempt_disable(); | ||
288 | kcb = get_kprobe_ctlblk(); | ||
289 | |||
290 | /* Check we're not actually recursing */ | ||
291 | if (kprobe_running()) { | ||
292 | p = get_kprobe(addr); | ||
293 | if (p) { | ||
294 | if (kcb->kprobe_status == KPROBE_HIT_SS && | ||
295 | *p->ainsn.insn == BREAKPOINT_INSTRUCTION) { | ||
296 | regs->psw.mask &= ~PSW_MASK_PER; | ||
297 | regs->psw.mask |= kcb->kprobe_saved_imask; | ||
298 | goto no_kprobe; | ||
299 | } | ||
300 | /* We have reentered the kprobe_handler(), since | ||
301 | * another probe was hit while within the handler. | ||
302 | * We here save the original kprobes variables and | ||
303 | * just single step on the instruction of the new probe | ||
304 | * without calling any user handlers. | ||
305 | */ | ||
306 | save_previous_kprobe(kcb); | ||
307 | set_current_kprobe(p, regs, kcb); | ||
308 | kprobes_inc_nmissed_count(p); | ||
309 | prepare_singlestep(p, regs); | ||
310 | kcb->kprobe_status = KPROBE_REENTER; | ||
311 | return 1; | ||
312 | } else { | ||
313 | p = __get_cpu_var(current_kprobe); | ||
314 | if (p->break_handler && p->break_handler(p, regs)) { | ||
315 | goto ss_probe; | ||
316 | } | ||
317 | } | ||
318 | goto no_kprobe; | ||
319 | } | ||
320 | |||
321 | p = get_kprobe(addr); | ||
322 | if (!p) { | ||
323 | if (*addr != BREAKPOINT_INSTRUCTION) { | ||
324 | /* | ||
325 | * The breakpoint instruction was removed right | ||
326 | * after we hit it. Another cpu has removed | ||
327 | * either a probepoint or a debugger breakpoint | ||
328 | * at this address. In either case, no further | ||
329 | * handling of this interrupt is appropriate. | ||
330 | * | ||
331 | */ | ||
332 | ret = 1; | ||
333 | } | ||
334 | /* Not one of ours: let kernel handle it */ | ||
335 | goto no_kprobe; | ||
336 | } | ||
337 | |||
338 | kcb->kprobe_status = KPROBE_HIT_ACTIVE; | ||
339 | set_current_kprobe(p, regs, kcb); | ||
340 | if (p->pre_handler && p->pre_handler(p, regs)) | ||
341 | /* handler has already set things up, so skip ss setup */ | ||
342 | return 1; | ||
343 | |||
344 | ss_probe: | ||
345 | prepare_singlestep(p, regs); | ||
346 | kcb->kprobe_status = KPROBE_HIT_SS; | ||
347 | return 1; | ||
348 | |||
349 | no_kprobe: | ||
350 | preempt_enable_no_resched(); | ||
351 | return ret; | ||
352 | } | ||
353 | |||
354 | /* | ||
355 | * Function return probe trampoline: | ||
356 | * - init_kprobes() establishes a probepoint here | ||
357 | * - When the probed function returns, this probe | ||
358 | * causes the handlers to fire | ||
359 | */ | ||
360 | void __kprobes kretprobe_trampoline_holder(void) | ||
361 | { | ||
362 | asm volatile(".global kretprobe_trampoline\n" | ||
363 | "kretprobe_trampoline: bcr 0,0\n"); | ||
364 | } | ||
365 | |||
366 | /* | ||
367 | * Called when the probe at kretprobe trampoline is hit | ||
368 | */ | ||
369 | int __kprobes trampoline_probe_handler(struct kprobe *p, struct pt_regs *regs) | ||
370 | { | ||
371 | struct kretprobe_instance *ri = NULL; | ||
372 | struct hlist_head *head; | ||
373 | struct hlist_node *node, *tmp; | ||
374 | unsigned long flags, orig_ret_address = 0; | ||
375 | unsigned long trampoline_address = (unsigned long)&kretprobe_trampoline; | ||
376 | |||
377 | spin_lock_irqsave(&kretprobe_lock, flags); | ||
378 | head = kretprobe_inst_table_head(current); | ||
379 | |||
380 | /* | ||
381 | * It is possible to have multiple instances associated with a given | ||
382 | * task either because an multiple functions in the call path | ||
383 | * have a return probe installed on them, and/or more then one return | ||
384 | * return probe was registered for a target function. | ||
385 | * | ||
386 | * We can handle this because: | ||
387 | * - instances are always inserted at the head of the list | ||
388 | * - when multiple return probes are registered for the same | ||
389 | * function, the first instance's ret_addr will point to the | ||
390 | * real return address, and all the rest will point to | ||
391 | * kretprobe_trampoline | ||
392 | */ | ||
393 | hlist_for_each_entry_safe(ri, node, tmp, head, hlist) { | ||
394 | if (ri->task != current) | ||
395 | /* another task is sharing our hash bucket */ | ||
396 | continue; | ||
397 | |||
398 | if (ri->rp && ri->rp->handler) | ||
399 | ri->rp->handler(ri, regs); | ||
400 | |||
401 | orig_ret_address = (unsigned long)ri->ret_addr; | ||
402 | recycle_rp_inst(ri); | ||
403 | |||
404 | if (orig_ret_address != trampoline_address) { | ||
405 | /* | ||
406 | * This is the real return address. Any other | ||
407 | * instances associated with this task are for | ||
408 | * other calls deeper on the call stack | ||
409 | */ | ||
410 | break; | ||
411 | } | ||
412 | } | ||
413 | BUG_ON(!orig_ret_address || (orig_ret_address == trampoline_address)); | ||
414 | regs->psw.addr = orig_ret_address | PSW_ADDR_AMODE; | ||
415 | |||
416 | reset_current_kprobe(); | ||
417 | spin_unlock_irqrestore(&kretprobe_lock, flags); | ||
418 | preempt_enable_no_resched(); | ||
419 | |||
420 | /* | ||
421 | * By returning a non-zero value, we are telling | ||
422 | * kprobe_handler() that we don't want the post_handler | ||
423 | * to run (and have re-enabled preemption) | ||
424 | */ | ||
425 | return 1; | ||
426 | } | ||
427 | |||
428 | /* | ||
429 | * Called after single-stepping. p->addr is the address of the | ||
430 | * instruction whose first byte has been replaced by the "breakpoint" | ||
431 | * instruction. To avoid the SMP problems that can occur when we | ||
432 | * temporarily put back the original opcode to single-step, we | ||
433 | * single-stepped a copy of the instruction. The address of this | ||
434 | * copy is p->ainsn.insn. | ||
435 | */ | ||
436 | static void __kprobes resume_execution(struct kprobe *p, struct pt_regs *regs) | ||
437 | { | ||
438 | struct kprobe_ctlblk *kcb = get_kprobe_ctlblk(); | ||
439 | |||
440 | regs->psw.addr &= PSW_ADDR_INSN; | ||
441 | |||
442 | if (p->ainsn.fixup & FIXUP_PSW_NORMAL) | ||
443 | regs->psw.addr = (unsigned long)p->addr + | ||
444 | ((unsigned long)regs->psw.addr - | ||
445 | (unsigned long)p->ainsn.insn); | ||
446 | |||
447 | if (p->ainsn.fixup & FIXUP_BRANCH_NOT_TAKEN) | ||
448 | if ((unsigned long)regs->psw.addr - | ||
449 | (unsigned long)p->ainsn.insn == p->ainsn.ilen) | ||
450 | regs->psw.addr = (unsigned long)p->addr + p->ainsn.ilen; | ||
451 | |||
452 | if (p->ainsn.fixup & FIXUP_RETURN_REGISTER) | ||
453 | regs->gprs[p->ainsn.reg] = ((unsigned long)p->addr + | ||
454 | (regs->gprs[p->ainsn.reg] - | ||
455 | (unsigned long)p->ainsn.insn)) | ||
456 | | PSW_ADDR_AMODE; | ||
457 | |||
458 | regs->psw.addr |= PSW_ADDR_AMODE; | ||
459 | /* turn off PER mode */ | ||
460 | regs->psw.mask &= ~PSW_MASK_PER; | ||
461 | /* Restore the original per control regs */ | ||
462 | __ctl_load(kcb->kprobe_saved_ctl, 9, 11); | ||
463 | regs->psw.mask |= kcb->kprobe_saved_imask; | ||
464 | } | ||
465 | |||
466 | static int __kprobes post_kprobe_handler(struct pt_regs *regs) | ||
467 | { | ||
468 | struct kprobe *cur = kprobe_running(); | ||
469 | struct kprobe_ctlblk *kcb = get_kprobe_ctlblk(); | ||
470 | |||
471 | if (!cur) | ||
472 | return 0; | ||
473 | |||
474 | if ((kcb->kprobe_status != KPROBE_REENTER) && cur->post_handler) { | ||
475 | kcb->kprobe_status = KPROBE_HIT_SSDONE; | ||
476 | cur->post_handler(cur, regs, 0); | ||
477 | } | ||
478 | |||
479 | resume_execution(cur, regs); | ||
480 | |||
481 | /*Restore back the original saved kprobes variables and continue. */ | ||
482 | if (kcb->kprobe_status == KPROBE_REENTER) { | ||
483 | restore_previous_kprobe(kcb); | ||
484 | goto out; | ||
485 | } | ||
486 | reset_current_kprobe(); | ||
487 | out: | ||
488 | preempt_enable_no_resched(); | ||
489 | |||
490 | /* | ||
491 | * if somebody else is singlestepping across a probe point, psw mask | ||
492 | * will have PER set, in which case, continue the remaining processing | ||
493 | * of do_single_step, as if this is not a probe hit. | ||
494 | */ | ||
495 | if (regs->psw.mask & PSW_MASK_PER) { | ||
496 | return 0; | ||
497 | } | ||
498 | |||
499 | return 1; | ||
500 | } | ||
501 | |||
502 | static int __kprobes kprobe_fault_handler(struct pt_regs *regs, int trapnr) | ||
503 | { | ||
504 | struct kprobe *cur = kprobe_running(); | ||
505 | struct kprobe_ctlblk *kcb = get_kprobe_ctlblk(); | ||
506 | const struct exception_table_entry *entry; | ||
507 | |||
508 | switch(kcb->kprobe_status) { | ||
509 | case KPROBE_SWAP_INST: | ||
510 | /* We are here because the instruction replacement failed */ | ||
511 | return 0; | ||
512 | case KPROBE_HIT_SS: | ||
513 | case KPROBE_REENTER: | ||
514 | /* | ||
515 | * We are here because the instruction being single | ||
516 | * stepped caused a page fault. We reset the current | ||
517 | * kprobe and the nip points back to the probe address | ||
518 | * and allow the page fault handler to continue as a | ||
519 | * normal page fault. | ||
520 | */ | ||
521 | regs->psw.addr = (unsigned long)cur->addr | PSW_ADDR_AMODE; | ||
522 | regs->psw.mask &= ~PSW_MASK_PER; | ||
523 | regs->psw.mask |= kcb->kprobe_saved_imask; | ||
524 | if (kcb->kprobe_status == KPROBE_REENTER) | ||
525 | restore_previous_kprobe(kcb); | ||
526 | else | ||
527 | reset_current_kprobe(); | ||
528 | preempt_enable_no_resched(); | ||
529 | break; | ||
530 | case KPROBE_HIT_ACTIVE: | ||
531 | case KPROBE_HIT_SSDONE: | ||
532 | /* | ||
533 | * We increment the nmissed count for accounting, | ||
534 | * we can also use npre/npostfault count for accouting | ||
535 | * these specific fault cases. | ||
536 | */ | ||
537 | kprobes_inc_nmissed_count(cur); | ||
538 | |||
539 | /* | ||
540 | * We come here because instructions in the pre/post | ||
541 | * handler caused the page_fault, this could happen | ||
542 | * if handler tries to access user space by | ||
543 | * copy_from_user(), get_user() etc. Let the | ||
544 | * user-specified handler try to fix it first. | ||
545 | */ | ||
546 | if (cur->fault_handler && cur->fault_handler(cur, regs, trapnr)) | ||
547 | return 1; | ||
548 | |||
549 | /* | ||
550 | * In case the user-specified fault handler returned | ||
551 | * zero, try to fix up. | ||
552 | */ | ||
553 | entry = search_exception_tables(regs->psw.addr & PSW_ADDR_INSN); | ||
554 | if (entry) { | ||
555 | regs->psw.addr = entry->fixup | PSW_ADDR_AMODE; | ||
556 | return 1; | ||
557 | } | ||
558 | |||
559 | /* | ||
560 | * fixup_exception() could not handle it, | ||
561 | * Let do_page_fault() fix it. | ||
562 | */ | ||
563 | break; | ||
564 | default: | ||
565 | break; | ||
566 | } | ||
567 | return 0; | ||
568 | } | ||
569 | |||
570 | /* | ||
571 | * Wrapper routine to for handling exceptions. | ||
572 | */ | ||
573 | int __kprobes kprobe_exceptions_notify(struct notifier_block *self, | ||
574 | unsigned long val, void *data) | ||
575 | { | ||
576 | struct die_args *args = (struct die_args *)data; | ||
577 | int ret = NOTIFY_DONE; | ||
578 | |||
579 | switch (val) { | ||
580 | case DIE_BPT: | ||
581 | if (kprobe_handler(args->regs)) | ||
582 | ret = NOTIFY_STOP; | ||
583 | break; | ||
584 | case DIE_SSTEP: | ||
585 | if (post_kprobe_handler(args->regs)) | ||
586 | ret = NOTIFY_STOP; | ||
587 | break; | ||
588 | case DIE_TRAP: | ||
589 | case DIE_PAGE_FAULT: | ||
590 | /* kprobe_running() needs smp_processor_id() */ | ||
591 | preempt_disable(); | ||
592 | if (kprobe_running() && | ||
593 | kprobe_fault_handler(args->regs, args->trapnr)) | ||
594 | ret = NOTIFY_STOP; | ||
595 | preempt_enable(); | ||
596 | break; | ||
597 | default: | ||
598 | break; | ||
599 | } | ||
600 | return ret; | ||
601 | } | ||
602 | |||
603 | int __kprobes setjmp_pre_handler(struct kprobe *p, struct pt_regs *regs) | ||
604 | { | ||
605 | struct jprobe *jp = container_of(p, struct jprobe, kp); | ||
606 | unsigned long addr; | ||
607 | struct kprobe_ctlblk *kcb = get_kprobe_ctlblk(); | ||
608 | |||
609 | memcpy(&kcb->jprobe_saved_regs, regs, sizeof(struct pt_regs)); | ||
610 | |||
611 | /* setup return addr to the jprobe handler routine */ | ||
612 | regs->psw.addr = (unsigned long)(jp->entry) | PSW_ADDR_AMODE; | ||
613 | |||
614 | /* r14 is the function return address */ | ||
615 | kcb->jprobe_saved_r14 = (unsigned long)regs->gprs[14]; | ||
616 | /* r15 is the stack pointer */ | ||
617 | kcb->jprobe_saved_r15 = (unsigned long)regs->gprs[15]; | ||
618 | addr = (unsigned long)kcb->jprobe_saved_r15; | ||
619 | |||
620 | memcpy(kcb->jprobes_stack, (kprobe_opcode_t *) addr, | ||
621 | MIN_STACK_SIZE(addr)); | ||
622 | return 1; | ||
623 | } | ||
624 | |||
625 | void __kprobes jprobe_return(void) | ||
626 | { | ||
627 | asm volatile(".word 0x0002"); | ||
628 | } | ||
629 | |||
630 | void __kprobes jprobe_return_end(void) | ||
631 | { | ||
632 | asm volatile("bcr 0,0"); | ||
633 | } | ||
634 | |||
635 | int __kprobes longjmp_break_handler(struct kprobe *p, struct pt_regs *regs) | ||
636 | { | ||
637 | struct kprobe_ctlblk *kcb = get_kprobe_ctlblk(); | ||
638 | unsigned long stack_addr = (unsigned long)(kcb->jprobe_saved_r15); | ||
639 | |||
640 | /* Put the regs back */ | ||
641 | memcpy(regs, &kcb->jprobe_saved_regs, sizeof(struct pt_regs)); | ||
642 | /* put the stack back */ | ||
643 | memcpy((kprobe_opcode_t *) stack_addr, kcb->jprobes_stack, | ||
644 | MIN_STACK_SIZE(stack_addr)); | ||
645 | preempt_enable_no_resched(); | ||
646 | return 1; | ||
647 | } | ||
648 | |||
649 | static struct kprobe trampoline_p = { | ||
650 | .addr = (kprobe_opcode_t *) & kretprobe_trampoline, | ||
651 | .pre_handler = trampoline_probe_handler | ||
652 | }; | ||
653 | |||
654 | int __init arch_init_kprobes(void) | ||
655 | { | ||
656 | return register_kprobe(&trampoline_p); | ||
657 | } | ||
diff --git a/arch/s390/kernel/traps.c b/arch/s390/kernel/traps.c index bde1d1d59858..c4982c963424 100644 --- a/arch/s390/kernel/traps.c +++ b/arch/s390/kernel/traps.c | |||
@@ -29,6 +29,7 @@ | |||
29 | #include <linux/module.h> | 29 | #include <linux/module.h> |
30 | #include <linux/kallsyms.h> | 30 | #include <linux/kallsyms.h> |
31 | #include <linux/reboot.h> | 31 | #include <linux/reboot.h> |
32 | #include <linux/kprobes.h> | ||
32 | 33 | ||
33 | #include <asm/system.h> | 34 | #include <asm/system.h> |
34 | #include <asm/uaccess.h> | 35 | #include <asm/uaccess.h> |
@@ -39,6 +40,7 @@ | |||
39 | #include <asm/s390_ext.h> | 40 | #include <asm/s390_ext.h> |
40 | #include <asm/lowcore.h> | 41 | #include <asm/lowcore.h> |
41 | #include <asm/debug.h> | 42 | #include <asm/debug.h> |
43 | #include <asm/kdebug.h> | ||
42 | 44 | ||
43 | /* Called from entry.S only */ | 45 | /* Called from entry.S only */ |
44 | extern void handle_per_exception(struct pt_regs *regs); | 46 | extern void handle_per_exception(struct pt_regs *regs); |
@@ -74,6 +76,20 @@ static int kstack_depth_to_print = 12; | |||
74 | static int kstack_depth_to_print = 20; | 76 | static int kstack_depth_to_print = 20; |
75 | #endif /* CONFIG_64BIT */ | 77 | #endif /* CONFIG_64BIT */ |
76 | 78 | ||
79 | ATOMIC_NOTIFIER_HEAD(s390die_chain); | ||
80 | |||
81 | int register_die_notifier(struct notifier_block *nb) | ||
82 | { | ||
83 | return atomic_notifier_chain_register(&s390die_chain, nb); | ||
84 | } | ||
85 | EXPORT_SYMBOL(register_die_notifier); | ||
86 | |||
87 | int unregister_die_notifier(struct notifier_block *nb) | ||
88 | { | ||
89 | return atomic_notifier_chain_unregister(&s390die_chain, nb); | ||
90 | } | ||
91 | EXPORT_SYMBOL(unregister_die_notifier); | ||
92 | |||
77 | /* | 93 | /* |
78 | * For show_trace we have tree different stack to consider: | 94 | * For show_trace we have tree different stack to consider: |
79 | * - the panic stack which is used if the kernel stack has overflown | 95 | * - the panic stack which is used if the kernel stack has overflown |
@@ -305,8 +321,9 @@ report_user_fault(long interruption_code, struct pt_regs *regs) | |||
305 | #endif | 321 | #endif |
306 | } | 322 | } |
307 | 323 | ||
308 | static void inline do_trap(long interruption_code, int signr, char *str, | 324 | static void __kprobes inline do_trap(long interruption_code, int signr, |
309 | struct pt_regs *regs, siginfo_t *info) | 325 | char *str, struct pt_regs *regs, |
326 | siginfo_t *info) | ||
310 | { | 327 | { |
311 | /* | 328 | /* |
312 | * We got all needed information from the lowcore and can | 329 | * We got all needed information from the lowcore and can |
@@ -315,6 +332,10 @@ static void inline do_trap(long interruption_code, int signr, char *str, | |||
315 | if (regs->psw.mask & PSW_MASK_PSTATE) | 332 | if (regs->psw.mask & PSW_MASK_PSTATE) |
316 | local_irq_enable(); | 333 | local_irq_enable(); |
317 | 334 | ||
335 | if (notify_die(DIE_TRAP, str, regs, interruption_code, | ||
336 | interruption_code, signr) == NOTIFY_STOP) | ||
337 | return; | ||
338 | |||
318 | if (regs->psw.mask & PSW_MASK_PSTATE) { | 339 | if (regs->psw.mask & PSW_MASK_PSTATE) { |
319 | struct task_struct *tsk = current; | 340 | struct task_struct *tsk = current; |
320 | 341 | ||
@@ -336,8 +357,12 @@ static inline void __user *get_check_address(struct pt_regs *regs) | |||
336 | return (void __user *)((regs->psw.addr-S390_lowcore.pgm_ilc) & PSW_ADDR_INSN); | 357 | return (void __user *)((regs->psw.addr-S390_lowcore.pgm_ilc) & PSW_ADDR_INSN); |
337 | } | 358 | } |
338 | 359 | ||
339 | void do_single_step(struct pt_regs *regs) | 360 | void __kprobes do_single_step(struct pt_regs *regs) |
340 | { | 361 | { |
362 | if (notify_die(DIE_SSTEP, "sstep", regs, 0, 0, | ||
363 | SIGTRAP) == NOTIFY_STOP){ | ||
364 | return; | ||
365 | } | ||
341 | if ((current->ptrace & PT_PTRACED) != 0) | 366 | if ((current->ptrace & PT_PTRACED) != 0) |
342 | force_sig(SIGTRAP, current); | 367 | force_sig(SIGTRAP, current); |
343 | } | 368 | } |
diff --git a/arch/s390/kernel/vmlinux.lds.S b/arch/s390/kernel/vmlinux.lds.S index ff5f7bb34f75..df0c16ab8e92 100644 --- a/arch/s390/kernel/vmlinux.lds.S +++ b/arch/s390/kernel/vmlinux.lds.S | |||
@@ -24,6 +24,7 @@ SECTIONS | |||
24 | *(.text) | 24 | *(.text) |
25 | SCHED_TEXT | 25 | SCHED_TEXT |
26 | LOCK_TEXT | 26 | LOCK_TEXT |
27 | KPROBES_TEXT | ||
27 | *(.fixup) | 28 | *(.fixup) |
28 | *(.gnu.warning) | 29 | *(.gnu.warning) |
29 | } = 0x0700 | 30 | } = 0x0700 |
diff --git a/arch/s390/mm/fault.c b/arch/s390/mm/fault.c index 7cd82575813d..44f0cda7e72e 100644 --- a/arch/s390/mm/fault.c +++ b/arch/s390/mm/fault.c | |||
@@ -25,10 +25,12 @@ | |||
25 | #include <linux/console.h> | 25 | #include <linux/console.h> |
26 | #include <linux/module.h> | 26 | #include <linux/module.h> |
27 | #include <linux/hardirq.h> | 27 | #include <linux/hardirq.h> |
28 | #include <linux/kprobes.h> | ||
28 | 29 | ||
29 | #include <asm/system.h> | 30 | #include <asm/system.h> |
30 | #include <asm/uaccess.h> | 31 | #include <asm/uaccess.h> |
31 | #include <asm/pgtable.h> | 32 | #include <asm/pgtable.h> |
33 | #include <asm/kdebug.h> | ||
32 | 34 | ||
33 | #ifndef CONFIG_64BIT | 35 | #ifndef CONFIG_64BIT |
34 | #define __FAIL_ADDR_MASK 0x7ffff000 | 36 | #define __FAIL_ADDR_MASK 0x7ffff000 |
@@ -48,6 +50,38 @@ extern int sysctl_userprocess_debug; | |||
48 | 50 | ||
49 | extern void die(const char *,struct pt_regs *,long); | 51 | extern void die(const char *,struct pt_regs *,long); |
50 | 52 | ||
53 | #ifdef CONFIG_KPROBES | ||
54 | ATOMIC_NOTIFIER_HEAD(notify_page_fault_chain); | ||
55 | int register_page_fault_notifier(struct notifier_block *nb) | ||
56 | { | ||
57 | return atomic_notifier_chain_register(¬ify_page_fault_chain, nb); | ||
58 | } | ||
59 | |||
60 | int unregister_page_fault_notifier(struct notifier_block *nb) | ||
61 | { | ||
62 | return atomic_notifier_chain_unregister(¬ify_page_fault_chain, nb); | ||
63 | } | ||
64 | |||
65 | static inline int notify_page_fault(enum die_val val, const char *str, | ||
66 | struct pt_regs *regs, long err, int trap, int sig) | ||
67 | { | ||
68 | struct die_args args = { | ||
69 | .regs = regs, | ||
70 | .str = str, | ||
71 | .err = err, | ||
72 | .trapnr = trap, | ||
73 | .signr = sig | ||
74 | }; | ||
75 | return atomic_notifier_call_chain(¬ify_page_fault_chain, val, &args); | ||
76 | } | ||
77 | #else | ||
78 | static inline int notify_page_fault(enum die_val val, const char *str, | ||
79 | struct pt_regs *regs, long err, int trap, int sig) | ||
80 | { | ||
81 | return NOTIFY_DONE; | ||
82 | } | ||
83 | #endif | ||
84 | |||
51 | extern spinlock_t timerlist_lock; | 85 | extern spinlock_t timerlist_lock; |
52 | 86 | ||
53 | /* | 87 | /* |
@@ -159,7 +193,7 @@ static void do_sigsegv(struct pt_regs *regs, unsigned long error_code, | |||
159 | * 11 Page translation -> Not present (nullification) | 193 | * 11 Page translation -> Not present (nullification) |
160 | * 3b Region third trans. -> Not present (nullification) | 194 | * 3b Region third trans. -> Not present (nullification) |
161 | */ | 195 | */ |
162 | static inline void | 196 | static inline void __kprobes |
163 | do_exception(struct pt_regs *regs, unsigned long error_code, int is_protection) | 197 | do_exception(struct pt_regs *regs, unsigned long error_code, int is_protection) |
164 | { | 198 | { |
165 | struct task_struct *tsk; | 199 | struct task_struct *tsk; |
@@ -173,6 +207,10 @@ do_exception(struct pt_regs *regs, unsigned long error_code, int is_protection) | |||
173 | tsk = current; | 207 | tsk = current; |
174 | mm = tsk->mm; | 208 | mm = tsk->mm; |
175 | 209 | ||
210 | if (notify_page_fault(DIE_PAGE_FAULT, "page fault", regs, error_code, 14, | ||
211 | SIGSEGV) == NOTIFY_STOP) | ||
212 | return; | ||
213 | |||
176 | /* | 214 | /* |
177 | * Check for low-address protection. This needs to be treated | 215 | * Check for low-address protection. This needs to be treated |
178 | * as a special case because the translation exception code | 216 | * as a special case because the translation exception code |