Subject: kprobes-x86: correct post-eip value in post_hander()
PATCH 1/1 Subject: kprobes-x86: correct post-eip value in post_hander()
I was trying to get the address of instruction to be executed next after the kprobed instruction. But regs->eip in post_handler() contains value which is useless to the user. It's pre-corrected value. This value is difficult to use without access to resume_execution(), which is not exported anyway.
I moved the invocation of post_handler() to *after* resume_execution(). Now regs->eip contains meaningful value in post_handler().
I do not think this change breaks any backward-compatibility. To make meaning of the old value, post_handler() would need access to resume_execution() which is not exported. I have difficulty to believe that previous, uncorrected, regs->eip can be meaningfully used in post_handler().
--- arch/x86/kernel/kprobes.c | 8 ++++---- 1 files changed, 4 insertions(+), 4 deletions(-)
arch/x86/kernel/kprobes.c +4 -4
@@ -858,15 +858,15 @@ static int __kprobes post_kprobe_handler(struct pt_regs *regs)if (!cur)return 0 ; +resume_execution (cur, regs, kcb); + regs->flags |= kcb->kprobe_saved_flags; +trace_hardirqs_fixup_flags (regs->flags); +if ((kcb->kprobe_status !=KPROBE_REENTER ) && cur->post_handler) { kcb->kprobe_status =KPROBE_HIT_SSDONE ; cur->post_handler (cur, regs,0 ); } -resume_execution (cur, regs, kcb); - regs->flags |= kcb->kprobe_saved_flags; -trace_hardirqs_fixup_flags (regs->flags); -/* Restore back the original saved kprobes variables and continue. */ if (kcb->kprobe_status ==KPROBE_REENTER ) {restore_previous_kprobe (kcb);
Signature · 1 line
1.5.4.4
Quoted 9 lines · Yakov Lerner
I was trying to get the address of instruction to be executed next after the kprobed instruction. But
regs->eipinpost_handler()contains value which is useless to the user. It's pre-corrected value. This value is difficult to use without access toresume_execution(), which is not exported anyway.
I moved the invocation ofpost_handler()to *after*resume_execution(). Nowregs->eipcontains meaningful value inpost_handler().
Quoted 5 lines
I do not think this change breaks any backward-compatibility. To make meaning of the old value,
post_handler()would need access toresume_execution()which is not exported. I have difficulty to believe that previous, uncorrected,regs->eipcan be meaningfully used inpost_handler().
resume_execution() exists not just for the program counter fixups after out-of-line singlestepping, but is also as an insurance to put the program counter back to the correct address in case the user's post_handler() mucks around with it. That isn't possible with this change :-(
Ananth
Quoted 16 lines · Ananth N Mavinakayanahalli
Quoted 9 lines · Yakov Lerner
I was trying to get the address of instruction to be executed next after the kprobed instruction. But
regs->eipinpost_handler()contains value which is useless to the user. It's pre-corrected value. This value is difficult to use without access toresume_execution(), which is not exported anyway.
I moved the invocation ofpost_handler()to *after*resume_execution(). Nowregs->eipcontains meaningful value inpost_handler().Quoted 5 lines
I do not think this change breaks any backward-compatibility. To make meaning of the old value,
post_handler()would need access toresume_execution()which is not exported. I have difficulty to believe that previous, uncorrected,regs->eipcan be meaningfully used inpost_handler().
Quoted 5 lines
resume_execution()exists not just for the program counter fixups after out-of-line singlestepping, but is also as an insurance to put the program counter back to the correct address in case the user'spost_handler()mucks around with it. That isn't possible with this change :-(
I see your point. This can be prevented by saving and restoring regs->ip around the post_handler() call, no ? Current code is beautiful. Saving and restoring regs->ip would make this place look ugly.
Otoh, if the post_handler() wants to crash the kernel, it can do it in thousand ways, not just by trashing regs->ip, no ?
Yakov
Quoted 24 lines · Yakov Lerner
Quoted 16 lines · Ananth N Mavinakayanahalli
Quoted 9 lines · Yakov Lerner
I was trying to get the address of instruction to be executed next after the kprobed instruction. But
regs->eipinpost_handler()contains value which is useless to the user. It's pre-corrected value. This value is difficult to use without access toresume_execution(), which is not exported anyway.
I moved the invocation ofpost_handler()to *after*resume_execution(). Nowregs->eipcontains meaningful value inpost_handler().Quoted 5 lines
I do not think this change breaks any backward-compatibility. To make meaning of the old value,
post_handler()would need access toresume_execution()which is not exported. I have difficulty to believe that previous, uncorrected,regs->eipcan be meaningfully used inpost_handler().Quoted 5 lines
resume_execution()exists not just for the program counter fixups after out-of-line singlestepping, but is also as an insurance to put the program counter back to the correct address in case the user'spost_handler()mucks around with it. That isn't possible with this change :-(
Quoted 6 lines
I see your point. This can be prevented by saving and restoring
regs->iparound thepost_handler()call, no ? Current code is beautiful. Saving and restoringregs->ipwould make this place look ugly.Otoh, if the
post_handler()wants to crash the kernel, it can do it in thousand ways, not just by trashingregs->ip, no ?
Of course, there still are other ways to shoot yourself in the foot with the post_handler(), but, atleast for cases we can control, we need to do the right thing.
Ananth
Quoted 28 lines · Ananth N Mavinakayanahalli
Quoted 27 lines · Yakov Lerner
Quoted 16 lines · Ananth N Mavinakayanahalli
Quoted 9 lines · Yakov Lerner
I was trying to get the address of instruction to be executed next after the kprobed instruction. But
regs->eipinpost_handler()contains value which is useless to the user. It's pre-corrected value. This value is difficult to use without access toresume_execution(), which is not exported anyway.
I moved the invocation ofpost_handler()to *after*resume_execution(). Nowregs->eipcontains meaningful value inpost_handler().Quoted 5 lines
I do not think this change breaks any backward-compatibility. To make meaning of the old value,
post_handler()would need access toresume_execution()which is not exported. I have difficulty to believe that previous, uncorrected,regs->eipcan be meaningfully used inpost_handler().Quoted 5 lines
resume_execution()exists not just for the program counter fixups after out-of-line singlestepping, but is also as an insurance to put the program counter back to the correct address in case the user'spost_handler()mucks around with it. That isn't possible with this change :-(I see your point. This can be prevented by saving and restoring
regs->iparound thepost_handler()call, no ? Current code is beautiful. Saving and restoringregs->ipwould make this place look ugly.
Quoted 6 lines
Quoted 2 lines
Otoh, if the
post_handler()wants to crash the kernel, it can do it in thousand ways, not just by trashingregs->ip, no ?Of course, there still are other ways to shoot yourself in the foot with the
post_handler(), but, atleast for cases we can control, we need to do the right thing.
Ananth, I think we can not prevent it even if resume_execution() is called after post_handler, because resume_execution() refers reg->ip...:-(
And Yakov, I think you might need to make a patchset against all arch which support kprobes, because this patch modifies expected behavior of kprobes only on x86.
IMHO, Yakov's suggestion will be also good for resume_execution(), because it only has to clean up after expectable-single-stepping. (user code is unexpectable... we can not control all of that)
Thanks,
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America) Inc. Software Solutions Division e-mail: [email protected]
Quoted 32 lines · Masami Hiramatsu
Quoted 31 lines · Ananth N Mavinakayanahalli
Quoted 29 lines · Yakov Lerner
Quoted 16 lines · Ananth N Mavinakayanahalli
Quoted 9 lines · Yakov Lerner
I was trying to get the address of instruction to be executed next after the kprobed instruction. But
regs->eipinpost_handler()contains value which is useless to the user. It's pre-corrected value. This value is difficult to use without access toresume_execution(), which is not exported anyway.
I moved the invocation ofpost_handler()to *after*resume_execution(). Nowregs->eipcontains meaningful value inpost_handler().Quoted 5 lines
I do not think this change breaks any backward-compatibility. To make meaning of the old value,
post_handler()would need access toresume_execution()which is not exported. I have difficulty to believe that previous, uncorrected,regs->eipcan be meaningfully used inpost_handler().Quoted 5 lines
resume_execution()exists not just for the program counter fixups after out-of-line singlestepping, but is also as an insurance to put the program counter back to the correct address in case the user'spost_handler()mucks around with it. That isn't possible with this change :-(I see your point. This can be prevented by saving and restoring
regs->iparound thepost_handler()call, no ? Current code is beautiful. Saving and restoringregs->ipwould make this place look ugly.Otoh, if the
post_handler()wants to crash the kernel, it can do it in thousand ways, not just by trashingregs->ip, no ?
Quoted 6 lines
Quoted 3 lines
Of course, there still are other ways to shoot yourself in the foot with the
post_handler(), but, atleast for cases we can control, we need to do the right thing.Ananth, I think we can not prevent it even if
resume_execution()is called afterpost_handler, becauseresume_execution()refers reg->ip...:-(
OK, I see what you are referring to... though we use kp.addr and kp.ainsn.insn to start with, we'll need the knowledge of regs->ip at the end.
Quoted 3 lines
And Yakov, I think you might need to make a patchset against all arch which support kprobes, because this patch modifies expected behavior of kprobes only on x86.
Agreed.
Quoted 3 lines
IMHO, Yakov's suggestion will be also good for
resume_execution(), because it only has to clean up after expectable-single-stepping. (user code is unexpectable... we can not control all of that)
Ananth
Quoted 8 lines · Yakov Lerner
I was trying to get the address of instruction to be executed next after the kprobed instruction. But
regs->eipinpost_handler()contains value which is useless to the user. It's pre-corrected value. This value is difficult to use without access toresume_execution(), which is not exported anyway. I moved the invocation ofpost_handler()to *after*resume_execution(). Nowregs->eipcontains meaningful value inpost_handler().
Quoted 5 lines
I do not think this change breaks any backward-compatibility. To make meaning of the old value,
post_handler()would need access toresume_execution()which is not exported. I have difficulty to believe that previous, uncorrected,regs->eipcan be meaningfully used inpost_handler().
thanks, i've added your patch to the .26 bucket of x86.git, but it would be nice to get an Ack/Nack from a kprobes person as well.
Ingo
Ananth N Mavinakayanahalli
Acked-byQuoted 11 lines · Ingo Molnar
Quoted 8 lines · Yakov Lerner
I was trying to get the address of instruction to be executed next after the kprobed instruction. But
regs->eipinpost_handler()contains value which is useless to the user. It's pre-corrected value. This value is difficult to use without access toresume_execution(), which is not exported anyway. I moved the invocation ofpost_handler()to *after*resume_execution(). Nowregs->eipcontains meaningful value inpost_handler().
Quoted 8 lines
Quoted 5 lines
I do not think this change breaks any backward-compatibility. To make meaning of the old value,
post_handler()would need access toresume_execution()which is not exported. I have difficulty to believe that previous, uncorrected,regs->eipcan be meaningfully used inpost_handler().thanks, i've added your patch to the .26 bucket of x86.git, but it would be nice to get an Ack/Nack from a kprobes person as well.
Ingo,
I've tested Yakov's more comprehensive patch on powerpc too. This has my ack.
Ingo Molnar
Acked-by Ananth N MavinakayanahalliQuoted 9 lines · Ananth N Mavinakayanahalli
Quoted 2 lines
thanks, i've added your patch to the .26 bucket of x86.git, but it would be nice to get an Ack/Nack from a kprobes person as well.
Ingo,
I've tested Yakov's more comprehensive patch on powerpc too. This has my ack.
thanks, i've queued up the x86-only patch below for .26 merging. (that is all that is needed for x86, and no .25 urgency, right?)
Ingo
------------------>
Subject: x86, kprobes: correct post-eip value in post_hander()
From: "Yakov Lerner" <[email protected]>
Date: Sun, 16 Mar 2008 03:21:21 -0500
I was trying to get the address of instruction to be executed next after the kprobed instruction. But regs->eip in post_handler() contains value which is useless to the user. It's pre-corrected value. This value is difficult to use without access to resume_execution(), which is not exported anyway.
I moved the invocation of post_handler() to *after* resume_execution(). Now regs->eip contains meaningful value in post_handler().
I do not think this change breaks any backward-compatibility. To make meaning of the old value, post_handler() would need access to resume_execution() which is not exported. I have difficulty to believe that previous, uncorrected, regs->eip can be meaningfully used in post_handler().
--- arch/x86/kernel/kprobes.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
arch/x86/kernel/kprobes.c +4 -4
@@ -858,15 +858,15 @@ static int __kprobes post_kprobe_handlerif (!cur)return 0 ; +resume_execution (cur, regs, kcb); + regs->flags |= kcb->kprobe_saved_flags; +trace_hardirqs_fixup_flags (regs->flags); +if ((kcb->kprobe_status !=KPROBE_REENTER ) && cur->post_handler) { kcb->kprobe_status =KPROBE_HIT_SSDONE ; cur->post_handler (cur, regs,0 ); } -resume_execution (cur, regs, kcb); - regs->flags |= kcb->kprobe_saved_flags; -trace_hardirqs_fixup_flags (regs->flags); -/* Restore back the original saved kprobes variables and continue. */ if (kcb->kprobe_status ==KPROBE_REENTER ) {restore_previous_kprobe (kcb);
Quoted 8 lines · Ingo Molnar
Quoted 5 lines · Ananth N Mavinakayanahalli
Quoted 2 lines
thanks, i've added your patch to the .26 bucket of x86.git, but it would be nice to get an Ack/Nack from a kprobes person as well.
Ingo,
Quoted 7 lines
Quoted 4 lines
I've tested Yakov's more comprehensive patch on powerpc too. This has my ack.
thanks, i've queued up the x86-only patch below for .26 merging. (that is all that is needed for x86, and no .25 urgency, right?)
Yup. This can wait for .26
Ananth
Masami Hiramatsu
Acked-byQuoted 16 lines · Ingo Molnar
Quoted 8 lines · Yakov Lerner
I was trying to get the address of instruction to be executed next after the kprobed instruction. But
regs->eipinpost_handler()contains value which is useless to the user. It's pre-corrected value. This value is difficult to use without access toresume_execution(), which is not exported anyway. I moved the invocation ofpost_handler()to *after*resume_execution(). Nowregs->eipcontains meaningful value inpost_handler().Quoted 5 lines
I do not think this change breaks any backward-compatibility. To make meaning of the old value,
post_handler()would need access toresume_execution()which is not exported. I have difficulty to believe that previous, uncorrected,regs->eipcan be meaningfully used inpost_handler().
Quoted 4 lines
thanks, i've added your patch to the .26 bucket of x86.git, but it would be nice to get an Ack/Nack from a kprobes person as well.
Ingo
Ingo, I also tested this on x86-64/x86/ia64.
Thanks,
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America) Inc. Software Solutions Division e-mail: [email protected]