Skip to content

Commit 637c26f

Browse files
anakryikomhiramat
anakryiko
authored and
mhiramat
committed
selftests/bpf: add test validating uprobe/uretprobe stack traces
Add a set of tests to validate that stack traces captured from or in the presence of active uprobes and uretprobes are valid and complete. For this we use BPF program that are installed either on entry or exit of user function, plus deep-nested USDT. One of target funtions (target_1) is recursive to generate two different entries in the stack trace for the same uprobe/uretprobe, testing potential edge conditions. If there is no fixes, we get something like this for one of the scenarios: caller: 0x758fff - 0x7595ab target_1: 0x758fd5 - 0x758fff target_2: 0x758fca - 0x758fd5 target_3: 0x758fbf - 0x758fca target_4: 0x758fb3 - 0x758fbf ENTRY #0: 0x758fb3 (in target_4) ENTRY #1: 0x758fd3 (in target_2) ENTRY #2: 0x758ffd (in target_1) ENTRY #3: 0x7fffffffe000 ENTRY #4: 0x7fffffffe000 ENTRY #5: 0x6f8f39 ENTRY #6: 0x6fa6f0 ENTRY #7: 0x7f403f229590 Entry #3 and #4 (0x7fffffffe000) are uretprobe trampoline addresses which obscure actual target_1 and another target_1 invocations. Also note that between entry #0 and entry #1 we are missing an entry for target_3. With fixes, we get desired full stack traces: caller: 0x758fff - 0x7595ab target_1: 0x758fd5 - 0x758fff target_2: 0x758fca - 0x758fd5 target_3: 0x758fbf - 0x758fca target_4: 0x758fb3 - 0x758fbf ENTRY #0: 0x758fb7 (in target_4) ENTRY #1: 0x758fc8 (in target_3) ENTRY #2: 0x758fd3 (in target_2) ENTRY #3: 0x758ffd (in target_1) ENTRY #4: 0x758ff3 (in target_1) ENTRY #5: 0x75922c (in caller) ENTRY #6: 0x6f8f39 ENTRY #7: 0x6fa6f0 ENTRY #8: 0x7f986adc4cd0 Now there is a logical and complete sequence of function calls. Link: https://lore.kernel.org/all/[email protected]/ Signed-off-by: Andrii Nakryiko <[email protected]> Acked-by: Jiri Olsa <[email protected]> Signed-off-by: Masami Hiramatsu (Google) <[email protected]>
1 parent 4a365eb commit 637c26f

File tree

2 files changed

+282
-0
lines changed

2 files changed

+282
-0
lines changed

‎tools/testing/selftests/bpf/prog_tests/uretprobe_stack.c

Lines changed: 186 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,186 @@
1+
// SPDX-License-Identifier: GPL-2.0
2+
/* Copyright (c) 2024 Meta Platforms, Inc. and affiliates. */
3+
4+
#include <test_progs.h>
5+
#include "uretprobe_stack.skel.h"
6+
#include "../sdt.h"
7+
8+
/* We set up target_1() -> target_2() -> target_3() -> target_4() -> USDT()
9+
* call chain, each being traced by our BPF program. On entry or return from
10+
* each target_*() we are capturing user stack trace and recording it in
11+
* global variable, so that user space part of the test can validate it.
12+
*
13+
* Note, we put each target function into a custom section to get those
14+
* __start_XXX/__stop_XXX symbols, generated by linker for us, which allow us
15+
* to know address range of those functions
16+
*/
17+
__attribute__((section("uprobe__target_4")))
18+
__weak int target_4(void)
19+
{
20+
STAP_PROBE1(uretprobe_stack, target, 42);
21+
return 42;
22+
}
23+
24+
extern const void *__start_uprobe__target_4;
25+
extern const void *__stop_uprobe__target_4;
26+
27+
__attribute__((section("uprobe__target_3")))
28+
__weak int target_3(void)
29+
{
30+
return target_4();
31+
}
32+
33+
extern const void *__start_uprobe__target_3;
34+
extern const void *__stop_uprobe__target_3;
35+
36+
__attribute__((section("uprobe__target_2")))
37+
__weak int target_2(void)
38+
{
39+
return target_3();
40+
}
41+
42+
extern const void *__start_uprobe__target_2;
43+
extern const void *__stop_uprobe__target_2;
44+
45+
__attribute__((section("uprobe__target_1")))
46+
__weak int target_1(int depth)
47+
{
48+
if (depth < 1)
49+
return 1 + target_1(depth + 1);
50+
else
51+
return target_2();
52+
}
53+
54+
extern const void *__start_uprobe__target_1;
55+
extern const void *__stop_uprobe__target_1;
56+
57+
extern const void *__start_uretprobe_stack_sec;
58+
extern const void *__stop_uretprobe_stack_sec;
59+
60+
struct range {
61+
long start;
62+
long stop;
63+
};
64+
65+
static struct range targets[] = {
66+
{}, /* we want target_1 to map to target[1], so need 1-based indexing */
67+
{ (long)&__start_uprobe__target_1, (long)&__stop_uprobe__target_1 },
68+
{ (long)&__start_uprobe__target_2, (long)&__stop_uprobe__target_2 },
69+
{ (long)&__start_uprobe__target_3, (long)&__stop_uprobe__target_3 },
70+
{ (long)&__start_uprobe__target_4, (long)&__stop_uprobe__target_4 },
71+
};
72+
73+
static struct range caller = {
74+
(long)&__start_uretprobe_stack_sec,
75+
(long)&__stop_uretprobe_stack_sec,
76+
};
77+
78+
static void validate_stack(__u64 *ips, int stack_len, int cnt, ...)
79+
{
80+
int i, j;
81+
va_list args;
82+
83+
if (!ASSERT_GT(stack_len, 0, "stack_len"))
84+
return;
85+
86+
stack_len /= 8;
87+
88+
/* check if we have enough entries to satisfy test expectations */
89+
if (!ASSERT_GE(stack_len, cnt, "stack_len2"))
90+
return;
91+
92+
if (env.verbosity >= VERBOSE_NORMAL) {
93+
printf("caller: %#lx - %#lx\n", caller.start, caller.stop);
94+
for (i = 1; i < ARRAY_SIZE(targets); i++)
95+
printf("target_%d: %#lx - %#lx\n", i, targets[i].start, targets[i].stop);
96+
for (i = 0; i < stack_len; i++) {
97+
for (j = 1; j < ARRAY_SIZE(targets); j++) {
98+
if (ips[i] >= targets[j].start && ips[i] < targets[j].stop)
99+
break;
100+
}
101+
if (j < ARRAY_SIZE(targets)) { /* found target match */
102+
printf("ENTRY #%d: %#lx (in target_%d)\n", i, (long)ips[i], j);
103+
} else if (ips[i] >= caller.start && ips[i] < caller.stop) {
104+
printf("ENTRY #%d: %#lx (in caller)\n", i, (long)ips[i]);
105+
} else {
106+
printf("ENTRY #%d: %#lx\n", i, (long)ips[i]);
107+
}
108+
}
109+
}
110+
111+
va_start(args, cnt);
112+
113+
for (i = cnt - 1; i >= 0; i--) {
114+
/* most recent entry is the deepest target function */
115+
const struct range *t = va_arg(args, const struct range *);
116+
117+
ASSERT_GE(ips[i], t->start, "addr_start");
118+
ASSERT_LT(ips[i], t->stop, "addr_stop");
119+
}
120+
121+
va_end(args);
122+
}
123+
124+
/* __weak prevents inlining */
125+
__attribute__((section("uretprobe_stack_sec")))
126+
__weak void test_uretprobe_stack(void)
127+
{
128+
LIBBPF_OPTS(bpf_uprobe_opts, uprobe_opts);
129+
struct uretprobe_stack *skel;
130+
int err;
131+
132+
skel = uretprobe_stack__open_and_load();
133+
if (!ASSERT_OK_PTR(skel, "skel_open"))
134+
return;
135+
136+
err = uretprobe_stack__attach(skel);
137+
if (!ASSERT_OK(err, "skel_attach"))
138+
goto cleanup;
139+
140+
/* trigger */
141+
ASSERT_EQ(target_1(0), 42 + 1, "trigger_return");
142+
143+
/*
144+
* Stacks captured on ENTRY uprobes
145+
*/
146+
147+
/* (uprobe 1) target_1 in stack trace*/
148+
validate_stack(skel->bss->entry_stack1, skel->bss->entry1_len,
149+
2, &caller, &targets[1]);
150+
/* (uprobe 1, recursed) */
151+
validate_stack(skel->bss->entry_stack1_recur, skel->bss->entry1_recur_len,
152+
3, &caller, &targets[1], &targets[1]);
153+
/* (uprobe 2) caller -> target_1 -> target_1 -> target_2 */
154+
validate_stack(skel->bss->entry_stack2, skel->bss->entry2_len,
155+
4, &caller, &targets[1], &targets[1], &targets[2]);
156+
/* (uprobe 3) */
157+
validate_stack(skel->bss->entry_stack3, skel->bss->entry3_len,
158+
5, &caller, &targets[1], &targets[1], &targets[2], &targets[3]);
159+
/* (uprobe 4) caller -> target_1 -> target_1 -> target_2 -> target_3 -> target_4 */
160+
validate_stack(skel->bss->entry_stack4, skel->bss->entry4_len,
161+
6, &caller, &targets[1], &targets[1], &targets[2], &targets[3], &targets[4]);
162+
163+
/* (USDT): full caller -> target_1 -> target_1 -> target_2 (uretprobed)
164+
* -> target_3 -> target_4 (uretprobes) chain
165+
*/
166+
validate_stack(skel->bss->usdt_stack, skel->bss->usdt_len,
167+
6, &caller, &targets[1], &targets[1], &targets[2], &targets[3], &targets[4]);
168+
169+
/*
170+
* Now stacks captured on the way out in EXIT uprobes
171+
*/
172+
173+
/* (uretprobe 4) everything up to target_4, but excluding it */
174+
validate_stack(skel->bss->exit_stack4, skel->bss->exit4_len,
175+
5, &caller, &targets[1], &targets[1], &targets[2], &targets[3]);
176+
/* we didn't install uretprobes on target_2 and target_3 */
177+
/* (uretprobe 1, recur) first target_1 call only */
178+
validate_stack(skel->bss->exit_stack1_recur, skel->bss->exit1_recur_len,
179+
2, &caller, &targets[1]);
180+
/* (uretprobe 1) just a caller in the stack trace */
181+
validate_stack(skel->bss->exit_stack1, skel->bss->exit1_len,
182+
1, &caller);
183+
184+
cleanup:
185+
uretprobe_stack__destroy(skel);
186+
}

‎tools/testing/selftests/bpf/progs/uretprobe_stack.c

Lines changed: 96 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,96 @@
1+
// SPDX-License-Identifier: GPL-2.0
2+
/* Copyright (c) 2024 Meta Platforms, Inc. and affiliates. */
3+
#include <vmlinux.h>
4+
#include <bpf/bpf_helpers.h>
5+
#include <bpf/bpf_tracing.h>
6+
#include <bpf/usdt.bpf.h>
7+
8+
char _license[] SEC("license") = "GPL";
9+
10+
__u64 entry_stack1[32], exit_stack1[32];
11+
__u64 entry_stack1_recur[32], exit_stack1_recur[32];
12+
__u64 entry_stack2[32];
13+
__u64 entry_stack3[32];
14+
__u64 entry_stack4[32], exit_stack4[32];
15+
__u64 usdt_stack[32];
16+
17+
int entry1_len, exit1_len;
18+
int entry1_recur_len, exit1_recur_len;
19+
int entry2_len, exit2_len;
20+
int entry3_len, exit3_len;
21+
int entry4_len, exit4_len;
22+
int usdt_len;
23+
24+
#define SZ sizeof(usdt_stack)
25+
26+
SEC("uprobe//proc/self/exe:target_1")
27+
int BPF_UPROBE(uprobe_1)
28+
{
29+
/* target_1 is recursive wit depth of 2, so we capture two separate
30+
* stack traces, depending on which occurence it is
31+
*/
32+
static bool recur = false;
33+
34+
if (!recur)
35+
entry1_len = bpf_get_stack(ctx, &entry_stack1, SZ, BPF_F_USER_STACK);
36+
else
37+
entry1_recur_len = bpf_get_stack(ctx, &entry_stack1_recur, SZ, BPF_F_USER_STACK);
38+
39+
recur = true;
40+
return 0;
41+
}
42+
43+
SEC("uretprobe//proc/self/exe:target_1")
44+
int BPF_URETPROBE(uretprobe_1)
45+
{
46+
/* see above, target_1 is recursive */
47+
static bool recur = false;
48+
49+
/* NOTE: order of returns is reversed to order of entries */
50+
if (!recur)
51+
exit1_recur_len = bpf_get_stack(ctx, &exit_stack1_recur, SZ, BPF_F_USER_STACK);
52+
else
53+
exit1_len = bpf_get_stack(ctx, &exit_stack1, SZ, BPF_F_USER_STACK);
54+
55+
recur = true;
56+
return 0;
57+
}
58+
59+
SEC("uprobe//proc/self/exe:target_2")
60+
int BPF_UPROBE(uprobe_2)
61+
{
62+
entry2_len = bpf_get_stack(ctx, &entry_stack2, SZ, BPF_F_USER_STACK);
63+
return 0;
64+
}
65+
66+
/* no uretprobe for target_2 */
67+
68+
SEC("uprobe//proc/self/exe:target_3")
69+
int BPF_UPROBE(uprobe_3)
70+
{
71+
entry3_len = bpf_get_stack(ctx, &entry_stack3, SZ, BPF_F_USER_STACK);
72+
return 0;
73+
}
74+
75+
/* no uretprobe for target_3 */
76+
77+
SEC("uprobe//proc/self/exe:target_4")
78+
int BPF_UPROBE(uprobe_4)
79+
{
80+
entry4_len = bpf_get_stack(ctx, &entry_stack4, SZ, BPF_F_USER_STACK);
81+
return 0;
82+
}
83+
84+
SEC("uretprobe//proc/self/exe:target_4")
85+
int BPF_URETPROBE(uretprobe_4)
86+
{
87+
exit4_len = bpf_get_stack(ctx, &exit_stack4, SZ, BPF_F_USER_STACK);
88+
return 0;
89+
}
90+
91+
SEC("usdt//proc/self/exe:uretprobe_stack:target")
92+
int BPF_USDT(usdt_probe)
93+
{
94+
usdt_len = bpf_get_stack(ctx, &usdt_stack, SZ, BPF_F_USER_STACK);
95+
return 0;
96+
}

0 commit comments

Comments
 (0)