arm64/kprobes: Add support for KPROBES_ON_FTRACE
Subsystems (4)
PATCH 1/1 arm64/kprobes: Add support for KPROBES_ON_FTRACE
This is the arm64 version of ftrace-based kprobes to avoid the overhead with regular kprobes, by using the ftrace infrastructure.
--- .../debug/kprobes-on-ftrace/arch-support.txt | 2 +- arch/arm64/Kconfig | 1 + arch/arm64/kernel/probes/Makefile | 1 + arch/arm64/kernel/probes/kprobes-ftrace.c | 81 +++++++++++++++++++ include/linux/kprobes.h | 2 + kernel/kprobes.c | 4 +- 6 files changed, 88 insertions(+), 3 deletions(-) create mode 100644 arch/arm64/kernel/probes/kprobes-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 | | csky: | ok | | hexagon: | TODO | | ia64: | TODO |
arch/arm64/Kconfig +1 -0
@@ -204,6 +204,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/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) += kprobes-ftrace.o
arch/arm64/kernel/probes/kprobes-ftrace.c new file +81 -0
81 lines not on this page · raw message
include/linux/kprobes.h +2 -0
@@ -392,6 +392,8 @@ static inline int arch_prepare_kprobe_ftrace(struct kprobe *p) }#endif /* CONFIG_KPROBES_ON_FTRACE */ +int arch_check_ftrace_location (struct kprobe *p); +/* Get the kprobe at this addr (if any) - called with preemption disabled */ struct kprobe *get_kprobe (void *addr);
kernel/kprobes.c +2 -2
@@ -1534,7 +1534,7 @@ static inline int warn_kprobe_rereg(struct kprobe *p)return ret; } -static int check_ftrace_location (struct kprobe *p) +int __weak arch_check_ftrace_location (struct kprobe *p) {unsigned long addr = (unsigned long )p->addr;
@@ -1553,7 +1553,7 @@ static int check_kprobe_address_safe(struct kprobe *p, {int ret; - ret =check_ftrace_location (p); + ret =arch_check_ftrace_location (p);if (ret)return ret;jump_label_lock ();
Signature · 1 line
2.25.1
Will Deacon
maintainer[+Mark R]
Quoted 4 lines · Jianlin Lv
This is the arm64 version of ftrace-based kprobes to avoid the overhead with regular kprobes, by using the ftrace infrastructure.
Signed-off-by Jianlin Lv <[email protected]>
Quoted 9 lines
--- .../debug/kprobes-on-ftrace/arch-support.txt | 2 +- arch/arm64/Kconfig | 1 + arch/arm64/kernel/probes/Makefile | 1 + arch/arm64/kernel/probes/kprobes-ftrace.c | 81 +++++++++++++++++++ include/linux/kprobes.h | 2 + kernel/kprobes.c | 4 +- 6 files changed, 88 insertions(+), 3 deletions(-) create mode 100644 arch/arm64/kernel/probes/kprobes-ftrace.c
Sorry for the slow reply on this, but I think this deserved to be split into two patches: the first one reworking the core check_ftrace_location() logic to work properly with branch-and-link style architectures, and the second one adding support for arm64.
I'd also prefer that we don't just punt the whole of check_ftrace_location() to the arch code using weak symbols. I'd have thought it would be cleaner for architectures to specify the offset which needs to be applied to the PC instead.
Having said that, how do architectures such as PowerPC and Risc-V handle this today without changing the core code?
Will
Mark Rutland
reviewerQuoted 17 lines · Will Deacon
[+Mark R]
Quoted 4 lines · Jianlin Lv
This is the arm64 version of ftrace-based kprobes to avoid the overhead with regular kprobes, by using the ftrace infrastructure.
Signed-off-by Jianlin Lv <[email protected]>Quoted 9 lines
--- .../debug/kprobes-on-ftrace/arch-support.txt | 2 +- arch/arm64/Kconfig | 1 + arch/arm64/kernel/probes/Makefile | 1 + arch/arm64/kernel/probes/kprobes-ftrace.c | 81 +++++++++++++++++++ include/linux/kprobes.h | 2 + kernel/kprobes.c | 4 +- 6 files changed, 88 insertions(+), 3 deletions(-) create mode 100644 arch/arm64/kernel/probes/kprobes-ftrace.c
Quoted 4 lines
Sorry for the slow reply on this, but I think this deserved to be split into two patches: the first one reworking the core
check_ftrace_location()logic to work properly with branch-and-link style architectures, and the second one adding support for arm64.
I'd prefer we don't do this at all; there a bunch of issues with kprobes *not* taking an exception, since we get a dodgy not-quite-real pt_regs, and to clean up the existing issues the plan is:
1) Move ftrace over to ftrace_regs
2) Implement fprobes using ftrace_regs
3) Remove kretprobes
... and regular kprobes will need to take an exception (via BRK) to get a real pt_regs, so that can't be optimized to use ftrace.
Thanks,
Mark.
Will Deacon
maintainerQuoted 27 lines · Mark Rutland
Quoted 17 lines · Will Deacon
[+Mark R]
Quoted 4 lines · Jianlin Lv
This is the arm64 version of ftrace-based kprobes to avoid the overhead with regular kprobes, by using the ftrace infrastructure.
Signed-off-by Jianlin Lv <[email protected]>Quoted 9 lines
--- .../debug/kprobes-on-ftrace/arch-support.txt | 2 +- arch/arm64/Kconfig | 1 + arch/arm64/kernel/probes/Makefile | 1 + arch/arm64/kernel/probes/kprobes-ftrace.c | 81 +++++++++++++++++++ include/linux/kprobes.h | 2 + kernel/kprobes.c | 4 +- 6 files changed, 88 insertions(+), 3 deletions(-) create mode 100644 arch/arm64/kernel/probes/kprobes-ftrace.cQuoted 4 lines
Sorry for the slow reply on this, but I think this deserved to be split into two patches: the first one reworking the core
check_ftrace_location()logic to work properly with branch-and-link style architectures, and the second one adding support for arm64.I'd prefer we don't do this at all; there a bunch of issues with kprobes *not* taking an exception, since we get a dodgy not-quite-real
pt_regs, and to clean up the existing issues the plan is:
Quoted 6 lines
1) Move ftrace over to
ftrace_regs
2) Implement fprobes usingftrace_regs
3) Remove kretprobes... and regular kprobes will need to take an exception (via BRK) to get a real
pt_regs, so that can't be optimized to use ftrace.
OKey doke. Does that mean that other architectures will follow the same approach of taking an exception, or do they somehow work by magic?
Will
Mark Rutland
reviewerQuoted 32 lines · Will Deacon
Quoted 31 lines · Mark Rutland
Quoted 17 lines · Will Deacon
[+Mark R]
Quoted 4 lines · Jianlin Lv
This is the arm64 version of ftrace-based kprobes to avoid the overhead with regular kprobes, by using the ftrace infrastructure.
Signed-off-by Jianlin Lv <[email protected]>Quoted 9 lines
--- .../debug/kprobes-on-ftrace/arch-support.txt | 2 +- arch/arm64/Kconfig | 1 + arch/arm64/kernel/probes/Makefile | 1 + arch/arm64/kernel/probes/kprobes-ftrace.c | 81 +++++++++++++++++++ include/linux/kprobes.h | 2 + kernel/kprobes.c | 4 +- 6 files changed, 88 insertions(+), 3 deletions(-) create mode 100644 arch/arm64/kernel/probes/kprobes-ftrace.cQuoted 4 lines
Sorry for the slow reply on this, but I think this deserved to be split into two patches: the first one reworking the core
check_ftrace_location()logic to work properly with branch-and-link style architectures, and the second one adding support for arm64.I'd prefer we don't do this at all; there a bunch of issues with kprobes *not* taking an exception, since we get a dodgy not-quite-real
pt_regs, and to clean up the existing issues the plan is:1) Move ftrace over to
ftrace_regs
2) Implement fprobes usingftrace_regs
3) Remove kretprobes
Quoted 5 lines
Quoted 2 lines
... and regular kprobes will need to take an exception (via BRK) to get a real
pt_regs, so that can't be optimized to use ftrace.OKey doke. Does that mean that other architectures will follow the same approach of taking an exception,
I think once everyone has FPROBE, KPROBES_ON_FTRACE becomes redundant, and could be removed (leaving kprobes to always follow a take-an-exception flow on all architectures).
Quoted 1 line
or do they somehow work by magic?
Some architectures don't need to take an exception to be able to create a full pt_regs (e.g. x86's flags are accessible in a way arm64's PSTATE isn't), but that needs to be generated / restored differently to exception entry/return, and so even where it's possible it can be painful to maintain (and slower than using ftrace_regs), so I suspect KPROBES_ON_FTRACE would be removed.
So different constaints more than magic.
Thanks,
Mark.
Masami Hiramatsu (Google)
maintainerQuoted 25 lines · On Mon, 7 Nov 2022 16:06:26 +0000 Mark Rutland <[email protected]> wrote:
Quoted 24 lines · Will Deacon
Quoted 23 lines · Mark Rutland
Quoted 21 lines · Will Deacon
[+Mark R]
Quoted 4 lines · Jianlin Lv
This is the arm64 version of ftrace-based kprobes to avoid the overhead with regular kprobes, by using the ftrace infrastructure.
Signed-off-by Jianlin Lv <[email protected]>Quoted 9 lines
--- .../debug/kprobes-on-ftrace/arch-support.txt | 2 +- arch/arm64/Kconfig | 1 + arch/arm64/kernel/probes/Makefile | 1 + arch/arm64/kernel/probes/kprobes-ftrace.c | 81 +++++++++++++++++++ include/linux/kprobes.h | 2 + kernel/kprobes.c | 4 +- 6 files changed, 88 insertions(+), 3 deletions(-) create mode 100644 arch/arm64/kernel/probes/kprobes-ftrace.cSorry for the slow reply on this, but I think this deserved to be split into two patches: the first one reworking the core
check_ftrace_location()logic to work properly with branch-and-link style architectures, and the second one adding support for arm64.
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
I'd prefer we don't do this at all; there a bunch of issues with kprobes *not* taking an exception, since we get a dodgy not-quite-real
pt_regs, and to clean up the existing issues the plan is:1) Move ftrace over to
ftrace_regs
2) Implement fprobes usingftrace_regs
3) Remove kretprobes
Yes, that is what we agreed at the tracing summit.
When we finished to move on the fprobe and fprobe-events, kretprobes (and kprobe-on-ftrace if CONFIG_HAVE_DYNAMIC_FTRACE_WITH_REGS is not supported) are not needed from the user viewpoint.
So we can mark the kretprobe API obsolete.
Quoted 10 lines
Quoted 6 lines
Quoted 3 lines
... and regular kprobes will need to take an exception (via BRK) to get a real
pt_regs, so that can't be optimized to use ftrace.OKey doke. Does that mean that other architectures will follow the same approach of taking an exception,
I think once everyone has FPROBE,
KPROBES_ON_FTRACEbecomes redundant, and could be removed (leaving kprobes to always follow a take-an-exception flow on all architectures).
Anyway I will give some window to transit to the fprobe with ftrace_regs.
Quoted 8 lines
Quoted 2 lines
or do they somehow work by magic?
Some architectures don't need to take an exception to be able to create a full
pt_regs(e.g. x86's flags are accessible in a way arm64's PSTATE isn't), but that needs to be generated / restored differently to exception entry/return, and so even where it's possible it can be painful to maintain (and slower than usingftrace_regs), so I suspectKPROBES_ON_FTRACEwould be removed.
I think KPROBES_ON_FTRACE support depends on CONFIG_HAVE_DYNAMIC_FTRACE_WITH_REGS. When the all architecture removed it, I remove it. But it means that if function tracer is enabled, we can not put any kprobes on the entry of functions on x86 because there is no space to put a software breakpoint at the function entry on x86.
For the ftrace (tracefs) user, I will minimize the effect of this change, but the tools developers (including eBPF developer) this change may be critical.
Thank you,
Quoted 5 lines
So different constaints more than magic.
Thanks,
Mark.
Signature · 1 line
Masami Hiramatsu (Google) <[email protected]>
Quoted 33 lines · Masami Hiramatsu
Quoted 29 lines · On Mon, 7 Nov 2022 16:06:26 +0000 Mark Rutland <[email protected]> wrote:
Quoted 28 lines · Will Deacon
Quoted 27 lines · Mark Rutland
Quoted 17 lines · Will Deacon
[+Mark R]
Quoted 4 lines · Jianlin Lv
This is the arm64 version of ftrace-based kprobes to avoid the overhead with regular kprobes, by using the ftrace infrastructure.
Signed-off-by Jianlin Lv <[email protected]>Quoted 9 lines
--- .../debug/kprobes-on-ftrace/arch-support.txt | 2 +- arch/arm64/Kconfig | 1 + arch/arm64/kernel/probes/Makefile | 1 + arch/arm64/kernel/probes/kprobes-ftrace.c | 81 +++++++++++++++++++ include/linux/kprobes.h | 2 + kernel/kprobes.c | 4 +- 6 files changed, 88 insertions(+), 3 deletions(-) create mode 100644 arch/arm64/kernel/probes/kprobes-ftrace.cQuoted 4 lines
Sorry for the slow reply on this, but I think this deserved to be split into two patches: the first one reworking the core
check_ftrace_location()logic to work properly with branch-and-link style architectures, and the second one adding support for arm64.I'd prefer we don't do this at all; there a bunch of issues with kprobes *not* taking an exception, since we get a dodgy not-quite-real
pt_regs, and to clean up the existing issues the plan is:
Quoted 5 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
1) Move ftrace over to
ftrace_regs
2) Implement fprobes usingftrace_regs
3) Remove kretprobesYes, that is what we agreed at the tracing summit.
Sorry to miss TS2022.
Are there documents that can be shared to document the conclusions reached at the tracing summit?
This will be helpful to understand what changes may be coming to tracing.
Quoted 49 lines
When we finished to move on the fprobe and fprobe-events, kretprobes (and kprobe-on-ftrace if
CONFIG_HAVE_DYNAMIC_FTRACE_WITH_REGSis not supported) are not needed from the user viewpoint.
So we can mark the kretprobe API obsolete.Quoted 10 lines
Quoted 6 lines
Quoted 3 lines
... and regular kprobes will need to take an exception (via BRK) to get a real
pt_regs, so that can't be optimized to use ftrace.OKey doke. Does that mean that other architectures will follow the same approach of taking an exception,
I think once everyone has FPROBE,
KPROBES_ON_FTRACEbecomes redundant, and could be removed (leaving kprobes to always follow a take-an-exception flow on all architectures).Anyway I will give some window to transit to the fprobe with
ftrace_regs.Quoted 8 lines
Quoted 2 lines
or do they somehow work by magic?
Some architectures don't need to take an exception to be able to create a full
pt_regs(e.g. x86's flags are accessible in a way arm64's PSTATE isn't), but that needs to be generated / restored differently to exception entry/return, and so even where it's possible it can be painful to maintain (and slower than usingftrace_regs), so I suspectKPROBES_ON_FTRACEwould be removed.I think
KPROBES_ON_FTRACEsupport depends onCONFIG_HAVE_DYNAMIC_FTRACE_WITH_REGS. When the all architecture removed it, I remove it. But it means that if function tracer is enabled, we can not put any kprobes on the entry of functions on x86 because there is no space to put a software breakpoint at the function entry on x86.For the ftrace (tracefs) user, I will minimize the effect of this change, but the tools developers (including eBPF developer) this change may be critical.
Thank you,
Quoted 5 lines
So different constaints more than magic.
Thanks,
Mark.--
Masami Hiramatsu (Google) <[email protected]>