From: Prasanna S Panchamukhi Minor changes required to port kprobes for x86_64. - arch_prepare_kprobe() returns an integer. - added arch_remove_kprobe(). - changes to access copy of original instruction, since kprobe_opcode_t insn[MAX_INSN_SIZE] is moved from struct kprobe to a struct arch_specific_insn. Signed-off-by: Prasanna S Panchamukhi Signed-off-by: Andrew Morton --- 25-akpm/arch/sparc64/kernel/kprobes.c | 29 +++++++++++++++++------------ 25-akpm/include/asm-sparc64/kprobes.h | 6 ++++++ 2 files changed, 23 insertions(+), 12 deletions(-) diff -puN arch/sparc64/kernel/kprobes.c~kprobes-minor-changes-for-sparc64 arch/sparc64/kernel/kprobes.c --- 25/arch/sparc64/kernel/kprobes.c~kprobes-minor-changes-for-sparc64 Mon Nov 1 15:37:40 2004 +++ 25-akpm/arch/sparc64/kernel/kprobes.c Mon Nov 1 15:37:40 2004 @@ -15,7 +15,7 @@ * traps. The top-level scheme is similar to that used * in the x86 kprobes implementation. * - * In the kprobe->insn[] array we store the original + * In the kprobe->ainsn.insn[] array we store the original * instruction at index zero and a break instruction at * index one. * @@ -24,12 +24,12 @@ * - Remember "regs->tnpc" and interrupt level stored in * "regs->tstate" so we can restore them later * - Disable PIL interrupts - * - Set regs->tpc to point to kprobe->insn[0] - * - Set regs->tnpc to point to kprobe->insn[1] + * - Set regs->tpc to point to kprobe->ainsn.insn[0] + * - Set regs->tnpc to point to kprobe->ainsn.insn[1] * - Mark that we are actively in a kprobe * * At this point we wait for the second breakpoint at - * kprobe->insn[1] to hit. When it does we: + * kprobe->ainsn.insn[1] to hit. When it does we: * - Run the post-handler * - Set regs->tpc to "remembered" regs->tnpc stored above, * restore the PIL interrupt level in "regs->tstate" as well @@ -38,10 +38,15 @@ * - Mark that we are no longer actively in a kprobe. */ -void arch_prepare_kprobe(struct kprobe *p) +int arch_prepare_kprobe(struct kprobe *p) +{ + p->ainsn.insn[0] = *p->addr; + p->ainsn.insn[1] = BREAKPOINT_INSTRUCTION_2; + return 0; +} + +void arch_remove_kprobe(struct kprobe *p) { - p->insn[0] = *p->addr; - p->insn[1] = BREAKPOINT_INSTRUCTION_2; } /* kprobe_status settings */ @@ -59,8 +64,8 @@ static inline void prepare_singlestep(st current_kprobe_orig_tstate_pil = (regs->tstate & TSTATE_PIL); regs->tstate |= TSTATE_PIL; - regs->tpc = (unsigned long) &p->insn[0]; - regs->tnpc = (unsigned long) &p->insn[1]; + regs->tpc = (unsigned long) &p->ainsn.insn[0]; + regs->tnpc = (unsigned long) &p->ainsn.insn[1]; } static inline void disarm_kprobe(struct kprobe *p, struct pt_regs *regs) @@ -199,19 +204,19 @@ static void retpc_fixup(struct pt_regs * * instruction. To avoid the SMP problems that can occur when we * temporarily put back the original opcode to single-step, we * single-stepped a copy of the instruction. The address of this - * copy is p->insn. + * copy is p->ainsn.insn. * * This function prepares to return from the post-single-step * breakpoint trap. */ static void resume_execution(struct kprobe *p, struct pt_regs *regs) { - u32 insn = p->insn[0]; + u32 insn = p->ainsn.insn[0]; regs->tpc = current_kprobe_orig_tnpc; regs->tnpc = relbranch_fixup(insn, (unsigned long) p->addr, - (unsigned long) &p->insn[0], + (unsigned long) &p->ainsn.insn[0], regs->tnpc); retpc_fixup(regs, insn, (unsigned long) p->addr); diff -puN include/asm-sparc64/kprobes.h~kprobes-minor-changes-for-sparc64 include/asm-sparc64/kprobes.h --- 25/include/asm-sparc64/kprobes.h~kprobes-minor-changes-for-sparc64 Mon Nov 1 15:37:40 2004 +++ 25-akpm/include/asm-sparc64/kprobes.h Mon Nov 1 15:37:40 2004 @@ -10,6 +10,12 @@ typedef u32 kprobe_opcode_t; #define BREAKPOINT_INSTRUCTION_2 0x91d02071 /* ta 0x71 */ #define MAX_INSN_SIZE 2 +/* Architecture specific copy of original instruction*/ +struct arch_specific_insn { + /* copy of the original instruction */ + kprobe_opcode_t insn[MAX_INSN_SIZE]; +}; + #ifdef CONFIG_KPROBES extern int kprobe_exceptions_notify(struct notifier_block *self, unsigned long val, void *data); _