arm64: implement KPROBES_ON_FTRACE
Subsystems (5)
v7 cover arm64: implement KPROBES_ON_FTRACE
KPROBES_ON_FTRACE avoids much of the overhead with regular kprobes as it eliminates the need for a trap, as well as the need to emulate or single-step instructions.
arm64 makes use of GCC -fpatchable-function-entry=2 option to insert two nops. When the function is traced, the first nop will be modified to the LR saver, then the second nop to "bl <ftrace-entry>". We need to allow kprobe on any of these two instructions.
patch1 uses ftrace_location() when [dis]arming probes. patch2 introduces FTRACE_IP_EXTENSION to let ftrace_location() recognise these two instructions as being part of ftrace patch3 implement the KPROBES_ON_FTRACE for arm64
Changes since v6:
- add patch1 and patch2
- fix the automatic offset as pointed out by Masami
Changes since v5:
- rebase v5.5-rc1
- collect Acked-by and Reviewed-by tags
Changes since v4:
- correct reg->pc: probed on foo, then pre_handler see foo+0x4, while
post_handler see foo+0x8
Changes since v3:
- move kprobe_lookup_name() and arch_kprobe_on_func_entry to ftrace.c since we only want to choose the ftrace entry for KPROBES_ON_FTRACE.
- only choose ftrace entry if (addr && !offset)
Changes since v2:
- remove patch1, make it a single cleanup patch
- remove "This patch" in the change log
- implement arm64's kprobe_lookup_name() and arch_kprobe_on_func_entry instead of patching the common kprobes code
Changes since v1:
- make the kprobes/x86: use instruction_pointer and instruction_pointer_set as patch1
- add Masami's ACK to patch1
- add some description about KPROBES_ON_FTRACE and why we need it on
arm64
- correct the log before the patch
- remove the consolidation patch, make it as TODO
- only adjust kprobe's addr when KPROBE_FLAG_FTRACE is set
- if KPROBES_ON_FTRACE, ftrace_call_adjust() the kprobe's addr before calling ftrace_location()
- update the kprobes-on-ftrace/arch-support.txt in doc
Jisheng Zhang (2):
ftrace: introduce FTRACE_IP_EXTENSION
arm64: implement KPROBES_ON_FTRACE
Naveen N. Rao (1):
kprobes/ftrace: Use ftrace_location() when [dis]arming probes
.../debug/kprobes-on-ftrace/arch-support.txt | 2 +- arch/arm64/Kconfig | 1 + arch/arm64/include/asm/ftrace.h | 1 + arch/arm64/kernel/probes/Makefile | 1 + arch/arm64/kernel/probes/ftrace.c | 78 +++++++++++++++++++ include/linux/ftrace.h | 4 + kernel/kprobes.c | 8 +- kernel/trace/ftrace.c | 2 +- 8 files changed, 92 insertions(+), 5 deletions(-) create mode 100644 arch/arm64/kernel/probes/ftrace.c
Signature · 7 lines
2.24.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v7 1/3 kprobes/ftrace: Use ftrace_location() when [dis]arming probes
Ftrace location could include more than a single instruction in case of some architectures (powerpc64, for now). In this case, kprobe is permitted on any of those instructions, and uses ftrace infrastructure for functioning.
However, [dis]arm_kprobe_ftrace() uses the kprobe address when setting up ftrace filter IP. This won't work if the address points to any instruction apart from the one that has a branch to _mcount(). To resolve this, have [dis]arm_kprobe_ftrace() use ftrace_function() to identify the filter IP.
--- kernel/kprobes.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-)
kernel/kprobes.c +5 -3
@@ -986,9 +986,10 @@ static int prepare_kprobe(struct kprobe *p)static int __arm_kprobe_ftrace (struct kprobe *p,struct ftrace_ops *ops,int *cnt) { +unsigned long ftrace_ip =ftrace_location ((unsigned long )p->addr);int ret =0 ; - ret =ftrace_set_filter_ip (ops, (unsigned long )p->addr,0 ,0 ); + ret =ftrace_set_filter_ip (ops, ftrace_ip,0 ,0 );if (ret) {pr_debug ("Failed to arm kprobe-ftrace at %pS (%d)\n" , p->addr, ret);
@@ -1011,7 +1012,7 @@ static int __arm_kprobe_ftrace(struct kprobe *p, struct ftrace_ops *ops,* At this point, sinec ops is not registered, we should be sefe from * registering empty filter. */ -ftrace_set_filter_ip (ops, (unsigned long )p->addr,1 ,0 ); +ftrace_set_filter_ip (ops, ftrace_ip,1 ,0 );return ret; }
@@ -1028,6 +1029,7 @@ static int arm_kprobe_ftrace(struct kprobe *p)static int __disarm_kprobe_ftrace (struct kprobe *p,struct ftrace_ops *ops,int *cnt) { +unsigned long ftrace_ip =ftrace_location ((unsigned long )p->addr);int ret =0 ;if (*cnt ==1 ) {
@@ -1038,7 +1040,7 @@ static int __disarm_kprobe_ftrace(struct kprobe *p, struct ftrace_ops *ops, (*cnt)--; - ret =ftrace_set_filter_ip (ops, (unsigned long )p->addr,1 ,0 ); + ret =ftrace_set_filter_ip (ops, ftrace_ip,1 ,0 );WARN_ONCE (ret <0 ,"Failed to disarm kprobe-ftrace at %pS (%d)\n" , p->addr, ret);return ret;
Signature · 1 line
2.24.1
Re: [PATCH v7 1/3] kprobes/ftrace: Use ftrace_location() when [dis]arming probes
Quoted 1 line · On Wed, 25 Dec 2019 09:42:07 +0000 Jisheng Zhang wrote:
oops, I missed "From: Naveen N. Rao <[email protected]>"
I will take care this point when posting new version.
Quoted 67 lines
Ftrace location could include more than a single instruction in case of some architectures (powerpc64, for now). In this case, kprobe is permitted on any of those instructions, and uses ftrace infrastructure for functioning.
However, [dis]arm_kprobe_ftrace() uses the kprobe address when setting up ftrace filter IP. This won't work if the address points to any instruction apart from the one that has a branch to
_mcount(). To resolve this, have [dis]arm_kprobe_ftrace() useftrace_function()to identify the filter IP.Signed-off-by Naveen N. Rao <[email protected]>Acked-by Masami Hiramatsu <[email protected]>--- kernel/kprobes.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-)kernel/kprobes.c +5
-4@@ -986,9 +986,10 @@ static int prepare_kprobe(struct kprobe *p)static int __arm_kprobe_ftrace (struct kprobe *p,struct ftrace_ops *ops,int *cnt) { +unsigned long ftrace_ip =ftrace_location ((unsigned long )p->addr);int ret =0 ; - ret =ftrace_set_filter_ip (ops, (unsigned long )p->addr,0 ,0 ); + ret =ftrace_set_filter_ip (ops, ftrace_ip,0 ,0 );if (ret) {pr_debug ("Failed to arm kprobe-ftrace at %pS (%d)\n" , p->addr, ret);@@ -1011,7 +1012,7 @@ static int __arm_kprobe_ftrace(struct kprobe *p, struct ftrace_ops *ops,* At this point, sinec ops is not registered, we should be sefe from * registering empty filter. */ -ftrace_set_filter_ip (ops, (unsigned long )p->addr,1 ,0 ); +ftrace_set_filter_ip (ops, ftrace_ip,1 ,0 );return ret; }@@ -1028,6 +1029,7 @@ static int arm_kprobe_ftrace(struct kprobe *p)static int __disarm_kprobe_ftrace (struct kprobe *p,struct ftrace_ops *ops,int *cnt) { +unsigned long ftrace_ip =ftrace_location ((unsigned long )p->addr);int ret =0 ;if (*cnt ==1 ) {@@ -1038,7 +1040,7 @@ static int __disarm_kprobe_ftrace(struct kprobe *p, struct ftrace_ops *ops, (*cnt)--; - ret =ftrace_set_filter_ip (ops, (unsigned long )p->addr,1 ,0 ); + ret =ftrace_set_filter_ip (ops, ftrace_ip,1 ,0 );WARN_ONCE (ret <0 ,"Failed to disarm kprobe-ftrace at %pS (%d)\n" , p->addr, ret);return ret; --2.24.1
_______________________________________________
linux-arm-kernel mailing list
[email protected]
https://urldefense.proofpoint.com/v2/url?u=http-3A__lists.infradead.org_mailman_listinfo_linux-2Darm-2Dkernel&d=DwICAg&c=7dfBJ8cXbWjhc0BhImu8wQ&r=wlaKTGoVCDxOzHc2QUzpzGEf9oY3eidXlAe3OF1omvo&m=BG5GowWc97yveg-i3gFbh3N7PDT3S3FwcxnpOSRpvIs&s=plWeJUToTNi5CWx998a_VbVx3eFc-MNhUNv4fLpmyiU&e=
PATCH v7 2/3 ftrace: introduce FTRACE_IP_EXTENSION
In reply to Jisheng ZhangOn some architectures, the DYNAMIC_FTRACE_WITH_REGS is implemented by gcc's -fpatchable-function-entry option. Take arm64 for example, arm64 makes use of GCC -fpatchable-function-entry=2 option to insert two nops. When the function is traced, the first nop will be modified to the LR saver, then the second nop to "bl <ftrace-entry>". we need to update ftrace_location() to recognise these two instructions as being part of ftrace. To do this, we introduce FTRACE_IP_EXTENSION to let ftrace_location search IP, IP + FTRACE_IP_EXTENSION range.
--- include/linux/ftrace.h | 4 ++++ kernel/trace/ftrace.c | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-)
include/linux/ftrace.h +4 -0
@@ -20,6 +20,10 @@#include <asm/ftrace.h> +#ifndef FTRACE_IP_EXTENSION +#define FTRACE_IP_EXTENSION 0 +#endif +/* * If the arch supports passing the variable contents of * function_trace_op as the third parameter back from the
kernel/trace/ftrace.c +1 -1
@@ -1590,7 +1590,7 @@ unsigned long ftrace_location_range(unsigned long start, unsigned long end)*/ unsigned long ftrace_location (unsigned long ip) { -return ftrace_location_range (ip, ip); +return ftrace_location_range (ip, ip +FTRACE_IP_EXTENSION ); }/**
Signature · 1 line
2.24.1
Re: [PATCH v7 2/3] ftrace: introduce FTRACE_IP_EXTENSION
Quoted 9 lines · On Wed, 25 Dec 2019 09:42:52 +0000 Jisheng Zhang <[email protected]>…
On some architectures, the
DYNAMIC_FTRACE_WITH_REGSis implemented by gcc's -fpatchable-function-entry option. Take arm64 for example, arm64 makes use of GCC -fpatchable-function-entry=2 option to insert two nops. When the function is traced, the first nop will be modified to the LR saver, then the second nop to "bl <ftrace-entry>". we need to updateftrace_location()to recognise these two instructions as being part of ftrace. To do this, we introduceFTRACE_IP_EXTENSIONto letftrace_locationsearch IP, IP +FTRACE_IP_EXTENSIONrange.
Looks good to me.
Thanks!
Quoted 38 lines
Signed-off-by Jisheng Zhang <[email protected]>Suggested-by Steven Rostedt (VMware) <[email protected]>--- include/linux/ftrace.h | 4 ++++ kernel/trace/ftrace.c | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-)include/linux/ftrace.h +4
-0@@ -20,6 +20,10 @@#include <asm/ftrace.h> +#ifndef FTRACE_IP_EXTENSION +#define FTRACE_IP_EXTENSION 0 +#endif +/* * If the arch supports passing the variable contents of * function_trace_op as the third parameter back from the kernel/trace/ftrace.c +1
-1@@ -1590,7 +1590,7 @@ unsigned long ftrace_location_range(unsigned long start, unsigned long end)*/ unsigned long ftrace_location (unsigned long ip) { -return ftrace_location_range (ip, ip); +return ftrace_location_range (ip, ip +FTRACE_IP_EXTENSION ); }/** Signature · 1 line
2.24.1
Signature · 1 line
Masami Hiramatsu <[email protected]>
Re: [PATCH v7 2/3] ftrace: introduce FTRACE_IP_EXTENSION
In reply to Jisheng ZhangQuoted 11 lines · On Wed, 25 Dec 2019 09:42:52 +0000 Jisheng Zhang <[email protected]>…
On some architectures, the
DYNAMIC_FTRACE_WITH_REGSis implemented by gcc's -fpatchable-function-entry option. Take arm64 for example, arm64 makes use of GCC -fpatchable-function-entry=2 option to insert two nops. When the function is traced, the first nop will be modified to the LR saver, then the second nop to "bl <ftrace-entry>". we need to updateftrace_location()to recognise these two instructions as being part of ftrace. To do this, we introduceFTRACE_IP_EXTENSIONto letftrace_locationsearch IP, IP +FTRACE_IP_EXTENSIONrange.Signed-off-by Jisheng Zhang <[email protected]>Suggested-by Steven Rostedt (VMware) <[email protected]>
You can also add:
and when Masami is happy with your patches, it should go through the tip tree.
Thanks!
-- Steve
Quoted 33 lines
--- include/linux/ftrace.h | 4 ++++ kernel/trace/ftrace.c | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-)include/linux/ftrace.h +4
-0@@ -20,6 +20,10 @@#include <asm/ftrace.h> +#ifndef FTRACE_IP_EXTENSION +#define FTRACE_IP_EXTENSION 0 +#endif +/* * If the arch supports passing the variable contents of * function_trace_op as the third parameter back from the kernel/trace/ftrace.c +1
-1@@ -1590,7 +1590,7 @@ unsigned long ftrace_location_range(unsigned long start, unsigned long end)*/ unsigned long ftrace_location (unsigned long ip) { -return ftrace_location_range (ip, ip); +return ftrace_location_range (ip, ip +FTRACE_IP_EXTENSION ); }/**
PATCH v7 3/3 arm64: implement KPROBES_ON_FTRACE
In reply to Jisheng ZhangKPROBES_ON_FTRACE avoids much of the overhead with regular kprobes as it eliminates the need for a trap, as well as the need to emulate or single-step instructions.
Tested on berlin arm64 platform.
~ # mount -t debugfs debugfs /sys/kernel/debug/
~ # cd /sys/kernel/debug//sys/kernel/debug # echo 'p _do_fork' > tracing/kprobe_events
before the patch:
/sys/kernel/debug # cat kprobes/listffffff801009fe28 k _do_fork+0x0 [DISABLED]
after the patch:
/sys/kernel/debug # cat kprobes/listffffff801009ff54 k _do_fork+0x0 [DISABLED][FTRACE]
--- .../debug/kprobes-on-ftrace/arch-support.txt | 2 +- arch/arm64/Kconfig | 1 + arch/arm64/include/asm/ftrace.h | 1 + arch/arm64/kernel/probes/Makefile | 1 + arch/arm64/kernel/probes/ftrace.c | 78 +++++++++++++++++++ 5 files changed, 82 insertions(+), 1 deletion(-) create mode 100644 arch/arm64/kernel/probes/ftrace.c
Documentation/features/debug/kprobes-on-ftrace/arch-support.txt +1 -1
@@ -9,7 +9,7 @@ | alpha: | TODO | | arc: | TODO | | arm: | TODO | - | arm64: | TODO | + | arm64: | ok | | c6x: | TODO | | csky: | TODO | | h8300: | TODO |
arch/arm64/Kconfig +1 -0
@@ -166,6 +166,7 @@ config ARM64 select HAVE_STACKPROTECTOR select HAVE_SYSCALL_TRACEPOINTS select HAVE_KPROBES + select HAVE_KPROBES_ON_FTRACE select HAVE_KRETPROBES select HAVE_GENERIC_VDSO select IOMMU_DMA if IOMMU_SUPPORT
arch/arm64/include/asm/ftrace.h +1 -0
@@ -20,6 +20,7 @@/* The BL at the callsite's adjusted rec->ip */ #define MCOUNT_INSN_SIZE AARCH64_INSN_SIZE +#define FTRACE_IP_EXTENSION MCOUNT_INSN_SIZE#define FTRACE_PLT_IDX 0#define FTRACE_REGS_PLT_IDX 1
arch/arm64/kernel/probes/Makefile +1 -0
@@ -4,3 +4,4 @@ obj-$(CONFIG_KPROBES) += kprobes.o decode-insn.o \ simulate-insn.o obj-$(CONFIG_UPROBES) += uprobes.o decode-insn.o \ simulate-insn.o +obj-$(CONFIG_KPROBES_ON_FTRACE) += ftrace.o
arch/arm64/kernel/probes/ftrace.c new file +78 -0
78 lines not on this page · raw message
Signature · 1 line
2.24.1
Masami Hiramatsu
maintainerHi Jisheng,
Quoted 12 lines · On Wed, 25 Dec 2019 09:44:21 +0000 Jisheng Zhang <[email protected]>…
KPROBES_ON_FTRACEavoids much of the overhead with regular kprobes as it eliminates the need for a trap, as well as the need to emulate or single-step instructions.Tested on berlin arm64 platform.
~ # mount -t debugfs debugfs
/sys/kernel/debug/
~ # cd/sys/kernel/debug//sys/kernel/debug# echo 'p_do_fork' > tracing/kprobe_eventsbefore the patch:
Quoted 7 lines
/sys/kernel/debug# cat kprobes/listffffff801009fe28k_do_fork+0x0[DISABLED]after the patch:
/sys/kernel/debug# cat kprobes/listffffff801009ff54k_do_fork+0x0[DISABLED][FTRACE]
What happens if user puts a probe on _do_fork+4?
Is that return -EILSEQ correctly?
Quoted 68 lines
Signed-off-by Jisheng Zhang <[email protected]>--- .../debug/kprobes-on-ftrace/arch-support.txt | 2 +- arch/arm64/Kconfig | 1 + arch/arm64/include/asm/ftrace.h | 1 + arch/arm64/kernel/probes/Makefile | 1 + arch/arm64/kernel/probes/ftrace.c | 78 +++++++++++++++++++ 5 files changed, 82 insertions(+), 1 deletion(-) create mode 100644 arch/arm64/kernel/probes/ftrace.cDocumentation/features/debug/kprobes-on-ftrace/arch-support.txt +1
-1@@ -9,7 +9,7 @@ | alpha: | TODO | | arc: | TODO | | arm: | TODO | - | arm64: | TODO | + | arm64: | ok | | c6x: | TODO | | csky: | TODO | | h8300: | TODO |arch/arm64/Kconfig +1
-0@@ -166,6 +166,7 @@ config ARM64 select HAVE_STACKPROTECTOR select HAVE_SYSCALL_TRACEPOINTS select HAVE_KPROBES + select HAVE_KPROBES_ON_FTRACE select HAVE_KRETPROBES select HAVE_GENERIC_VDSO select IOMMU_DMA if IOMMU_SUPPORTarch/arm64/include/asm/ftrace.h +1
-0@@ -20,6 +20,7 @@/* The BL at the callsite's adjusted rec->ip */ #define MCOUNT_INSN_SIZE AARCH64_INSN_SIZE +#define FTRACE_IP_EXTENSION MCOUNT_INSN_SIZE#define FTRACE_PLT_IDX 0#define FTRACE_REGS_PLT_IDX 1arch/arm64/kernel/probes/Makefile +1
-0@@ -4,3 +4,4 @@ obj-$(CONFIG_KPROBES) += kprobes.o decode-insn.o \ simulate-insn.o obj-$(CONFIG_UPROBES) += uprobes.o decode-insn.o \ simulate-insn.o +obj-$(CONFIG_KPROBES_ON_FTRACE) += ftrace.oarch/arm64/kernel/probes/ftrace.c new file +5
-0@@ -0,0 +1,78 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Dynamic Ftrace based Kprobes Optimization +* +* Copyright (C) Hitachi Ltd., 2012
arch/arm64/kernel/probes/ftrace.c line 15
Quoted 10 lines
arch/arm64/kernel/probes/ftrace.c new file +10
-0+* Copyright (C) 2019 Jisheng Zhang <[email protected]> +* Synaptics Incorporated +*/ + +#include <linux/kprobes.h> + +/* +* In arm64 FTRACE_WITH_REGS implementation, we patch two nop instructions: +* the lr saver and bl ftrace-entry. Both these instructions are claimed +* by ftrace and we should allow probing on either instruction.
No, the 2nd bl ftrace-entry must not be probed.
The pair of lr-saver and bl ftrace-entry is tightly coupled. You can not decouple it.
arch/arm64/kernel/probes/ftrace.c line 22
Quoted 7 lines
arch/arm64/kernel/probes/ftrace.c new file +7
-0+*/ +int arch_check_ftrace_location (struct kprobe *p) +{ +if (ftrace_location ((unsigned long )p->addr)) + p->flags |=KPROBE_FLAG_FTRACE ; +return 0 ; +}
Thus, this must return -EILSEQ if user puts a probe on the bl.
Quoted 6 lines
arch/arm64/kernel/probes/ftrace.c new file +6
-0+ +/* Ftrace callback handler for kprobes -- called under preepmt disabed */ +void kprobe_ftrace_handler (unsigned long ip,unsigned long parent_ip, +struct ftrace_ops *ops,struct pt_regs *regs) +{ +bool lr_saver = false;
arch/arm64/kernel/probes/ftrace.c line 38
Quoted 10 lines
arch/arm64/kernel/probes/ftrace.c new file +10
-0+struct kprobe *p; +struct kprobe_ctlblk *kcb; + +/* Preempt is disabled by ftrace */ + p =get_kprobe ((kprobe_opcode_t *)ip); +if (!p) { + p =get_kprobe ((kprobe_opcode_t *)(ip -MCOUNT_INSN_SIZE )); +if (unlikely (!p) ||kprobe_disabled (p)) +return ; + lr_saver = true;
Then, this can be removed.
arch/arm64/kernel/probes/ftrace.c line 48
Quoted 10 lines
arch/arm64/kernel/probes/ftrace.c new file +10
-0+ } + + kcb =get_kprobe_ctlblk (); +if (kprobe_running ()) { +kprobes_inc_nmissed_count (p); + }else { +unsigned long orig_ip =instruction_pointer (regs); + +if (lr_saver) + ip -=MCOUNT_INSN_SIZE ;
Ditto.
Thank you,
Quoted 33 lines
arch/arm64/kernel/probes/ftrace.c new file +30
-0+instruction_pointer_set (regs, ip); +__this_cpu_write (current_kprobe, p); + kcb->kprobe_status =KPROBE_HIT_ACTIVE ; +if (!p->pre_handler || !p->pre_handler (p, regs)) { +/* +* Emulate singlestep (and also recover regs->pc) +* as if there is a nop +*/ +instruction_pointer_set (regs, + (unsigned long )p->addr +MCOUNT_INSN_SIZE ); +if (unlikely (p->post_handler)) { + kcb->kprobe_status =KPROBE_HIT_SSDONE ; + p->post_handler (p, regs,0 ); + } +instruction_pointer_set (regs, orig_ip); + } +/* +* If pre_handler returns !0, it changes regs->pc. We have to +* skip emulating post_handler. +*/ +__this_cpu_write (current_kprobe,NULL ); + } +} +NOKPROBE_SYMBOL (kprobe_ftrace_handler); + +int arch_prepare_kprobe_ftrace (struct kprobe *p) +{ + p->ainsn.api.insn =NULL ; +return 0 ; +}Signature · 1 line
2.24.1
Signature · 1 line
Masami Hiramatsu <[email protected]>
Hi
Quoted 21 lines · On Thu, 26 Dec 2019 11:57:07 +0900 Masami Hiramatsu wrote:
Hi Jisheng,
Quoted 15 lines · On Wed, 25 Dec 2019 09:44:21 +0000 Jisheng Zhang <[email protected]>…
KPROBES_ON_FTRACEavoids much of the overhead with regular kprobes as it eliminates the need for a trap, as well as the need to emulate or single-step instructions.Tested on berlin arm64 platform.
~ # mount -t debugfs debugfs
/sys/kernel/debug/
~ # cd/sys/kernel/debug//sys/kernel/debug# echo 'p_do_fork' > tracing/kprobe_eventsbefore the patch:
/sys/kernel/debug# cat kprobes/listffffff801009fe28k_do_fork+0x0[DISABLED]
Quoted 7 lines
Quoted 4 lines
after the patch:
/sys/kernel/debug# cat kprobes/listffffff801009ff54k_do_fork+0x0[DISABLED][FTRACE]What happens if user puts a probe on _do_fork+4?
Is that return-EILSEQcorrectly?
_do_fork+4 can be probed successfully.
Quoted 75 lines
Quoted 75 lines
Signed-off-by Jisheng Zhang <[email protected]>--- .../debug/kprobes-on-ftrace/arch-support.txt | 2 +- arch/arm64/Kconfig | 1 + arch/arm64/include/asm/ftrace.h | 1 + arch/arm64/kernel/probes/Makefile | 1 + arch/arm64/kernel/probes/ftrace.c | 78 +++++++++++++++++++ 5 files changed, 82 insertions(+), 1 deletion(-) create mode 100644 arch/arm64/kernel/probes/ftrace.cDocumentation/features/debug/kprobes-on-ftrace/arch-support.txt +1
-1@@ -9,7 +9,7 @@ | alpha: | TODO | | arc: | TODO | | arm: | TODO | - | arm64: | TODO | + | arm64: | ok | | c6x: | TODO | | csky: | TODO | | h8300: | TODO |arch/arm64/Kconfig +1
-0@@ -166,6 +166,7 @@ config ARM64 select HAVE_STACKPROTECTOR select HAVE_SYSCALL_TRACEPOINTS select HAVE_KPROBES + select HAVE_KPROBES_ON_FTRACE select HAVE_KRETPROBES select HAVE_GENERIC_VDSO select IOMMU_DMA if IOMMU_SUPPORTarch/arm64/include/asm/ftrace.h +1
-0@@ -20,6 +20,7 @@/* The BL at the callsite's adjusted rec->ip */ #define MCOUNT_INSN_SIZE AARCH64_INSN_SIZE +#define FTRACE_IP_EXTENSION MCOUNT_INSN_SIZE#define FTRACE_PLT_IDX 0#define FTRACE_REGS_PLT_IDX 1arch/arm64/kernel/probes/Makefile +1
-0@@ -4,3 +4,4 @@ obj-$(CONFIG_KPROBES) += kprobes.o decode-insn.o \ simulate-insn.o obj-$(CONFIG_UPROBES) += uprobes.o decode-insn.o \ simulate-insn.o +obj-$(CONFIG_KPROBES_ON_FTRACE) += ftrace.oarch/arm64/kernel/probes/ftrace.c new file +11
-0@@ -0,0 +1,78 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Dynamic Ftrace based Kprobes Optimization +* +* Copyright (C) Hitachi Ltd., 2012 +* Copyright (C) 2019 Jisheng Zhang <[email protected]> +* Synaptics Incorporated +*/ + +#include <linux/kprobes.h> +
Quoted 8 lines
arch/arm64/kernel/probes/ftrace.c line 15
Quoted 4 lines
arch/arm64/kernel/probes/ftrace.c new file +4
-0+/* +* In arm64 FTRACE_WITH_REGS implementation, we patch two nop instructions: +* the lr saver and bl ftrace-entry. Both these instructions are claimed +* by ftrace and we should allow probing on either instruction. No, the 2nd bl ftrace-entry must not be probed.
The pair of lr-saver and bl ftrace-entry is tightly coupled. You can not decouple it.
This is the key. different viewing of this results in different implementation. I'm just wondering why are the two instructions considered as coupled. I think here we met similar situation as powerpc: https://lkml.org/lkml/2019/6/18/646
the "mflr r0" equals to lr-saver here, branch to _mcount equals to bl ftrace-entry could you please kindly comment more?
Thanks in advance
Quoted 82 lines
arch/arm64/kernel/probes/ftrace.c line 22
Quoted 8 lines
arch/arm64/kernel/probes/ftrace.c new file +7
-0+*/ +int arch_check_ftrace_location (struct kprobe *p) +{ +if (ftrace_location ((unsigned long )p->addr)) + p->flags |=KPROBE_FLAG_FTRACE ; +return 0 ; +}Thus, this must return
-EILSEQif user puts a probe on the bl.Quoted 6 lines
arch/arm64/kernel/probes/ftrace.c new file +6
-0+ +/* Ftrace callback handler for kprobes -- called under preepmt disabed */ +void kprobe_ftrace_handler (unsigned long ip,unsigned long parent_ip, +struct ftrace_ops *ops,struct pt_regs *regs) +{ +bool lr_saver = false;arch/arm64/kernel/probes/ftrace.c line 38
Quoted 10 lines
arch/arm64/kernel/probes/ftrace.c new file +10
-0+struct kprobe *p; +struct kprobe_ctlblk *kcb; + +/* Preempt is disabled by ftrace */ + p =get_kprobe ((kprobe_opcode_t *)ip); +if (!p) { + p =get_kprobe ((kprobe_opcode_t *)(ip -MCOUNT_INSN_SIZE )); +if (unlikely (!p) ||kprobe_disabled (p)) +return ; + lr_saver = true;Then, this can be removed.
arch/arm64/kernel/probes/ftrace.c line 48
Quoted 10 lines
arch/arm64/kernel/probes/ftrace.c new file +10
-0+ } + + kcb =get_kprobe_ctlblk (); +if (kprobe_running ()) { +kprobes_inc_nmissed_count (p); + }else { +unsigned long orig_ip =instruction_pointer (regs); + +if (lr_saver) + ip -=MCOUNT_INSN_SIZE ;Ditto.
Thank you,
Quoted 31 lines
arch/arm64/kernel/probes/ftrace.c new file +30
-1+instruction_pointer_set (regs, ip); +__this_cpu_write (current_kprobe, p); + kcb->kprobe_status =KPROBE_HIT_ACTIVE ; +if (!p->pre_handler || !p->pre_handler (p, regs)) { +/* +* Emulate singlestep (and also recover regs->pc) +* as if there is a nop +*/ +instruction_pointer_set (regs, + (unsigned long )p->addr +MCOUNT_INSN_SIZE ); +if (unlikely (p->post_handler)) { + kcb->kprobe_status =KPROBE_HIT_SSDONE ; + p->post_handler (p, regs,0 ); + } +instruction_pointer_set (regs, orig_ip); + } +/* +* If pre_handler returns !0, it changes regs->pc. We have to +* skip emulating post_handler. +*/ +__this_cpu_write (current_kprobe,NULL ); + } +} +NOKPROBE_SYMBOL (kprobe_ftrace_handler); + +int arch_prepare_kprobe_ftrace (struct kprobe *p) +{ + p->ainsn.api.insn =NULL ; +return 0 ; +} --Quoted 2 lines
2.24.1
--
Masami Hiramatsu <[email protected]>
Quoted 121 lines · On Thu, 26 Dec 2019 03:18:07 +0000 Jisheng Zhang wrote:
Hi
Quoted 21 lines · On Thu, 26 Dec 2019 11:57:07 +0900 Masami Hiramatsu wrote:
Hi Jisheng,
Quoted 15 lines · On Wed, 25 Dec 2019 09:44:21 +0000 Jisheng Zhang <[email protected]>…
KPROBES_ON_FTRACEavoids much of the overhead with regular kprobes as it eliminates the need for a trap, as well as the need to emulate or single-step instructions.Tested on berlin arm64 platform.
~ # mount -t debugfs debugfs
/sys/kernel/debug/
~ # cd/sys/kernel/debug//sys/kernel/debug# echo 'p_do_fork' > tracing/kprobe_eventsbefore the patch:
/sys/kernel/debug# cat kprobes/listffffff801009fe28k_do_fork+0x0[DISABLED]Quoted 7 lines
Quoted 4 lines
after the patch:
/sys/kernel/debug# cat kprobes/listffffff801009ff54k_do_fork+0x0[DISABLED][FTRACE]What happens if user puts a probe on _do_fork+4?
Is that return-EILSEQcorrectly?_do_fork+4 can be probed successfully.
Quoted 75 lines
Quoted 75 lines
Signed-off-by Jisheng Zhang <[email protected]>--- .../debug/kprobes-on-ftrace/arch-support.txt | 2 +- arch/arm64/Kconfig | 1 + arch/arm64/include/asm/ftrace.h | 1 + arch/arm64/kernel/probes/Makefile | 1 + arch/arm64/kernel/probes/ftrace.c | 78 +++++++++++++++++++ 5 files changed, 82 insertions(+), 1 deletion(-) create mode 100644 arch/arm64/kernel/probes/ftrace.cDocumentation/features/debug/kprobes-on-ftrace/arch-support.txt +1
-1@@ -9,7 +9,7 @@ | alpha: | TODO | | arc: | TODO | | arm: | TODO | - | arm64: | TODO | + | arm64: | ok | | c6x: | TODO | | csky: | TODO | | h8300: | TODO |arch/arm64/Kconfig +1
-0@@ -166,6 +166,7 @@ config ARM64 select HAVE_STACKPROTECTOR select HAVE_SYSCALL_TRACEPOINTS select HAVE_KPROBES + select HAVE_KPROBES_ON_FTRACE select HAVE_KRETPROBES select HAVE_GENERIC_VDSO select IOMMU_DMA if IOMMU_SUPPORTarch/arm64/include/asm/ftrace.h +1
-0@@ -20,6 +20,7 @@/* The BL at the callsite's adjusted rec->ip */ #define MCOUNT_INSN_SIZE AARCH64_INSN_SIZE +#define FTRACE_IP_EXTENSION MCOUNT_INSN_SIZE#define FTRACE_PLT_IDX 0#define FTRACE_REGS_PLT_IDX 1arch/arm64/kernel/probes/Makefile +1
-0@@ -4,3 +4,4 @@ obj-$(CONFIG_KPROBES) += kprobes.o decode-insn.o \ simulate-insn.o obj-$(CONFIG_UPROBES) += uprobes.o decode-insn.o \ simulate-insn.o +obj-$(CONFIG_KPROBES_ON_FTRACE) += ftrace.oarch/arm64/kernel/probes/ftrace.c new file +11
-0@@ -0,0 +1,78 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Dynamic Ftrace based Kprobes Optimization +* +* Copyright (C) Hitachi Ltd., 2012 +* Copyright (C) 2019 Jisheng Zhang <[email protected]> +* Synaptics Incorporated +*/ + +#include <linux/kprobes.h> +Quoted 8 lines
arch/arm64/kernel/probes/ftrace.c line 15
Quoted 4 lines
arch/arm64/kernel/probes/ftrace.c new file +4
-0+/* +* In arm64 FTRACE_WITH_REGS implementation, we patch two nop instructions: +* the lr saver and bl ftrace-entry. Both these instructions are claimed +* by ftrace and we should allow probing on either instruction. No, the 2nd bl ftrace-entry must not be probed.
The pair of lr-saver and bl ftrace-entry is tightly coupled. You can not decouple it.
Quoted 8 lines
This is the key. different viewing of this results in different implementation. I'm just wondering why are the two instructions considered as coupled. I think here we met similar situation as powerpc: https://lkml.org/lkml/2019/6/18/646
the "mflr r0" equals to lr-saver here, branch to_mcountequals to bl ftrace-entry could you please kindly comment more?Thanks in advance
hmm, I think I may get some part of your opinion. In v7 implementation:
if probe on func+4, that's bl ftrace-entry, similar as mcount call on other architectures, we allow this probe as normal.
if probe on func+0, the first param ip in kprobe_ftrace_handler() points to func+4(this is adjusted by ftrace), regs->ip points to func+8, so in kprobe_ftrace_handler() we modify regs->ip to func+0 to call kprobe pre handler, then modify regs->ip to func+8 to call kprobe post handler. As can be seen, the first two instructions are considered as a virtual mcount call. From this point of view, lr saver and the bl <ftrace-entry> is coupled.
If we split patch3 into two:
one to support kprobes func+4
the second to support kprobe on func+0
it would be much clearer.
Then the key here is whether we could allow both kprobes on func+0 and func+4
Thanks
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Masami Hiramatsu
maintainerQuoted 23 lines · On Thu, 26 Dec 2019 04:25:24 +0000 Jisheng Zhang <[email protected]>…
Quoted 9 lines
Quoted 8 lines
Quoted 4 lines
+/*
+ * In arm64FTRACE_WITH_REGSimplementation, we patch two nop instructions:
+ * the lr saver and bl ftrace-entry. Both these instructions are claimed
+ * by ftrace and we should allow probing on either instruction.No, the 2nd bl ftrace-entry must not be probed.
The pair of lr-saver and bl ftrace-entry is tightly coupled. You can not decouple it.Quoted 8 lines
This is the key. different viewing of this results in different implementation. I'm just wondering why are the two instructions considered as coupled. I think here we met similar situation as powerpc: https://lkml.org/lkml/2019/6/18/646
the "mflr r0" equals to lr-saver here, branch to_mcountequals to bl ftrace-entry could you please kindly comment more?Thanks in advance
hmm, I think I may get some part of your opinion. In v7 implementation:
if probe on func+4, that's bl ftrace-entry, similar as mcount call on other architectures, we allow this probe as normal.
Quoted 7 lines
if probe on func+0, the first param ip in
kprobe_ftrace_handler()points to func+4(this is adjusted by ftrace),regs->ippoints to func+8, so inkprobe_ftrace_handler()we modifyregs->ipto func+0 to call kprobe pre handler, then modifyregs->ipto func+8 to call kprobe post handler. As can be seen, the first two instructions are considered as a virtual mcount call. From this point of view, lr saver and the bl <ftrace-entry> is coupled.
Yes, this is good. But probing on func+4 is meaningless. Both func+0 and func+4 call a handler with same pt_regs. And it should have the stack pointer which is NOT modified by lr-saver and regs->lr must point original call address. (ftrace regs caller must do this fixup for supporting live patching correctly)
And in this case, func+4 has fake pt_regs because it skips lr-saver's effects.
And even if you fixed up the pt_regs, there is another problem of what user expects on the target instructions.
As you know, dynamic ftrace will fill the instruction with NOP (2 NOPs in arm64), in this case, maybe pt_regs are same except pc on func+0 and func+4. But if ftrace already enabled on the function, user will see there are lr-saver and bl, oops. In this case we have to change pt_regs between func+0 and func+4. So it depends on the current mode.
However, IMHO, it is not worth to pay such simulation cost. No one want to probe such simulated intermediate address. It is easy to expect the result from the code. Moreover, the func+4 will not appear on debuginfo because those 2 special insturctions are just appended by the compiler, not generated by the code.
So I don't think we need to support func+4. We only need func+0, or func+8 (this must be same as func+0 except regs->pc anyway)
Thank you,
Quoted 9 lines
If we split patch3 into two:
one to support kprobes func+4
the second to support kprobe on func+0
it would be much clearer.Then the key here is whether we could allow both kprobes on func+0 and func+4
Thanks
Signature · 1 line
Masami Hiramatsu <[email protected]>
Masami Hiramatsu
maintainerHi Jisheng,
Would you be still working on this series?
If you are still want to put a probe on func+4, it is OK if you can completely emulate the 1st instruction. (lr save on the stack and change the regs->sp)
Thank you,
Quoted 76 lines · On Thu, 26 Dec 2019 18:26:07 +0900 Masami Hiramatsu <[email protected]> wrote:
Quoted 23 lines · On Thu, 26 Dec 2019 04:25:24 +0000 Jisheng Zhang <[email protected]>…
Quoted 9 lines
Quoted 8 lines
Quoted 4 lines
+/*
+ * In arm64FTRACE_WITH_REGSimplementation, we patch two nop instructions:
+ * the lr saver and bl ftrace-entry. Both these instructions are claimed
+ * by ftrace and we should allow probing on either instruction.No, the 2nd bl ftrace-entry must not be probed.
The pair of lr-saver and bl ftrace-entry is tightly coupled. You can not decouple it.Quoted 8 lines
This is the key. different viewing of this results in different implementation. I'm just wondering why are the two instructions considered as coupled. I think here we met similar situation as powerpc: https://lkml.org/lkml/2019/6/18/646
the "mflr r0" equals to lr-saver here, branch to_mcountequals to bl ftrace-entry could you please kindly comment more?Thanks in advance
hmm, I think I may get some part of your opinion. In v7 implementation:
if probe on func+4, that's bl ftrace-entry, similar as mcount call on other architectures, we allow this probe as normal.
Quoted 7 lines
if probe on func+0, the first param ip in
kprobe_ftrace_handler()points to func+4(this is adjusted by ftrace),regs->ippoints to func+8, so inkprobe_ftrace_handler()we modifyregs->ipto func+0 to call kprobe pre handler, then modifyregs->ipto func+8 to call kprobe post handler. As can be seen, the first two instructions are considered as a virtual mcount call. From this point of view, lr saver and the bl <ftrace-entry> is coupled.Yes, this is good. But probing on func+4 is meaningless. Both func+0 and func+4 call a handler with same
pt_regs. And it should have the stack pointer which is NOT modified by lr-saver andregs->lrmust point original call address. (ftrace regs caller must do this fixup for supporting live patching correctly)And in this case, func+4 has fake
pt_regsbecause it skips lr-saver's effects.And even if you fixed up the
pt_regs, there is another problem of what user expects on the target instructions.As you know, dynamic ftrace will fill the instruction with NOP (2 NOPs in arm64), in this case, maybe
pt_regsare same except pc on func+0 and func+4. But if ftrace already enabled on the function, user will see there are lr-saver and bl, oops. In this case we have to changept_regsbetween func+0 and func+4. So it depends on the current mode.However, IMHO, it is not worth to pay such simulation cost. No one want to probe such simulated intermediate address. It is easy to expect the result from the code. Moreover, the func+4 will not appear on debuginfo because those 2 special insturctions are just appended by the compiler, not generated by the code.
So I don't think we need to support func+4. We only need func+0, or func+8 (this must be same as func+0 except
regs->pcanyway)Thank you,
Quoted 9 lines
If we split patch3 into two:
one to support kprobes func+4
the second to support kprobe on func+0
it would be much clearer.Then the key here is whether we could allow both kprobes on func+0 and func+4
Thanks
Signature · 1 line
Masami Hiramatsu <[email protected]>
Signature · 1 line
Masami Hiramatsu <[email protected]>
Quoted 3 lines · On Tue, 21 Jul 2020 22:24:55 +0900 Masami Hiramatsu wrote:
Hi Jisheng,
Hi,
Quoted 2 lines
Would you be still working on this series?
I will rebase the implementation on the latest code, then try to address your comments and Mark's comments. I will send out patches in this weekend.
Quoted 4 lines
If you are still want to put a probe on func+4, it is OK if you can completely emulate the 1st instruction. (lr save on the stack and change the
regs->sp)
Will check which is the better solution.
Thank you very much
Masami Hiramatsu
maintainerQuoted 16 lines · On Fri, 24 Jul 2020 15:06:11 +0800 Jisheng Zhang <[email protected]>…
Quoted 3 lines · On Tue, 21 Jul 2020 22:24:55 +0900 Masami Hiramatsu wrote:
Hi Jisheng,
Hi,
Quoted 2 lines
Would you be still working on this series?
I will rebase the implementation on the latest code, then try to address your comments and Mark's comments. I will send out patches in this weekend.
Quoted 1 line
Quoted 5 lines
Quoted 3 lines
If you are still want to put a probe on func+4, it is OK if you can completely emulate the 1st instruction. (lr save on the stack and change the
regs->sp)Will check which is the better solution.
Thanks Jisheng!
What I'm considering is the consistency of pre_handler()@addr and post_handler()@addr+4. Also, whether the value of regs (and stacks) is same as the user expected.
Thank you,
Signature · 1 line
Masami Hiramatsu <[email protected]>
Mark Rutland
reviewerHi,
This has been on my list to review for a while. Given Masami's comments, I was waiting for a new version -- is there any plan to respin this?
Otherwise, I have some comments below.
Quoted 3 lines · Jisheng Zhang
KPROBES_ON_FTRACEavoids much of the overhead with regular kprobes as it eliminates the need for a trap, as well as the need to emulate or single-step instructions.
Where does this overhead matter?
Quoted 8 lines
Tested on berlin arm64 platform.
~ # mount -t debugfs debugfs
/sys/kernel/debug/
~ # cd/sys/kernel/debug//sys/kernel/debug# echo 'p_do_fork' > tracing/kprobe_eventsbefore the patch:
Quoted 7 lines
/sys/kernel/debug# cat kprobes/listffffff801009fe28k_do_fork+0x0[DISABLED]after the patch:
/sys/kernel/debug# cat kprobes/listffffff801009ff54k_do_fork+0x0[DISABLED][FTRACE]
Just to check, how is the kprobe addresss expected to relate to the function address? For any of {mcount, mfentry, patchable-function-entry} there are some number of instructions prior to the call instruction. Does the user have to provide that address?
How does this work on other architectures?
Quoted 29 lines
Signed-off-by Jisheng Zhang <[email protected]>--- .../debug/kprobes-on-ftrace/arch-support.txt | 2 +- arch/arm64/Kconfig | 1 + arch/arm64/include/asm/ftrace.h | 1 + arch/arm64/kernel/probes/Makefile | 1 + arch/arm64/kernel/probes/ftrace.c | 78 +++++++++++++++++++ 5 files changed, 82 insertions(+), 1 deletion(-) create mode 100644 arch/arm64/kernel/probes/ftrace.cDocumentation/features/debug/kprobes-on-ftrace/arch-support.txt +1
-1@@ -9,7 +9,7 @@ | alpha: | TODO | | arc: | TODO | | arm: | TODO | - | arm64: | TODO | + | arm64: | ok | | c6x: | TODO | | csky: | TODO | | h8300: | TODO |arch/arm64/Kconfig +0
-0
arch/arm64/Kconfig config ARM64 · line 169
Quoted 4 lines
arch/arm64/Kconfig +1
-0@@ -166,6 +166,7 @@ config ARM64 select HAVE_STACKPROTECTOR select HAVE_SYSCALL_TRACEPOINTS select HAVE_KPROBES + select HAVE_KPROBES_ON_FTRACE
The rest of the code seems to presume FTRACE_WITH_REGS, but you haven't made that dependency explicit here.
arch/arm64/include/asm/ftrace.h line 23
Quoted 12 lines
arch/arm64/Kconfig +0
-0select HAVE_KRETPROBES select HAVE_GENERIC_VDSO select IOMMU_DMA if IOMMU_SUPPORTarch/arm64/include/asm/ftrace.h +1
-0@@ -20,6 +20,7 @@/* The BL at the callsite's adjusted rec->ip */ #define MCOUNT_INSN_SIZE AARCH64_INSN_SIZE +#define FTRACE_IP_EXTENSION MCOUNT_INSN_SIZE
I'm confused by what exactly this is meant to represent. At runtime our rec->ip is always the BL, so what exactly is this attempting to account for?
How does this work when using mcount rather than
patchable-function-entry?
Quoted 30 lines
arch/arm64/include/asm/ftrace.h +0
-0#define FTRACE_PLT_IDX 0#define FTRACE_REGS_PLT_IDX 1arch/arm64/kernel/probes/Makefile +1
-0@@ -4,3 +4,4 @@ obj-$(CONFIG_KPROBES) += kprobes.o decode-insn.o \ simulate-insn.o obj-$(CONFIG_UPROBES) += uprobes.o decode-insn.o \ simulate-insn.o +obj-$(CONFIG_KPROBES_ON_FTRACE) += ftrace.oarch/arm64/kernel/probes/ftrace.c new file +12
-0@@ -0,0 +1,78 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Dynamic Ftrace based Kprobes Optimization +* +* Copyright (C) Hitachi Ltd., 2012 +* Copyright (C) 2019 Jisheng Zhang <[email protected]> +* Synaptics Incorporated +*/ + +#include <linux/kprobes.h> + +/*
arch/arm64/kernel/probes/ftrace.c line 22
Quoted 10 lines
arch/arm64/kernel/probes/ftrace.c new file +10
-0+* In arm64 FTRACE_WITH_REGS implementation, we patch two nop instructions: +* the lr saver and bl ftrace-entry. Both these instructions are claimed +* by ftrace and we should allow probing on either instruction. +*/ +int arch_check_ftrace_location (struct kprobe *p) +{ +if (ftrace_location ((unsigned long )p->addr)) + p->flags |=KPROBE_FLAG_FTRACE ; +return 0 ; +}
What about when not using patchable-function-entry?
Why do we need to allow probing both?
Quoted 7 lines
arch/arm64/kernel/probes/ftrace.c new file +7
-0+ +/* Ftrace callback handler for kprobes -- called under preepmt disabed */ +void kprobe_ftrace_handler (unsigned long ip,unsigned long parent_ip, +struct ftrace_ops *ops,struct pt_regs *regs) +{ +bool lr_saver = false; +struct kprobe *p;
arch/arm64/kernel/probes/ftrace.c line 39
Quoted 10 lines
arch/arm64/kernel/probes/ftrace.c new file +10
-0+struct kprobe_ctlblk *kcb; + +/* Preempt is disabled by ftrace */ + p =get_kprobe ((kprobe_opcode_t *)ip); +if (!p) { + p =get_kprobe ((kprobe_opcode_t *)(ip -MCOUNT_INSN_SIZE )); +if (unlikely (!p) ||kprobe_disabled (p)) +return ; + lr_saver = true; + }
This complexity worries me. Is it really necessary to allow kprobing on either instruction?
Quoted 14 lines
arch/arm64/kernel/probes/ftrace.c new file +14
-0+ + kcb =get_kprobe_ctlblk (); +if (kprobe_running ()) { +kprobes_inc_nmissed_count (p); + }else { +unsigned long orig_ip =instruction_pointer (regs); + +if (lr_saver) + ip -=MCOUNT_INSN_SIZE ; +instruction_pointer_set (regs, ip); +__this_cpu_write (current_kprobe, p); + kcb->kprobe_status =KPROBE_HIT_ACTIVE ; +if (!p->pre_handler || !p->pre_handler (p, regs)) { +/*
arch/arm64/kernel/probes/ftrace.c line 63
Quoted 10 lines
arch/arm64/kernel/probes/ftrace.c new file +10
-0+* Emulate singlestep (and also recover regs->pc) +* as if there is a nop +*/ +instruction_pointer_set (regs, + (unsigned long )p->addr +MCOUNT_INSN_SIZE ); +if (unlikely (p->post_handler)) { + kcb->kprobe_status =KPROBE_HIT_SSDONE ; + p->post_handler (p, regs,0 ); + } +instruction_pointer_set (regs, orig_ip);
If you're going to mess with the PC then you also need to adjust the hardware single-step state machine.
Thanks,
Mark.
Quoted 18 lines
arch/arm64/kernel/probes/ftrace.c new file +15
-0+ } +/* +* If pre_handler returns !0, it changes regs->pc. We have to +* skip emulating post_handler. +*/ +__this_cpu_write (current_kprobe,NULL ); + } +} +NOKPROBE_SYMBOL (kprobe_ftrace_handler); + +int arch_prepare_kprobe_ftrace (struct kprobe *p) +{ + p->ainsn.api.insn =NULL ; +return 0 ; +}Signature · 1 line
2.24.1