1 /* arch/sparc64/kernel/kprobes.c
3 * Copyright (C) 2004 David S. Miller <davem@davemloft.net>
6 #include <linux/config.h>
7 #include <linux/kernel.h>
8 #include <linux/kprobes.h>
9 #include <linux/module.h>
10 #include <asm/kdebug.h>
11 #include <asm/signal.h>
12 #include <asm/cacheflush.h>
13 #include <asm/uaccess.h>
15 /* We do not have hardware single-stepping on sparc64.
16 * So we implement software single-stepping with breakpoint
17 * traps. The top-level scheme is similar to that used
18 * in the x86 kprobes implementation.
20 * In the kprobe->ainsn.insn[] array we store the original
21 * instruction at index zero and a break instruction at
24 * When we hit a kprobe we:
25 * - Run the pre-handler
26 * - Remember "regs->tnpc" and interrupt level stored in
27 * "regs->tstate" so we can restore them later
28 * - Disable PIL interrupts
29 * - Set regs->tpc to point to kprobe->ainsn.insn[0]
30 * - Set regs->tnpc to point to kprobe->ainsn.insn[1]
31 * - Mark that we are actively in a kprobe
33 * At this point we wait for the second breakpoint at
34 * kprobe->ainsn.insn[1] to hit. When it does we:
35 * - Run the post-handler
36 * - Set regs->tpc to "remembered" regs->tnpc stored above,
37 * restore the PIL interrupt level in "regs->tstate" as well
38 * - Make any adjustments necessary to regs->tnpc in order
39 * to handle relative branches correctly. See below.
40 * - Mark that we are no longer actively in a kprobe.
43 DEFINE_PER_CPU(struct kprobe
*, current_kprobe
) = NULL
;
44 DEFINE_PER_CPU(struct kprobe_ctlblk
, kprobe_ctlblk
);
46 int __kprobes
arch_prepare_kprobe(struct kprobe
*p
)
48 p
->ainsn
.insn
[0] = *p
->addr
;
49 p
->ainsn
.insn
[1] = BREAKPOINT_INSTRUCTION_2
;
54 void __kprobes
arch_arm_kprobe(struct kprobe
*p
)
56 *p
->addr
= BREAKPOINT_INSTRUCTION
;
60 void __kprobes
arch_disarm_kprobe(struct kprobe
*p
)
66 static inline void save_previous_kprobe(struct kprobe_ctlblk
*kcb
)
68 kcb
->prev_kprobe
.kp
= kprobe_running();
69 kcb
->prev_kprobe
.status
= kcb
->kprobe_status
;
70 kcb
->prev_kprobe
.orig_tnpc
= kcb
->kprobe_orig_tnpc
;
71 kcb
->prev_kprobe
.orig_tstate_pil
= kcb
->kprobe_orig_tstate_pil
;
74 static inline void restore_previous_kprobe(struct kprobe_ctlblk
*kcb
)
76 __get_cpu_var(current_kprobe
) = kcb
->prev_kprobe
.kp
;
77 kcb
->kprobe_status
= kcb
->prev_kprobe
.status
;
78 kcb
->kprobe_orig_tnpc
= kcb
->prev_kprobe
.orig_tnpc
;
79 kcb
->kprobe_orig_tstate_pil
= kcb
->prev_kprobe
.orig_tstate_pil
;
82 static inline void set_current_kprobe(struct kprobe
*p
, struct pt_regs
*regs
,
83 struct kprobe_ctlblk
*kcb
)
85 __get_cpu_var(current_kprobe
) = p
;
86 kcb
->kprobe_orig_tnpc
= regs
->tnpc
;
87 kcb
->kprobe_orig_tstate_pil
= (regs
->tstate
& TSTATE_PIL
);
90 static inline void prepare_singlestep(struct kprobe
*p
, struct pt_regs
*regs
,
91 struct kprobe_ctlblk
*kcb
)
93 regs
->tstate
|= TSTATE_PIL
;
95 /*single step inline, if it a breakpoint instruction*/
96 if (p
->opcode
== BREAKPOINT_INSTRUCTION
) {
97 regs
->tpc
= (unsigned long) p
->addr
;
98 regs
->tnpc
= kcb
->kprobe_orig_tnpc
;
100 regs
->tpc
= (unsigned long) &p
->ainsn
.insn
[0];
101 regs
->tnpc
= (unsigned long) &p
->ainsn
.insn
[1];
105 static int __kprobes
kprobe_handler(struct pt_regs
*regs
)
108 void *addr
= (void *) regs
->tpc
;
110 struct kprobe_ctlblk
*kcb
;
113 * We don't want to be preempted for the entire
114 * duration of kprobe processing
117 kcb
= get_kprobe_ctlblk();
119 if (kprobe_running()) {
120 p
= get_kprobe(addr
);
122 if (kcb
->kprobe_status
== KPROBE_HIT_SS
) {
123 regs
->tstate
= ((regs
->tstate
& ~TSTATE_PIL
) |
124 kcb
->kprobe_orig_tstate_pil
);
127 /* We have reentered the kprobe_handler(), since
128 * another probe was hit while within the handler.
129 * We here save the original kprobes variables and
130 * just single step on the instruction of the new probe
131 * without calling any user handlers.
133 save_previous_kprobe(kcb
);
134 set_current_kprobe(p
, regs
, kcb
);
135 kprobes_inc_nmissed_count(p
);
136 kcb
->kprobe_status
= KPROBE_REENTER
;
137 prepare_singlestep(p
, regs
, kcb
);
140 if (*(u32
*)addr
!= BREAKPOINT_INSTRUCTION
) {
141 /* The breakpoint instruction was removed by
142 * another cpu right after we hit, no further
143 * handling of this interrupt is appropriate
148 p
= __get_cpu_var(current_kprobe
);
149 if (p
->break_handler
&& p
->break_handler(p
, regs
))
155 p
= get_kprobe(addr
);
157 if (*(u32
*)addr
!= BREAKPOINT_INSTRUCTION
) {
159 * The breakpoint instruction was removed right
160 * after we hit it. Another cpu has removed
161 * either a probepoint or a debugger breakpoint
162 * at this address. In either case, no further
163 * handling of this interrupt is appropriate.
167 /* Not one of ours: let kernel handle it */
171 set_current_kprobe(p
, regs
, kcb
);
172 kcb
->kprobe_status
= KPROBE_HIT_ACTIVE
;
173 if (p
->pre_handler
&& p
->pre_handler(p
, regs
))
177 prepare_singlestep(p
, regs
, kcb
);
178 kcb
->kprobe_status
= KPROBE_HIT_SS
;
182 preempt_enable_no_resched();
186 /* If INSN is a relative control transfer instruction,
187 * return the corrected branch destination value.
189 * The original INSN location was REAL_PC, it actually
190 * executed at PC and produced destination address NPC.
192 static unsigned long __kprobes
relbranch_fixup(u32 insn
, unsigned long real_pc
,
196 /* Branch not taken, no mods necessary. */
197 if (npc
== pc
+ 0x4UL
)
198 return real_pc
+ 0x4UL
;
200 /* The three cases are call, branch w/prediction,
201 * and traditional branch.
203 if ((insn
& 0xc0000000) == 0x40000000 ||
204 (insn
& 0xc1c00000) == 0x00400000 ||
205 (insn
& 0xc1c00000) == 0x00800000) {
206 /* The instruction did all the work for us
207 * already, just apply the offset to the correct
208 * instruction location.
210 return (real_pc
+ (npc
- pc
));
213 return real_pc
+ 0x4UL
;
216 /* If INSN is an instruction which writes it's PC location
217 * into a destination register, fix that up.
219 static void __kprobes
retpc_fixup(struct pt_regs
*regs
, u32 insn
,
220 unsigned long real_pc
)
222 unsigned long *slot
= NULL
;
224 /* Simplest cast is call, which always uses %o7 */
225 if ((insn
& 0xc0000000) == 0x40000000) {
226 slot
= ®s
->u_regs
[UREG_I7
];
229 /* Jmpl encodes the register inside of the opcode */
230 if ((insn
& 0xc1f80000) == 0x81c00000) {
231 unsigned long rd
= ((insn
>> 25) & 0x1f);
234 slot
= ®s
->u_regs
[rd
];
236 /* Hard case, it goes onto the stack. */
240 slot
= (unsigned long *)
241 (regs
->u_regs
[UREG_FP
] + STACK_BIAS
);
250 * Called after single-stepping. p->addr is the address of the
251 * instruction whose first byte has been replaced by the breakpoint
252 * instruction. To avoid the SMP problems that can occur when we
253 * temporarily put back the original opcode to single-step, we
254 * single-stepped a copy of the instruction. The address of this
255 * copy is p->ainsn.insn.
257 * This function prepares to return from the post-single-step
260 static void __kprobes
resume_execution(struct kprobe
*p
,
261 struct pt_regs
*regs
, struct kprobe_ctlblk
*kcb
)
263 u32 insn
= p
->ainsn
.insn
[0];
265 regs
->tpc
= kcb
->kprobe_orig_tnpc
;
266 regs
->tnpc
= relbranch_fixup(insn
,
267 (unsigned long) p
->addr
,
268 (unsigned long) &p
->ainsn
.insn
[0],
270 retpc_fixup(regs
, insn
, (unsigned long) p
->addr
);
272 regs
->tstate
= ((regs
->tstate
& ~TSTATE_PIL
) |
273 kcb
->kprobe_orig_tstate_pil
);
276 static inline int post_kprobe_handler(struct pt_regs
*regs
)
278 struct kprobe
*cur
= kprobe_running();
279 struct kprobe_ctlblk
*kcb
= get_kprobe_ctlblk();
284 if ((kcb
->kprobe_status
!= KPROBE_REENTER
) && cur
->post_handler
) {
285 kcb
->kprobe_status
= KPROBE_HIT_SSDONE
;
286 cur
->post_handler(cur
, regs
, 0);
289 resume_execution(cur
, regs
, kcb
);
291 /*Restore back the original saved kprobes variables and continue. */
292 if (kcb
->kprobe_status
== KPROBE_REENTER
) {
293 restore_previous_kprobe(kcb
);
296 reset_current_kprobe();
298 preempt_enable_no_resched();
303 static inline int kprobe_fault_handler(struct pt_regs
*regs
, int trapnr
)
305 struct kprobe
*cur
= kprobe_running();
306 struct kprobe_ctlblk
*kcb
= get_kprobe_ctlblk();
307 const struct exception_table_entry
*entry
;
309 switch(kcb
->kprobe_status
) {
313 * We are here because the instruction being single
314 * stepped caused a page fault. We reset the current
315 * kprobe and the tpc points back to the probe address
316 * and allow the page fault handler to continue as a
319 regs
->tpc
= (unsigned long)cur
->addr
;
320 regs
->tnpc
= kcb
->kprobe_orig_tnpc
;
321 regs
->tstate
= ((regs
->tstate
& ~TSTATE_PIL
) |
322 kcb
->kprobe_orig_tstate_pil
);
323 if (kcb
->kprobe_status
== KPROBE_REENTER
)
324 restore_previous_kprobe(kcb
);
326 reset_current_kprobe();
327 preempt_enable_no_resched();
329 case KPROBE_HIT_ACTIVE
:
330 case KPROBE_HIT_SSDONE
:
332 * We increment the nmissed count for accounting,
333 * we can also use npre/npostfault count for accouting
334 * these specific fault cases.
336 kprobes_inc_nmissed_count(cur
);
339 * We come here because instructions in the pre/post
340 * handler caused the page_fault, this could happen
341 * if handler tries to access user space by
342 * copy_from_user(), get_user() etc. Let the
343 * user-specified handler try to fix it first.
345 if (cur
->fault_handler
&& cur
->fault_handler(cur
, regs
, trapnr
))
349 * In case the user-specified fault handler returned
350 * zero, try to fix up.
353 entry
= search_exception_tables(regs
->tpc
);
355 regs
->tpc
= entry
->fixup
;
356 regs
->tnpc
= regs
->tpc
+ 4;
361 * fixup_exception() could not handle it,
362 * Let do_page_fault() fix it.
373 * Wrapper routine to for handling exceptions.
375 int __kprobes
kprobe_exceptions_notify(struct notifier_block
*self
,
376 unsigned long val
, void *data
)
378 struct die_args
*args
= (struct die_args
*)data
;
379 int ret
= NOTIFY_DONE
;
381 if (args
->regs
&& user_mode(args
->regs
))
386 if (kprobe_handler(args
->regs
))
390 if (post_kprobe_handler(args
->regs
))
395 /* kprobe_running() needs smp_processor_id() */
397 if (kprobe_running() &&
398 kprobe_fault_handler(args
->regs
, args
->trapnr
))
408 asmlinkage
void __kprobes
kprobe_trap(unsigned long trap_level
,
409 struct pt_regs
*regs
)
411 BUG_ON(trap_level
!= 0x170 && trap_level
!= 0x171);
413 if (user_mode(regs
)) {
415 bad_trap(regs
, trap_level
);
419 /* trap_level == 0x170 --> ta 0x70
420 * trap_level == 0x171 --> ta 0x71
422 if (notify_die((trap_level
== 0x170) ? DIE_DEBUG
: DIE_DEBUG_2
,
423 (trap_level
== 0x170) ? "debug" : "debug_2",
424 regs
, 0, trap_level
, SIGTRAP
) != NOTIFY_STOP
)
425 bad_trap(regs
, trap_level
);
428 /* Jprobes support. */
429 int __kprobes
setjmp_pre_handler(struct kprobe
*p
, struct pt_regs
*regs
)
431 struct jprobe
*jp
= container_of(p
, struct jprobe
, kp
);
432 struct kprobe_ctlblk
*kcb
= get_kprobe_ctlblk();
434 kcb
->jprobe_saved_regs_location
= regs
;
435 memcpy(&(kcb
->jprobe_saved_regs
), regs
, sizeof(*regs
));
437 /* Save a whole stack frame, this gets arguments
438 * pushed onto the stack after using up all the
441 memcpy(&(kcb
->jprobe_saved_stack
),
442 (char *) (regs
->u_regs
[UREG_FP
] + STACK_BIAS
),
443 sizeof(kcb
->jprobe_saved_stack
));
445 regs
->tpc
= (unsigned long) jp
->entry
;
446 regs
->tnpc
= ((unsigned long) jp
->entry
) + 0x4UL
;
447 regs
->tstate
|= TSTATE_PIL
;
452 void __kprobes
jprobe_return(void)
454 __asm__
__volatile__(
455 ".globl jprobe_return_trap_instruction\n"
456 "jprobe_return_trap_instruction:\n\t"
460 extern void jprobe_return_trap_instruction(void);
462 extern void __show_regs(struct pt_regs
* regs
);
464 int __kprobes
longjmp_break_handler(struct kprobe
*p
, struct pt_regs
*regs
)
466 u32
*addr
= (u32
*) regs
->tpc
;
467 struct kprobe_ctlblk
*kcb
= get_kprobe_ctlblk();
469 if (addr
== (u32
*) jprobe_return_trap_instruction
) {
470 if (kcb
->jprobe_saved_regs_location
!= regs
) {
471 printk("JPROBE: Current regs (%p) does not match "
472 "saved regs (%p).\n",
473 regs
, kcb
->jprobe_saved_regs_location
);
474 printk("JPROBE: Saved registers\n");
475 __show_regs(kcb
->jprobe_saved_regs_location
);
476 printk("JPROBE: Current registers\n");
480 /* Restore old register state. Do pt_regs
481 * first so that UREG_FP is the original one for
482 * the stack frame restore.
484 memcpy(regs
, &(kcb
->jprobe_saved_regs
), sizeof(*regs
));
486 memcpy((char *) (regs
->u_regs
[UREG_FP
] + STACK_BIAS
),
487 &(kcb
->jprobe_saved_stack
),
488 sizeof(kcb
->jprobe_saved_stack
));
490 preempt_enable_no_resched();
496 /* architecture specific initialization */
497 int arch_init_kprobes(void)