]>
Commit | Line | Data |
---|---|---|
b920de1b DH |
1 | /* MN10300 Kernel probes implementation |
2 | * | |
3 | * Copyright (C) 2005 Red Hat, Inc. All Rights Reserved. | |
4 | * Written by Mark Salter (msalter@redhat.com) | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public Licence as published by | |
8 | * the Free Software Foundation; either version 2 of the Licence, or | |
9 | * (at your option) any later version. | |
10 | * | |
11 | * This program is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | * GNU General Public Licence for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU General Public Licence | |
17 | * along with this program; if not, write to the Free Software | |
18 | * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
19 | */ | |
20 | #include <linux/kprobes.h> | |
21 | #include <linux/ptrace.h> | |
22 | #include <linux/spinlock.h> | |
23 | #include <linux/preempt.h> | |
24 | #include <linux/kdebug.h> | |
25 | #include <asm/cacheflush.h> | |
26 | ||
27 | struct kretprobe_blackpoint kretprobe_blacklist[] = { { NULL, NULL } }; | |
28 | const int kretprobe_blacklist_size = ARRAY_SIZE(kretprobe_blacklist); | |
29 | ||
30 | /* kprobe_status settings */ | |
31 | #define KPROBE_HIT_ACTIVE 0x00000001 | |
32 | #define KPROBE_HIT_SS 0x00000002 | |
33 | ||
390dfd95 TH |
34 | static struct kprobe *cur_kprobe; |
35 | static unsigned long cur_kprobe_orig_pc; | |
36 | static unsigned long cur_kprobe_next_pc; | |
37 | static int cur_kprobe_ss_flags; | |
b920de1b | 38 | static unsigned long kprobe_status; |
390dfd95 TH |
39 | static kprobe_opcode_t cur_kprobe_ss_buf[MAX_INSN_SIZE + 2]; |
40 | static unsigned long cur_kprobe_bp_addr; | |
b920de1b DH |
41 | |
42 | DEFINE_PER_CPU(struct kprobe *, current_kprobe) = NULL; | |
43 | ||
44 | ||
45 | /* singlestep flag bits */ | |
46 | #define SINGLESTEP_BRANCH 1 | |
47 | #define SINGLESTEP_PCREL 2 | |
48 | ||
49 | #define READ_BYTE(p, valp) \ | |
50 | do { *(u8 *)(valp) = *(u8 *)(p); } while (0) | |
51 | ||
52 | #define READ_WORD16(p, valp) \ | |
53 | do { \ | |
54 | READ_BYTE((p), (valp)); \ | |
55 | READ_BYTE((u8 *)(p) + 1, (u8 *)(valp) + 1); \ | |
56 | } while (0) | |
57 | ||
58 | #define READ_WORD32(p, valp) \ | |
59 | do { \ | |
60 | READ_BYTE((p), (valp)); \ | |
61 | READ_BYTE((u8 *)(p) + 1, (u8 *)(valp) + 1); \ | |
62 | READ_BYTE((u8 *)(p) + 2, (u8 *)(valp) + 2); \ | |
63 | READ_BYTE((u8 *)(p) + 3, (u8 *)(valp) + 3); \ | |
64 | } while (0) | |
65 | ||
66 | ||
67 | static const u8 mn10300_insn_sizes[256] = | |
68 | { | |
69 | /* 1 2 3 4 5 6 7 8 9 a b c d e f */ | |
70 | 1, 3, 3, 3, 1, 3, 3, 3, 1, 3, 3, 3, 1, 3, 3, 3, /* 0 */ | |
71 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 1 */ | |
72 | 2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, /* 2 */ | |
73 | 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 1, 1, 1, /* 3 */ | |
74 | 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, /* 4 */ | |
75 | 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, /* 5 */ | |
76 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 6 */ | |
77 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 7 */ | |
78 | 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* 8 */ | |
79 | 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* 9 */ | |
80 | 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* a */ | |
81 | 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* b */ | |
82 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 2, /* c */ | |
83 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* d */ | |
84 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* e */ | |
85 | 0, 2, 2, 2, 2, 2, 2, 4, 0, 3, 0, 4, 0, 6, 7, 1 /* f */ | |
86 | }; | |
87 | ||
88 | #define LT (1 << 0) | |
89 | #define GT (1 << 1) | |
90 | #define GE (1 << 2) | |
91 | #define LE (1 << 3) | |
92 | #define CS (1 << 4) | |
93 | #define HI (1 << 5) | |
94 | #define CC (1 << 6) | |
95 | #define LS (1 << 7) | |
96 | #define EQ (1 << 8) | |
97 | #define NE (1 << 9) | |
98 | #define RA (1 << 10) | |
99 | #define VC (1 << 11) | |
100 | #define VS (1 << 12) | |
101 | #define NC (1 << 13) | |
102 | #define NS (1 << 14) | |
103 | ||
104 | static const u16 cond_table[] = { | |
105 | /* V C N Z */ | |
106 | /* 0 0 0 0 */ (NE | NC | CC | VC | GE | GT | HI), | |
107 | /* 0 0 0 1 */ (EQ | NC | CC | VC | GE | LE | LS), | |
108 | /* 0 0 1 0 */ (NE | NS | CC | VC | LT | LE | HI), | |
109 | /* 0 0 1 1 */ (EQ | NS | CC | VC | LT | LE | LS), | |
110 | /* 0 1 0 0 */ (NE | NC | CS | VC | GE | GT | LS), | |
111 | /* 0 1 0 1 */ (EQ | NC | CS | VC | GE | LE | LS), | |
112 | /* 0 1 1 0 */ (NE | NS | CS | VC | LT | LE | LS), | |
113 | /* 0 1 1 1 */ (EQ | NS | CS | VC | LT | LE | LS), | |
114 | /* 1 0 0 0 */ (NE | NC | CC | VS | LT | LE | HI), | |
115 | /* 1 0 0 1 */ (EQ | NC | CC | VS | LT | LE | LS), | |
116 | /* 1 0 1 0 */ (NE | NS | CC | VS | GE | GT | HI), | |
117 | /* 1 0 1 1 */ (EQ | NS | CC | VS | GE | LE | LS), | |
118 | /* 1 1 0 0 */ (NE | NC | CS | VS | LT | LE | LS), | |
119 | /* 1 1 0 1 */ (EQ | NC | CS | VS | LT | LE | LS), | |
120 | /* 1 1 1 0 */ (NE | NS | CS | VS | GE | GT | LS), | |
121 | /* 1 1 1 1 */ (EQ | NS | CS | VS | GE | LE | LS), | |
122 | }; | |
123 | ||
124 | /* | |
125 | * Calculate what the PC will be after executing next instruction | |
126 | */ | |
127 | static unsigned find_nextpc(struct pt_regs *regs, int *flags) | |
128 | { | |
129 | unsigned size; | |
130 | s8 x8; | |
131 | s16 x16; | |
132 | s32 x32; | |
133 | u8 opc, *pc, *sp, *next; | |
134 | ||
135 | next = 0; | |
136 | *flags = SINGLESTEP_PCREL; | |
137 | ||
138 | pc = (u8 *) regs->pc; | |
139 | sp = (u8 *) (regs + 1); | |
140 | opc = *pc; | |
141 | ||
142 | size = mn10300_insn_sizes[opc]; | |
143 | if (size > 0) { | |
144 | next = pc + size; | |
145 | } else { | |
146 | switch (opc) { | |
147 | /* Bxx (d8,PC) */ | |
148 | case 0xc0 ... 0xca: | |
149 | x8 = 2; | |
150 | if (cond_table[regs->epsw & 0xf] & (1 << (opc & 0xf))) | |
151 | x8 = (s8)pc[1]; | |
152 | next = pc + x8; | |
153 | *flags |= SINGLESTEP_BRANCH; | |
154 | break; | |
155 | ||
156 | /* JMP (d16,PC) or CALL (d16,PC) */ | |
157 | case 0xcc: | |
158 | case 0xcd: | |
159 | READ_WORD16(pc + 1, &x16); | |
160 | next = pc + x16; | |
161 | *flags |= SINGLESTEP_BRANCH; | |
162 | break; | |
163 | ||
164 | /* JMP (d32,PC) or CALL (d32,PC) */ | |
165 | case 0xdc: | |
166 | case 0xdd: | |
167 | READ_WORD32(pc + 1, &x32); | |
168 | next = pc + x32; | |
169 | *flags |= SINGLESTEP_BRANCH; | |
170 | break; | |
171 | ||
172 | /* RETF */ | |
173 | case 0xde: | |
174 | next = (u8 *)regs->mdr; | |
175 | *flags &= ~SINGLESTEP_PCREL; | |
176 | *flags |= SINGLESTEP_BRANCH; | |
177 | break; | |
178 | ||
179 | /* RET */ | |
180 | case 0xdf: | |
181 | sp += pc[2]; | |
182 | READ_WORD32(sp, &x32); | |
183 | next = (u8 *)x32; | |
184 | *flags &= ~SINGLESTEP_PCREL; | |
185 | *flags |= SINGLESTEP_BRANCH; | |
186 | break; | |
187 | ||
188 | case 0xf0: | |
189 | next = pc + 2; | |
190 | opc = pc[1]; | |
191 | if (opc >= 0xf0 && opc <= 0xf7) { | |
192 | /* JMP (An) / CALLS (An) */ | |
193 | switch (opc & 3) { | |
194 | case 0: | |
195 | next = (u8 *)regs->a0; | |
196 | break; | |
197 | case 1: | |
198 | next = (u8 *)regs->a1; | |
199 | break; | |
200 | case 2: | |
201 | next = (u8 *)regs->a2; | |
202 | break; | |
203 | case 3: | |
204 | next = (u8 *)regs->a3; | |
205 | break; | |
206 | } | |
207 | *flags &= ~SINGLESTEP_PCREL; | |
208 | *flags |= SINGLESTEP_BRANCH; | |
209 | } else if (opc == 0xfc) { | |
210 | /* RETS */ | |
211 | READ_WORD32(sp, &x32); | |
212 | next = (u8 *)x32; | |
213 | *flags &= ~SINGLESTEP_PCREL; | |
214 | *flags |= SINGLESTEP_BRANCH; | |
215 | } else if (opc == 0xfd) { | |
216 | /* RTI */ | |
217 | READ_WORD32(sp + 4, &x32); | |
218 | next = (u8 *)x32; | |
219 | *flags &= ~SINGLESTEP_PCREL; | |
220 | *flags |= SINGLESTEP_BRANCH; | |
221 | } | |
222 | break; | |
223 | ||
224 | /* potential 3-byte conditional branches */ | |
225 | case 0xf8: | |
226 | next = pc + 3; | |
227 | opc = pc[1]; | |
228 | if (opc >= 0xe8 && opc <= 0xeb && | |
229 | (cond_table[regs->epsw & 0xf] & | |
230 | (1 << ((opc & 0xf) + 3))) | |
231 | ) { | |
232 | READ_BYTE(pc+2, &x8); | |
233 | next = pc + x8; | |
234 | *flags |= SINGLESTEP_BRANCH; | |
235 | } | |
236 | break; | |
237 | ||
238 | case 0xfa: | |
239 | if (pc[1] == 0xff) { | |
240 | /* CALLS (d16,PC) */ | |
241 | READ_WORD16(pc + 2, &x16); | |
242 | next = pc + x16; | |
243 | } else | |
244 | next = pc + 4; | |
245 | *flags |= SINGLESTEP_BRANCH; | |
246 | break; | |
247 | ||
248 | case 0xfc: | |
249 | x32 = 6; | |
250 | if (pc[1] == 0xff) { | |
251 | /* CALLS (d32,PC) */ | |
252 | READ_WORD32(pc + 2, &x32); | |
253 | } | |
254 | next = pc + x32; | |
255 | *flags |= SINGLESTEP_BRANCH; | |
256 | break; | |
257 | /* LXX (d8,PC) */ | |
258 | /* SETLB - loads the next four bytes into the LIR reg */ | |
259 | case 0xd0 ... 0xda: | |
260 | case 0xdb: | |
261 | panic("Can't singlestep Lxx/SETLB\n"); | |
262 | break; | |
263 | } | |
264 | } | |
265 | return (unsigned)next; | |
266 | ||
267 | } | |
268 | ||
269 | /* | |
270 | * set up out of place singlestep of some branching instructions | |
271 | */ | |
272 | static unsigned __kprobes singlestep_branch_setup(struct pt_regs *regs) | |
273 | { | |
274 | u8 opc, *pc, *sp, *next; | |
275 | ||
276 | next = NULL; | |
277 | pc = (u8 *) regs->pc; | |
278 | sp = (u8 *) (regs + 1); | |
279 | ||
280 | switch (pc[0]) { | |
281 | case 0xc0 ... 0xca: /* Bxx (d8,PC) */ | |
282 | case 0xcc: /* JMP (d16,PC) */ | |
283 | case 0xdc: /* JMP (d32,PC) */ | |
284 | case 0xf8: /* Bxx (d8,PC) 3-byte version */ | |
285 | /* don't really need to do anything except cause trap */ | |
286 | next = pc; | |
287 | break; | |
288 | ||
289 | case 0xcd: /* CALL (d16,PC) */ | |
290 | pc[1] = 5; | |
291 | pc[2] = 0; | |
292 | next = pc + 5; | |
293 | break; | |
294 | ||
295 | case 0xdd: /* CALL (d32,PC) */ | |
296 | pc[1] = 7; | |
297 | pc[2] = 0; | |
298 | pc[3] = 0; | |
299 | pc[4] = 0; | |
300 | next = pc + 7; | |
301 | break; | |
302 | ||
303 | case 0xde: /* RETF */ | |
304 | next = pc + 3; | |
305 | regs->mdr = (unsigned) next; | |
306 | break; | |
307 | ||
308 | case 0xdf: /* RET */ | |
309 | sp += pc[2]; | |
310 | next = pc + 3; | |
311 | *(unsigned *)sp = (unsigned) next; | |
312 | break; | |
313 | ||
314 | case 0xf0: | |
315 | next = pc + 2; | |
316 | opc = pc[1]; | |
317 | if (opc >= 0xf0 && opc <= 0xf3) { | |
318 | /* CALLS (An) */ | |
319 | /* use CALLS (d16,PC) to avoid mucking with An */ | |
320 | pc[0] = 0xfa; | |
321 | pc[1] = 0xff; | |
322 | pc[2] = 4; | |
323 | pc[3] = 0; | |
324 | next = pc + 4; | |
325 | } else if (opc >= 0xf4 && opc <= 0xf7) { | |
326 | /* JMP (An) */ | |
327 | next = pc; | |
328 | } else if (opc == 0xfc) { | |
329 | /* RETS */ | |
330 | next = pc + 2; | |
331 | *(unsigned *) sp = (unsigned) next; | |
332 | } else if (opc == 0xfd) { | |
333 | /* RTI */ | |
334 | next = pc + 2; | |
335 | *(unsigned *)(sp + 4) = (unsigned) next; | |
336 | } | |
337 | break; | |
338 | ||
339 | case 0xfa: /* CALLS (d16,PC) */ | |
340 | pc[2] = 4; | |
341 | pc[3] = 0; | |
342 | next = pc + 4; | |
343 | break; | |
344 | ||
345 | case 0xfc: /* CALLS (d32,PC) */ | |
346 | pc[2] = 6; | |
347 | pc[3] = 0; | |
348 | pc[4] = 0; | |
349 | pc[5] = 0; | |
350 | next = pc + 6; | |
351 | break; | |
352 | ||
353 | case 0xd0 ... 0xda: /* LXX (d8,PC) */ | |
354 | case 0xdb: /* SETLB */ | |
355 | panic("Can't singlestep Lxx/SETLB\n"); | |
356 | } | |
357 | ||
358 | return (unsigned) next; | |
359 | } | |
360 | ||
361 | int __kprobes arch_prepare_kprobe(struct kprobe *p) | |
362 | { | |
363 | return 0; | |
364 | } | |
365 | ||
366 | void __kprobes arch_copy_kprobe(struct kprobe *p) | |
367 | { | |
368 | memcpy(p->ainsn.insn, p->addr, MAX_INSN_SIZE); | |
369 | } | |
370 | ||
371 | void __kprobes arch_arm_kprobe(struct kprobe *p) | |
372 | { | |
373 | *p->addr = BREAKPOINT_INSTRUCTION; | |
374 | flush_icache_range((unsigned long) p->addr, | |
375 | (unsigned long) p->addr + sizeof(kprobe_opcode_t)); | |
376 | } | |
377 | ||
378 | void __kprobes arch_disarm_kprobe(struct kprobe *p) | |
379 | { | |
b478491f | 380 | #ifndef CONFIG_MN10300_CACHE_SNOOP |
b920de1b DH |
381 | mn10300_dcache_flush(); |
382 | mn10300_icache_inv(); | |
b478491f | 383 | #endif |
b920de1b DH |
384 | } |
385 | ||
386 | void arch_remove_kprobe(struct kprobe *p) | |
387 | { | |
388 | } | |
389 | ||
390 | static inline | |
391 | void __kprobes disarm_kprobe(struct kprobe *p, struct pt_regs *regs) | |
392 | { | |
393 | *p->addr = p->opcode; | |
394 | regs->pc = (unsigned long) p->addr; | |
b478491f | 395 | #ifndef CONFIG_MN10300_CACHE_SNOOP |
b920de1b DH |
396 | mn10300_dcache_flush(); |
397 | mn10300_icache_inv(); | |
b478491f | 398 | #endif |
b920de1b DH |
399 | } |
400 | ||
401 | static inline | |
402 | void __kprobes prepare_singlestep(struct kprobe *p, struct pt_regs *regs) | |
403 | { | |
404 | unsigned long nextpc; | |
405 | ||
390dfd95 TH |
406 | cur_kprobe_orig_pc = regs->pc; |
407 | memcpy(cur_kprobe_ss_buf, &p->ainsn.insn[0], MAX_INSN_SIZE); | |
408 | regs->pc = (unsigned long) cur_kprobe_ss_buf; | |
b920de1b | 409 | |
390dfd95 TH |
410 | nextpc = find_nextpc(regs, &cur_kprobe_ss_flags); |
411 | if (cur_kprobe_ss_flags & SINGLESTEP_PCREL) | |
412 | cur_kprobe_next_pc = cur_kprobe_orig_pc + (nextpc - regs->pc); | |
b920de1b | 413 | else |
390dfd95 | 414 | cur_kprobe_next_pc = nextpc; |
b920de1b DH |
415 | |
416 | /* branching instructions need special handling */ | |
390dfd95 | 417 | if (cur_kprobe_ss_flags & SINGLESTEP_BRANCH) |
b920de1b DH |
418 | nextpc = singlestep_branch_setup(regs); |
419 | ||
390dfd95 | 420 | cur_kprobe_bp_addr = nextpc; |
b920de1b DH |
421 | |
422 | *(u8 *) nextpc = BREAKPOINT_INSTRUCTION; | |
390dfd95 TH |
423 | mn10300_dcache_flush_range2((unsigned) cur_kprobe_ss_buf, |
424 | sizeof(cur_kprobe_ss_buf)); | |
b920de1b DH |
425 | mn10300_icache_inv(); |
426 | } | |
427 | ||
428 | static inline int __kprobes kprobe_handler(struct pt_regs *regs) | |
429 | { | |
430 | struct kprobe *p; | |
431 | int ret = 0; | |
432 | unsigned int *addr = (unsigned int *) regs->pc; | |
433 | ||
434 | /* We're in an interrupt, but this is clear and BUG()-safe. */ | |
435 | preempt_disable(); | |
436 | ||
437 | /* Check we're not actually recursing */ | |
438 | if (kprobe_running()) { | |
439 | /* We *are* holding lock here, so this is safe. | |
440 | Disarm the probe we just hit, and ignore it. */ | |
441 | p = get_kprobe(addr); | |
442 | if (p) { | |
443 | disarm_kprobe(p, regs); | |
444 | ret = 1; | |
445 | } else { | |
390dfd95 | 446 | p = cur_kprobe; |
b920de1b DH |
447 | if (p->break_handler && p->break_handler(p, regs)) |
448 | goto ss_probe; | |
449 | } | |
450 | /* If it's not ours, can't be delete race, (we hold lock). */ | |
451 | goto no_kprobe; | |
452 | } | |
453 | ||
454 | p = get_kprobe(addr); | |
455 | if (!p) { | |
456 | if (*addr != BREAKPOINT_INSTRUCTION) { | |
457 | /* The breakpoint instruction was removed right after | |
458 | * we hit it. Another cpu has removed either a | |
459 | * probepoint or a debugger breakpoint at this address. | |
460 | * In either case, no further handling of this | |
461 | * interrupt is appropriate. | |
462 | */ | |
463 | ret = 1; | |
464 | } | |
465 | /* Not one of ours: let kernel handle it */ | |
466 | goto no_kprobe; | |
467 | } | |
468 | ||
469 | kprobe_status = KPROBE_HIT_ACTIVE; | |
390dfd95 | 470 | cur_kprobe = p; |
b920de1b DH |
471 | if (p->pre_handler(p, regs)) { |
472 | /* handler has already set things up, so skip ss setup */ | |
473 | return 1; | |
474 | } | |
475 | ||
476 | ss_probe: | |
477 | prepare_singlestep(p, regs); | |
478 | kprobe_status = KPROBE_HIT_SS; | |
479 | return 1; | |
480 | ||
481 | no_kprobe: | |
482 | preempt_enable_no_resched(); | |
483 | return ret; | |
484 | } | |
485 | ||
486 | /* | |
487 | * Called after single-stepping. p->addr is the address of the | |
488 | * instruction whose first byte has been replaced by the "breakpoint" | |
489 | * instruction. To avoid the SMP problems that can occur when we | |
490 | * temporarily put back the original opcode to single-step, we | |
491 | * single-stepped a copy of the instruction. The address of this | |
492 | * copy is p->ainsn.insn. | |
493 | */ | |
494 | static void __kprobes resume_execution(struct kprobe *p, struct pt_regs *regs) | |
495 | { | |
496 | /* we may need to fixup regs/stack after singlestepping a call insn */ | |
390dfd95 TH |
497 | if (cur_kprobe_ss_flags & SINGLESTEP_BRANCH) { |
498 | regs->pc = cur_kprobe_orig_pc; | |
b920de1b DH |
499 | switch (p->ainsn.insn[0]) { |
500 | case 0xcd: /* CALL (d16,PC) */ | |
501 | *(unsigned *) regs->sp = regs->mdr = regs->pc + 5; | |
502 | break; | |
503 | case 0xdd: /* CALL (d32,PC) */ | |
504 | /* fixup mdr and return address on stack */ | |
505 | *(unsigned *) regs->sp = regs->mdr = regs->pc + 7; | |
506 | break; | |
507 | case 0xf0: | |
508 | if (p->ainsn.insn[1] >= 0xf0 && | |
509 | p->ainsn.insn[1] <= 0xf3) { | |
510 | /* CALLS (An) */ | |
511 | /* fixup MDR and return address on stack */ | |
512 | regs->mdr = regs->pc + 2; | |
513 | *(unsigned *) regs->sp = regs->mdr; | |
514 | } | |
515 | break; | |
516 | ||
517 | case 0xfa: /* CALLS (d16,PC) */ | |
518 | /* fixup MDR and return address on stack */ | |
519 | *(unsigned *) regs->sp = regs->mdr = regs->pc + 4; | |
520 | break; | |
521 | ||
522 | case 0xfc: /* CALLS (d32,PC) */ | |
523 | /* fixup MDR and return address on stack */ | |
524 | *(unsigned *) regs->sp = regs->mdr = regs->pc + 6; | |
525 | break; | |
526 | } | |
527 | } | |
528 | ||
390dfd95 TH |
529 | regs->pc = cur_kprobe_next_pc; |
530 | cur_kprobe_bp_addr = 0; | |
b920de1b DH |
531 | } |
532 | ||
533 | static inline int __kprobes post_kprobe_handler(struct pt_regs *regs) | |
534 | { | |
535 | if (!kprobe_running()) | |
536 | return 0; | |
537 | ||
390dfd95 TH |
538 | if (cur_kprobe->post_handler) |
539 | cur_kprobe->post_handler(cur_kprobe, regs, 0); | |
b920de1b | 540 | |
390dfd95 | 541 | resume_execution(cur_kprobe, regs); |
b920de1b DH |
542 | reset_current_kprobe(); |
543 | preempt_enable_no_resched(); | |
544 | return 1; | |
545 | } | |
546 | ||
547 | /* Interrupts disabled, kprobe_lock held. */ | |
548 | static inline | |
549 | int __kprobes kprobe_fault_handler(struct pt_regs *regs, int trapnr) | |
550 | { | |
390dfd95 TH |
551 | if (cur_kprobe->fault_handler && |
552 | cur_kprobe->fault_handler(cur_kprobe, regs, trapnr)) | |
b920de1b DH |
553 | return 1; |
554 | ||
555 | if (kprobe_status & KPROBE_HIT_SS) { | |
390dfd95 | 556 | resume_execution(cur_kprobe, regs); |
b920de1b DH |
557 | reset_current_kprobe(); |
558 | preempt_enable_no_resched(); | |
559 | } | |
560 | return 0; | |
561 | } | |
562 | ||
563 | /* | |
564 | * Wrapper routine to for handling exceptions. | |
565 | */ | |
566 | int __kprobes kprobe_exceptions_notify(struct notifier_block *self, | |
567 | unsigned long val, void *data) | |
568 | { | |
569 | struct die_args *args = data; | |
570 | ||
571 | switch (val) { | |
572 | case DIE_BREAKPOINT: | |
390dfd95 | 573 | if (cur_kprobe_bp_addr != args->regs->pc) { |
b920de1b DH |
574 | if (kprobe_handler(args->regs)) |
575 | return NOTIFY_STOP; | |
576 | } else { | |
577 | if (post_kprobe_handler(args->regs)) | |
578 | return NOTIFY_STOP; | |
579 | } | |
580 | break; | |
581 | case DIE_GPF: | |
582 | if (kprobe_running() && | |
583 | kprobe_fault_handler(args->regs, args->trapnr)) | |
584 | return NOTIFY_STOP; | |
585 | break; | |
586 | default: | |
587 | break; | |
588 | } | |
589 | return NOTIFY_DONE; | |
590 | } | |
591 | ||
592 | /* Jprobes support. */ | |
593 | static struct pt_regs jprobe_saved_regs; | |
594 | static struct pt_regs *jprobe_saved_regs_location; | |
595 | static kprobe_opcode_t jprobe_saved_stack[MAX_STACK_SIZE]; | |
596 | ||
597 | int __kprobes setjmp_pre_handler(struct kprobe *p, struct pt_regs *regs) | |
598 | { | |
599 | struct jprobe *jp = container_of(p, struct jprobe, kp); | |
600 | ||
601 | jprobe_saved_regs_location = regs; | |
602 | memcpy(&jprobe_saved_regs, regs, sizeof(struct pt_regs)); | |
603 | ||
604 | /* Save a whole stack frame, this gets arguments | |
605 | * pushed onto the stack after using up all the | |
606 | * arg registers. | |
607 | */ | |
608 | memcpy(&jprobe_saved_stack, regs + 1, sizeof(jprobe_saved_stack)); | |
609 | ||
610 | /* setup return addr to the jprobe handler routine */ | |
611 | regs->pc = (unsigned long) jp->entry; | |
612 | return 1; | |
613 | } | |
614 | ||
615 | void __kprobes jprobe_return(void) | |
616 | { | |
617 | void *orig_sp = jprobe_saved_regs_location + 1; | |
618 | ||
619 | preempt_enable_no_resched(); | |
620 | asm volatile(" mov %0,sp\n" | |
621 | ".globl jprobe_return_bp_addr\n" | |
622 | "jprobe_return_bp_addr:\n\t" | |
623 | " .byte 0xff\n" | |
624 | : : "d" (orig_sp)); | |
625 | } | |
626 | ||
627 | extern void jprobe_return_bp_addr(void); | |
628 | ||
629 | int __kprobes longjmp_break_handler(struct kprobe *p, struct pt_regs *regs) | |
630 | { | |
631 | u8 *addr = (u8 *) regs->pc; | |
632 | ||
633 | if (addr == (u8 *) jprobe_return_bp_addr) { | |
634 | if (jprobe_saved_regs_location != regs) { | |
635 | printk(KERN_ERR"JPROBE:" | |
636 | " Current regs (%p) does not match saved regs" | |
637 | " (%p).\n", | |
638 | regs, jprobe_saved_regs_location); | |
639 | BUG(); | |
640 | } | |
641 | ||
642 | /* Restore old register state. | |
643 | */ | |
644 | memcpy(regs, &jprobe_saved_regs, sizeof(struct pt_regs)); | |
645 | ||
646 | memcpy(regs + 1, &jprobe_saved_stack, | |
647 | sizeof(jprobe_saved_stack)); | |
648 | return 1; | |
649 | } | |
650 | return 0; | |
651 | } | |
652 | ||
653 | int __init arch_init_kprobes(void) | |
654 | { | |
655 | return 0; | |
656 | } |