uprobe,bpf: Allow to change app registers from uprobe registers
Subsystems (9)
Jiri Olsa
reviewerv4 cover uprobe,bpf: Allow to change app registers from uprobe registers
hi,
we recently had several requests for tetragon to be able to change user application function return value or divert its execution through instruction pointer change.
This patchset adds support for uprobe program to change app's registers including instruction pointer.
v4 changes:
- rebased on bpf-next/master, we will handle the future simple conflict with tip/perf/core
- changed condition in kprobe_prog_is_valid_access [Andrii]
- added acks
thanks,
jirka
---
Jiri Olsa (6):
bpf: Allow uprobe program to change context registers
uprobe: Do not emulate/sstep original instruction when ip is changed selftests/bpf: Add uprobe context registers changes test selftests/bpf: Add uprobe context ip register change test selftests/bpf: Add kprobe write ctx attach test selftests/bpf: Add kprobe multi write ctx attach test
include/linux/bpf.h | 1 + kernel/events/core.c | 4 +++ kernel/events/uprobes.c | 7 +++++ kernel/trace/bpf_trace.c | 9 ++++-- tools/testing/selftests/bpf/prog_tests/attach_probe.c | 28 +++++++++++++++++ tools/testing/selftests/bpf/prog_tests/kprobe_multi_test.c | 27 ++++++++++++++++ tools/testing/selftests/bpf/prog_tests/uprobe.c | 156 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- tools/testing/selftests/bpf/progs/kprobe_write_ctx.c | 22 +++++++++++++ tools/testing/selftests/bpf/progs/test_uprobe.c | 38 +++++++++++++++++++++++ 9 files changed, 289 insertions(+), 3 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/kprobe_write_ctx.c
Jiri Olsa
reviewerPATCH v4 1/6 bpf: Allow uprobe program to change context registers
Currently uprobe (BPF_PROG_TYPE_KPROBE) program can't write to the context registers data. While this makes sense for kprobe attachments, for uprobe attachment it might make sense to be able to change user space registers to alter application execution.
Since uprobe and kprobe programs share the same type (BPF_PROG_TYPE_KPROBE), we can't deny write access to context during the program load. We need to check on it during program attachment to see if it's going to be kprobe or uprobe.
Storing the program's write attempt to context and checking on it during the attachment.
--- include/linux/bpf.h | 1 + kernel/events/core.c | 4 ++++ kernel/trace/bpf_trace.c | 9 +++++++-- 3 files changed, 12 insertions(+), 2 deletions(-)
include/linux/bpf.h +1 -0
@@ -1624,6 +1624,7 @@ struct bpf_prog_aux {bool priv_stack_requested;bool changes_pkt_data;bool might_sleep; +bool kprobe_write_ctx;u64 prog_array_member_cnt;/* counts how many times as member of prog_array */ struct mutex ext_mutex;/* mutex for is_extended and prog_array_member_cnt */ struct bpf_arena *arena;
kernel/events/core.c +4 -0
@@ -11232,6 +11232,10 @@ static int __perf_event_set_bpf_prog(struct perf_event *event,if (prog->kprobe_override && !is_kprobe)return -EINVAL ; +/* Writing to context allowed only for uprobes. */ +if (prog->aux->kprobe_write_ctx && !is_uprobe) +return -EINVAL ; +if (is_tracepoint || is_syscall_tp) {int off =trace_event_get_offsets (event->tp_event);
kernel/trace/bpf_trace.c +7 -2
@@ -1521,8 +1521,6 @@ static bool kprobe_prog_is_valid_access(int off, int size, enum bpf_access_type {if (off <0 || off >=sizeof (struct pt_regs ))return false; -if (type !=BPF_READ ) -return false;if (off % size !=0 )return false;/*
@@ -1532,6 +1530,9 @@ static bool kprobe_prog_is_valid_access(int off, int size, enum bpf_access_typeif (off + size >sizeof (struct pt_regs ))return false; +if (type ==BPF_WRITE ) + prog->aux->kprobe_write_ctx = true; +return true; }
@@ -2918,6 +2919,10 @@ int bpf_kprobe_multi_link_attach(const union bpf_attr *attr, struct bpf_prog *prif (!is_kprobe_multi (prog))return -EINVAL ; +/* Writing to context is not allowed for kprobes. */ +if (prog->aux->kprobe_write_ctx) +return -EINVAL ; + flags = attr->link_create.kprobe_multi.flags;if (flags & ~BPF_F_KPROBE_MULTI_RETURN )return -EINVAL ;
Signature · 1 line
2.51.0
Jiri Olsa
reviewerPATCH v4 2/6 uprobe: Do not emulate/sstep original instruction when ip is changed
In reply to Jiri OlsaIf uprobe handler changes instruction pointer we still execute single step) or emulate the original instruction and increment the (new) ip with its length.
This makes the new instruction pointer bogus and application will likely crash on illegal instruction execution.
If user decided to take execution elsewhere, it makes little sense to execute the original instruction, so let's skip it.
--- kernel/events/uprobes.c | 7 +++++++ 1 file changed, 7 insertions(+)
kernel/events/uprobes.c +7 -0
@@ -2741,6 +2741,13 @@ static void handle_swbp(struct pt_regs *regs)handler_chain (uprobe, regs); +/* +* If user decided to take execution elsewhere, it makes little sense +* to execute the original instruction, so let's skip it. +*/ +if (instruction_pointer (regs) != bp_vaddr) + goto out; +if (arch_uprobe_skip_sstep (&uprobe->arch, regs)) goto out;
Signature · 1 line
2.51.0
Re: [PATCHv4 bpf-next 2/6] uprobe: Do not emulate/sstep original instruction when ip is changed
Quoted 23 lines · Jiri Olsa
If uprobe handler changes instruction pointer we still execute single step) or emulate the original instruction and increment the (new) ip with its length.
This makes the new instruction pointer bogus and application will likely crash on illegal instruction execution.
If user decided to take execution elsewhere, it makes little sense to execute the original instruction, so let's skip it.
Acked-by Oleg Nesterov <[email protected]>Acked-by Andrii Nakryiko <[email protected]>Signed-off-by Jiri Olsa <[email protected]>--- kernel/events/uprobes.c | 7 +++++++ 1 file changed, 7 insertions(+)kernel/events/uprobes.c +0
-0
kernel/events/uprobes.c static void handle_swbp(struct pt_regs *regs) · line 2750
Quoted 10 lines
kernel/events/uprobes.c +7
-0@@ -2741,6 +2741,13 @@ static void handle_swbp(struct pt_regs *regs)handler_chain (uprobe, regs); +/* +* If user decided to take execution elsewhere, it makes little sense +* to execute the original instruction, so let's skip it. +*/ +if (instruction_pointer (regs) != bp_vaddr) + goto out; +
Peter, Ingo,
Are you guys ok with us routing this through the bpf-next tree? We'll have a tiny conflict because in perf/core branch there is arch_uprobe_optimize() call added after handler_chain(), so git merge will be a bit confused, probably. But it should be trivially resolvable.
Quoted 6 lines
kernel/events/uprobes.c +0
-1if (arch_uprobe_skip_sstep (&uprobe->arch, regs)) goto out; --2.51.0
Re: [PATCHv4 bpf-next 2/6] uprobe: Do not emulate/sstep original instruction when ip is changed
Quoted 38 lines · Andrii Nakryiko
Quoted 23 lines · Jiri Olsa
If uprobe handler changes instruction pointer we still execute single step) or emulate the original instruction and increment the (new) ip with its length.
This makes the new instruction pointer bogus and application will likely crash on illegal instruction execution.
If user decided to take execution elsewhere, it makes little sense to execute the original instruction, so let's skip it.
Acked-by Oleg Nesterov <[email protected]>Acked-by Andrii Nakryiko <[email protected]>Signed-off-by Jiri Olsa <[email protected]>--- kernel/events/uprobes.c | 7 +++++++ 1 file changed, 7 insertions(+)kernel/events/uprobes.c +0
-0kernel/events/uprobes.c static void handle_swbp(struct pt_regs *regs) · line 2750
Quoted 10 lines
kernel/events/uprobes.c +7
-0@@ -2741,6 +2741,13 @@ static void handle_swbp(struct pt_regs *regs)handler_chain (uprobe, regs); +/* +* If user decided to take execution elsewhere, it makes little sense +* to execute the original instruction, so let's skip it. +*/ +if (instruction_pointer (regs) != bp_vaddr) + goto out; +Peter, Ingo,
Quoted 5 lines
Are you guys ok with us routing this through the bpf-next tree? We'll have a tiny conflict because in perf/core branch there is
arch_uprobe_optimize()call added afterhandler_chain(), so git merge will be a bit confused, probably. But it should be trivially resolvable.
Ping. Any objections for landing this patch in bpf-next?
Quoted 7 lines
Quoted 7 lines
kernel/events/uprobes.c +0
-1if (arch_uprobe_skip_sstep (&uprobe->arch, regs)) goto out; --2.51.0
Peter Zijlstra
maintainerRe: [PATCHv4 bpf-next 2/6] uprobe: Do not emulate/sstep original instruction when ip is changed
In reply to Andrii NakryikoQuoted 37 lines · Andrii Nakryiko
Quoted 23 lines · Jiri Olsa
If uprobe handler changes instruction pointer we still execute single step) or emulate the original instruction and increment the (new) ip with its length.
This makes the new instruction pointer bogus and application will likely crash on illegal instruction execution.
If user decided to take execution elsewhere, it makes little sense to execute the original instruction, so let's skip it.
Acked-by Oleg Nesterov <[email protected]>Acked-by Andrii Nakryiko <[email protected]>Signed-off-by Jiri Olsa <[email protected]>--- kernel/events/uprobes.c | 7 +++++++ 1 file changed, 7 insertions(+)kernel/events/uprobes.c +0
-0kernel/events/uprobes.c static void handle_swbp(struct pt_regs *regs) · line 2750
Quoted 10 lines
kernel/events/uprobes.c +7
-0@@ -2741,6 +2741,13 @@ static void handle_swbp(struct pt_regs *regs)handler_chain (uprobe, regs); +/* +* If user decided to take execution elsewhere, it makes little sense +* to execute the original instruction, so let's skip it. +*/ +if (instruction_pointer (regs) != bp_vaddr) + goto out; +Peter, Ingo,
Quoted 5 lines
Are you guys ok with us routing this through the bpf-next tree? We'll have a tiny conflict because in perf/core branch there is
arch_uprobe_optimize()call added afterhandler_chain(), so git merge will be a bit confused, probably. But it should be trivially resolvable.
Nah, I suppose that'll be fine. Thanks!
Alexei Starovoitov
AppliedRe: [PATCHv4 bpf-next 2/6] uprobe: Do not emulate/sstep original instruction when ip is changed
Quoted 39 lines · Peter Zijlstra
Quoted 37 lines · Andrii Nakryiko
Quoted 23 lines · Jiri Olsa
If uprobe handler changes instruction pointer we still execute single step) or emulate the original instruction and increment the (new) ip with its length.
This makes the new instruction pointer bogus and application will likely crash on illegal instruction execution.
If user decided to take execution elsewhere, it makes little sense to execute the original instruction, so let's skip it.
Acked-by Oleg Nesterov <[email protected]>Acked-by Andrii Nakryiko <[email protected]>Signed-off-by Jiri Olsa <[email protected]>--- kernel/events/uprobes.c | 7 +++++++ 1 file changed, 7 insertions(+)kernel/events/uprobes.c +0
-0kernel/events/uprobes.c static void handle_swbp(struct pt_regs *regs) · line 2750
Quoted 10 lines
kernel/events/uprobes.c +7
-0@@ -2741,6 +2741,13 @@ static void handle_swbp(struct pt_regs *regs)handler_chain (uprobe, regs); +/* +* If user decided to take execution elsewhere, it makes little sense +* to execute the original instruction, so let's skip it. +*/ +if (instruction_pointer (regs) != bp_vaddr) + goto out; +Peter, Ingo,
Quoted 7 lines
Quoted 5 lines
Are you guys ok with us routing this through the bpf-next tree? We'll have a tiny conflict because in perf/core branch there is
arch_uprobe_optimize()call added afterhandler_chain(), so git merge will be a bit confused, probably. But it should be trivially resolvable.Nah, I suppose that'll be fine. Thanks!
Thanks! Applied.
Jiri,
in the future, please keep the whole history in the cover letter. v1->v2, v2->v3. Just v4 changes are nice, but pls copy paste previous cover letters and expand them.
Also please always include links to previous versions in the cover. Search on lore sucks. Links in the cover are a much better way to preserve the history.
Re: [PATCHv4 bpf-next 2/6] uprobe: Do not emulate/sstep original instruction when ip is changed
Quoted 46 lines · Alexei Starovoitov
Quoted 45 lines · Peter Zijlstra
Quoted 42 lines · Andrii Nakryiko
Quoted 23 lines · Jiri Olsa
If uprobe handler changes instruction pointer we still execute single step) or emulate the original instruction and increment the (new) ip with its length.
This makes the new instruction pointer bogus and application will likely crash on illegal instruction execution.
If user decided to take execution elsewhere, it makes little sense to execute the original instruction, so let's skip it.
Acked-by Oleg Nesterov <[email protected]>Acked-by Andrii Nakryiko <[email protected]>Signed-off-by Jiri Olsa <[email protected]>--- kernel/events/uprobes.c | 7 +++++++ 1 file changed, 7 insertions(+)kernel/events/uprobes.c +0
-0kernel/events/uprobes.c static void handle_swbp(struct pt_regs *regs) · line 2750
Quoted 10 lines
kernel/events/uprobes.c +7
-0@@ -2741,6 +2741,13 @@ static void handle_swbp(struct pt_regs *regs)handler_chain (uprobe, regs); +/* +* If user decided to take execution elsewhere, it makes little sense +* to execute the original instruction, so let's skip it. +*/ +if (instruction_pointer (regs) != bp_vaddr) + goto out; +Peter, Ingo,
Are you guys ok with us routing this through the bpf-next tree? We'll have a tiny conflict because in perf/core branch there is
arch_uprobe_optimize()call added afterhandler_chain(), so git merge will be a bit confused, probably. But it should be trivially resolvable.
Quoted 8 lines
Quoted 1 line
Nah, I suppose that'll be fine. Thanks!
Thanks! Applied.
Jiri,
in the future, please keep the whole history in the cover letter.v1->v2,v2->v3. Just v4 changes are nice, but pls copy paste previous cover letters and expand them.
ok
Quoted 3 lines
Also please always include links to previous versions in the cover. Search on lore sucks. Links in the cover are a much better way to preserve the history.
will add them in future, thanks
jirka
Jiri Olsa
reviewerPATCH v4 3/6 selftests/bpf: Add uprobe context registers changes test
In reply to Jiri OlsaAdding test to check we can change common register values through uprobe program.
It's x86_64 specific test.
--- .../testing/selftests/bpf/prog_tests/uprobe.c | 114 +++++++++++++++++- .../testing/selftests/bpf/progs/test_uprobe.c | 24 ++++ 2 files changed, 137 insertions(+), 1 deletion(-)
tools/testing/selftests/bpf/prog_tests/uprobe.c +113 -1
@@ -2,6 +2,7 @@/* Copyright (c) 2023 Hengqi Chen */ #include <test_progs.h> +#include <asm/ptrace.h> #include "test_uprobe.skel.h" static FILE *urand_spawn (int *pid)
@@ -33,7 +34,7 @@ static int urand_trigger(FILE **urand_pipe)return exit_code; } -void test_uprobe (void ) +static void test_uprobe_attach (void ) {LIBBPF_OPTS (bpf_uprobe_opts, uprobe_opts);struct test_uprobe *skel;
@@ -93,3 +94,114 @@ void test_uprobe(void)pclose (urand_pipe);test_uprobe__destroy (skel); } + +#ifdef __x86_64__ +__naked __maybe_unused unsigned long uprobe_regs_change_trigger (void ) +{ + asmvolatile ( +"ret\n" + ); +} + +static __naked void uprobe_regs_change (struct pt_regs *before,struct pt_regs *after) +{ + asmvolatile ( +"movq %r11, 48(%rdi)\n" +"movq %r10, 56(%rdi)\n" +"movq %r9, 64(%rdi)\n" +"movq %r8, 72(%rdi)\n" +"movq %rax, 80(%rdi)\n" +"movq %rcx, 88(%rdi)\n" +"movq %rdx, 96(%rdi)\n" +"movq %rsi, 104(%rdi)\n" +"movq %rdi, 112(%rdi)\n" + +/* save 2nd argument */ +"pushq %rsi\n" +"call uprobe_regs_change_trigger\n" + +/* save return value and load 2nd argument pointer to rax */ +"pushq %rax\n" +"movq 8(%rsp), %rax\n" + +"movq %r11, 48(%rax)\n" +"movq %r10, 56(%rax)\n" +"movq %r9, 64(%rax)\n" +"movq %r8, 72(%rax)\n" +"movq %rcx, 88(%rax)\n" +"movq %rdx, 96(%rax)\n" +"movq %rsi, 104(%rax)\n" +"movq %rdi, 112(%rax)\n" + +/* restore return value and 2nd argument */ +"pop %rax\n" +"pop %rsi\n" + +"movq %rax, 80(%rsi)\n" +"ret\n" + ); +} + +static void regs_common (void ) +{ +struct pt_regs before = {}, after = {}, expected = { + .rax =0xc0ffe , + .rcx =0xbad , + .rdx =0xdead , + .r8 =0x8 , + .r9 =0x9 , + .r10 =0x10 , + .r11 =0x11 , + .rdi =0x12 , + .rsi =0x13 , + }; +LIBBPF_OPTS (bpf_uprobe_opts, uprobe_opts); +struct test_uprobe *skel; + + skel =test_uprobe__open_and_load (); +if (!ASSERT_OK_PTR (skel,"skel_open" )) +return ; + + skel->bss->my_pid =getpid (); + skel->bss->regs = expected; + + uprobe_opts.func_name ="uprobe_regs_change_trigger" ; + skel->links.test_regs_change =bpf_program__attach_uprobe_opts (skel->progs.test_regs_change, +-1 , +"/proc/self/exe" , +0 /* offset */ , + &uprobe_opts); +if (!ASSERT_OK_PTR (skel->links.test_regs_change,"bpf_program__attach_uprobe_opts" )) + goto cleanup; + +uprobe_regs_change (&before, &after); + +ASSERT_EQ (after.rax, expected.rax,"ax" ); +ASSERT_EQ (after.rcx, expected.rcx,"cx" ); +ASSERT_EQ (after.rdx, expected.rdx,"dx" ); +ASSERT_EQ (after.r8, expected.r8,"r8" ); +ASSERT_EQ (after.r9, expected.r9,"r9" ); +ASSERT_EQ (after.r10, expected.r10,"r10" ); +ASSERT_EQ (after.r11, expected.r11,"r11" ); +ASSERT_EQ (after.rdi, expected.rdi,"rdi" ); +ASSERT_EQ (after.rsi, expected.rsi,"rsi" ); + +cleanup: +test_uprobe__destroy (skel); +} + +static void test_uprobe_regs_change (void ) +{ +if (test__start_subtest ("regs_change_common" )) +regs_common (); +} +#else +static void test_uprobe_regs_change (void ) { } +#endif + +void test_uprobe (void ) +{ +if (test__start_subtest ("attach" )) +test_uprobe_attach (); +test_uprobe_regs_change (); +}
tools/testing/selftests/bpf/progs/test_uprobe.c +24 -0
@@ -59,3 +59,27 @@ int BPF_UPROBE(test4) test4_result =1 ;return 0 ; } + +#if defined(__TARGET_ARCH_x86) +struct pt_regs regs; + +SEC("uprobe") +int BPF_UPROBE (test_regs_change ) +{ +pid_t pid =bpf_get_current_pid_tgid () >>32 ; + +if (pid != my_pid) +return 0 ; + + ctx->ax = regs.ax; + ctx->cx = regs.cx; + ctx->dx = regs.dx; + ctx->r8 = regs.r8; + ctx->r9 = regs.r9; + ctx->r10 = regs.r10; + ctx->r11 = regs.r11; + ctx->di = regs.di; + ctx->si = regs.si; +return 0 ; +} +#endif
Signature · 1 line
2.51.0
Jiri Olsa
reviewerPATCH v4 4/6 selftests/bpf: Add uprobe context ip register change test
In reply to Jiri OlsaAdding test to check we can change the application execution through instruction pointer change through uprobe program.
It's x86_64 specific test.
--- .../testing/selftests/bpf/prog_tests/uprobe.c | 42 +++++++++++++++++++ .../testing/selftests/bpf/progs/test_uprobe.c | 14 +++++++ 2 files changed, 56 insertions(+)
tools/testing/selftests/bpf/prog_tests/uprobe.c +42 -0
@@ -190,10 +190,52 @@ static void regs_common(void)test_uprobe__destroy (skel); } +static noinline unsigned long uprobe_regs_change_ip_1 (void ) +{ +return 0xc0ffee ; +} + +static noinline unsigned long uprobe_regs_change_ip_2 (void ) +{ +return 0xdeadbeef ; +} + +static void regs_ip (void ) +{ +LIBBPF_OPTS (bpf_uprobe_opts, uprobe_opts); +struct test_uprobe *skel; +unsigned long ret; + + skel =test_uprobe__open_and_load (); +if (!ASSERT_OK_PTR (skel,"skel_open" )) +return ; + + skel->bss->my_pid =getpid (); + skel->bss->ip = (unsigned long ) uprobe_regs_change_ip_2; + + uprobe_opts.func_name ="uprobe_regs_change_ip_1" ; + skel->links.test_regs_change_ip =bpf_program__attach_uprobe_opts ( + skel->progs.test_regs_change_ip, +-1 , +"/proc/self/exe" , +0 /* offset */ , + &uprobe_opts); +if (!ASSERT_OK_PTR (skel->links.test_regs_change_ip,"bpf_program__attach_uprobe_opts" )) + goto cleanup; + + ret =uprobe_regs_change_ip_1 (); +ASSERT_EQ (ret,0xdeadbeef ,"ret" ); + +cleanup: +test_uprobe__destroy (skel); +} +static void test_uprobe_regs_change (void ) {if (test__start_subtest ("regs_change_common" ))regs_common (); +if (test__start_subtest ("regs_change_ip" )) +regs_ip (); }#else static void test_uprobe_regs_change (void ) { }
tools/testing/selftests/bpf/progs/test_uprobe.c +14 -0
@@ -82,4 +82,18 @@ int BPF_UPROBE(test_regs_change) ctx->si = regs.si;return 0 ; } + +unsigned long ip; + +SEC("uprobe") +int BPF_UPROBE (test_regs_change_ip ) +{ +pid_t pid =bpf_get_current_pid_tgid () >>32 ; + +if (pid != my_pid) +return 0 ; + + ctx->ip = ip; +return 0 ; +}#endif
Signature · 1 line
2.51.0
Jiri Olsa
reviewerPATCH v4 5/6 selftests/bpf: Add kprobe write ctx attach test
In reply to Jiri OlsaAdding test to check we can't attach standard kprobe program that writes to the context.
It's x86_64 specific test.
--- .../selftests/bpf/prog_tests/attach_probe.c | 28 +++++++++++++++++++ .../selftests/bpf/progs/kprobe_write_ctx.c | 15 ++++++++++ 2 files changed, 43 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/kprobe_write_ctx.c
tools/testing/selftests/bpf/prog_tests/attach_probe.c +28 -0
@@ -3,6 +3,7 @@#include "test_attach_kprobe_sleepable.skel.h" #include "test_attach_probe_manual.skel.h" #include "test_attach_probe.skel.h" +#include "kprobe_write_ctx.skel.h" /* this is how USDT semaphore is actually defined, except volatile modifier */ volatile unsigned short uprobe_ref_ctr __attribute__((unused)) __attribute((section(".probes")));
@@ -201,6 +202,31 @@ static void test_attach_kprobe_long_event_name(void)test_attach_probe_manual__destroy (skel); } +#ifdef __x86_64__ +/* attach kprobe/kretprobe long event name testings */ +static void test_attach_kprobe_write_ctx (void ) +{ +struct kprobe_write_ctx *skel =NULL ; +struct bpf_link *link =NULL ; + + skel =kprobe_write_ctx__open_and_load (); +if (!ASSERT_OK_PTR (skel,"kprobe_write_ctx__open_and_load" )) +return ; + + link =bpf_program__attach_kprobe_opts (skel->progs.kprobe_write_ctx, +"bpf_fentry_test1" ,NULL ); +if (!ASSERT_ERR_PTR (link,"bpf_program__attach_kprobe_opts" )) +bpf_link__destroy (link); + +kprobe_write_ctx__destroy (skel); +} +#else +static void test_attach_kprobe_write_ctx (void ) +{ +test__skip (); +} +#endif +static void test_attach_probe_auto (struct test_attach_probe *skel) {struct bpf_link *uprobe_err_link;
@@ -406,6 +432,8 @@ void test_attach_probe(void)test_attach_uprobe_long_event_name ();if (test__start_subtest ("kprobe-long_name" ))test_attach_kprobe_long_event_name (); +if (test__start_subtest ("kprobe-write-ctx" )) +test_attach_kprobe_write_ctx (); cleanup:test_attach_probe__destroy (skel);
tools/testing/selftests/bpf/progs/kprobe_write_ctx.c new file +15 -0
@@ -0,0 +1,15 @@ +// SPDX-License-Identifier: GPL-2.0 +#include "vmlinux.h" +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> + +char _license[] SEC("license") = "GPL"; + +#if defined(__TARGET_ARCH_x86) +SEC("kprobe") +int kprobe_write_ctx (struct pt_regs *ctx) +{ + ctx->ax =0 ; +return 0 ; +} +#endif
Signature · 1 line
2.51.0
Jiri Olsa
reviewerPATCH v4 6/6 selftests/bpf: Add kprobe multi write ctx attach test
In reply to Jiri OlsaAdding test to check we can't attach kprobe multi program that writes to the context.
It's x86_64 specific test.
--- .../bpf/prog_tests/kprobe_multi_test.c | 27 +++++++++++++++++++ .../selftests/bpf/progs/kprobe_write_ctx.c | 7 +++++ 2 files changed, 34 insertions(+)
tools/testing/selftests/bpf/prog_tests/kprobe_multi_test.c +27 -0
@@ -7,6 +7,7 @@#include "kprobe_multi_session.skel.h" #include "kprobe_multi_session_cookie.skel.h" #include "kprobe_multi_verifier.skel.h" +#include "kprobe_write_ctx.skel.h" #include "bpf/libbpf_internal.h" #include "bpf/hashmap.h"
@@ -539,6 +540,30 @@ static void test_attach_override(void)kprobe_multi_override__destroy (skel); } +#ifdef __x86_64__ +static void test_attach_write_ctx (void ) +{ +struct kprobe_write_ctx *skel =NULL ; +struct bpf_link *link =NULL ; + + skel =kprobe_write_ctx__open_and_load (); +if (!ASSERT_OK_PTR (skel,"kprobe_write_ctx__open_and_load" )) +return ; + + link =bpf_program__attach_kprobe_opts (skel->progs.kprobe_multi_write_ctx, +"bpf_fentry_test1" ,NULL ); +if (!ASSERT_ERR_PTR (link,"bpf_program__attach_kprobe_opts" )) +bpf_link__destroy (link); + +kprobe_write_ctx__destroy (skel); +} +#else +static void test_attach_write_ctx (void ) +{ +test__skip (); +} +#endif +void serial_test_kprobe_multi_bench_attach (void ) {if (test__start_subtest ("kernel" ))
@@ -578,5 +603,7 @@ void test_kprobe_multi_test(void)test_session_cookie_skel_api ();if (test__start_subtest ("unique_match" ))test_unique_match (); +if (test__start_subtest ("attach_write_ctx" )) +test_attach_write_ctx ();RUN_TESTS (kprobe_multi_verifier); }
tools/testing/selftests/bpf/progs/kprobe_write_ctx.c +7 -0
@@ -12,4 +12,11 @@ int kprobe_write_ctx(struct pt_regs *ctx) ctx->ax =0 ;return 0 ; } + +SEC("kprobe.multi") +int kprobe_multi_write_ctx(struct pt_regs *ctx) +{ + ctx->ax =0 ; +return 0 ; +}#endif
Signature · 1 line
2.51.0
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:
Hello:
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:
Quoted 9 lines · On Tue, 16 Sep 2025 23:52:55 +0200 you wrote:
hi,
we recently had several requests for tetragon to be able to change user application function return value or divert its execution through instruction pointer change.This patchset adds support for uprobe program to change app's registers including instruction pointer.
[...]
Here is the summary with links:
- [PATCHv4,bpf-next,1/6] bpf: Allow uprobe program to change context registers
https://git.kernel.org/bpf/bpf-next/c/7384893d970e - [PATCHv4,bpf-next,2/6] uprobe: Do not emulate/sstep original instruction when ip is changed https://git.kernel.org/bpf/bpf-next/c/4363264111e1 - [PATCHv4,bpf-next,3/6] selftests/bpf: Add uprobe context registers changes test https://git.kernel.org/bpf/bpf-next/c/7f8a05c5d388 - [PATCHv4,bpf-next,4/6] selftests/bpf: Add uprobe context ip register change test https://git.kernel.org/bpf/bpf-next/c/6a4ea0d1cb44 - [PATCHv4,bpf-next,5/6] selftests/bpf: Add kprobe write ctx attach test https://git.kernel.org/bpf/bpf-next/c/1b881ee294b2 - [PATCHv4,bpf-next,6/6] selftests/bpf: Add kprobe multi write ctx attach test https://git.kernel.org/bpf/bpf-next/c/3d237467a444
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html