Skip to content

Commit 8173760

Browse files
kkdwivedikkdwivedi
committed
selftests/bpf: Add tests for prog streams
Add selftests to stress test the various facets of the stream API, memory allocation pattern, and ensuring dumping support is tested and functional. Signed-off-by: Kumar Kartikeya Dwivedi <[email protected]>
1 parent 598df5c commit 8173760

File tree

3 files changed

+238
-0
lines changed

3 files changed

+238
-0
lines changed

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

Lines changed: 146 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,146 @@
1+
// SPDX-License-Identifier: GPL-2.0
2+
/* Copyright (c) 2025 Meta Platforms, Inc. and affiliates. */
3+
#include <test_progs.h>
4+
#include <sys/mman.h>
5+
#include <regex.h>
6+
7+
#include "stream.skel.h"
8+
#include "stream_fail.skel.h"
9+
10+
void test_stream_failure(void)
11+
{
12+
RUN_TESTS(stream_fail);
13+
}
14+
15+
void test_stream_success(void)
16+
{
17+
RUN_TESTS(stream);
18+
return;
19+
}
20+
21+
struct {
22+
int prog_off;
23+
const char *errstr;
24+
} stream_error_arr[] = {
25+
{
26+
offsetof(struct stream, progs.stream_cond_break),
27+
"ERROR: Timeout detected for may_goto instruction\n"
28+
"CPU: [0-9]+ UID: 0 PID: [0-9]+ Comm: test_progs\n"
29+
"Call trace:\n"
30+
"([a-zA-Z_][a-zA-Z0-9_]*\\+0x[0-9a-fA-F]+/0x[0-9a-fA-F]+\n"
31+
"|[ \t]+[^\n]+\n)*",
32+
},
33+
{
34+
offsetof(struct stream, progs.stream_deadlock),
35+
"ERROR: AA or ABBA deadlock detected for bpf_res_spin_lock\n"
36+
"Attempted lock = (0x[0-9a-fA-F]+)\n"
37+
"Total held locks = 1\n"
38+
"Held lock\\[ 0\\] = \\1\n" // Lock address must match
39+
"CPU: [0-9]+ UID: 0 PID: [0-9]+ Comm: test_progs\n"
40+
"Call trace:\n"
41+
"([a-zA-Z_][a-zA-Z0-9_]*\\+0x[0-9a-fA-F]+/0x[0-9a-fA-F]+\n"
42+
"|[ \t]+[^\n]+\n)*",
43+
},
44+
};
45+
46+
static int match_regex(const char *pattern, const char *string)
47+
{
48+
int err, rc;
49+
regex_t re;
50+
51+
err = regcomp(&re, pattern, REG_EXTENDED | REG_NEWLINE);
52+
if (err) {
53+
char errbuf[512];
54+
55+
regerror(err, &re, errbuf, sizeof(errbuf));
56+
return -1;
57+
}
58+
rc = regexec(&re, string, 0, NULL, 0);
59+
regfree(&re);
60+
return rc == 0 ? 1 : 0;
61+
}
62+
63+
void test_stream_errors(void)
64+
{
65+
LIBBPF_OPTS(bpf_test_run_opts, opts);
66+
LIBBPF_OPTS(bpf_prog_stream_read_opts, ropts);
67+
char buf[1024] = {};
68+
struct stream *skel;
69+
int ret, prog_fd;
70+
71+
skel = stream__open_and_load();
72+
if (!ASSERT_OK_PTR(skel, "stream__open_and_load"))
73+
return;
74+
75+
for (int i = 0; i < ARRAY_SIZE(stream_error_arr); i++) {
76+
struct bpf_program **prog;
77+
78+
prog = (struct bpf_program **)(((char *)skel) + stream_error_arr[i].prog_off);
79+
prog_fd = bpf_program__fd(*prog);
80+
ret = bpf_prog_test_run_opts(prog_fd, &opts);
81+
ASSERT_OK(ret, "ret");
82+
ASSERT_OK(opts.retval, "retval");
83+
84+
#if !defined(__x86_64__)
85+
ASSERT_TRUE(1, "Timed may_goto unsupported, skip.");
86+
if (i == 0) {
87+
ret = bpf_prog_stream_read(prog_fd, 2, buf, sizeof(buf), &ropts);
88+
ASSERT_EQ(ret, 0, "stream read");
89+
continue;
90+
}
91+
#endif
92+
93+
ret = bpf_prog_stream_read(prog_fd, BPF_STREAM_STDERR, buf, sizeof(buf), &ropts);
94+
ASSERT_GT(ret, 0, "stream read");
95+
int len = ret;
96+
97+
ret = match_regex(stream_error_arr[i].errstr, buf);
98+
ASSERT_GE(ret, 0, "regex match noerror");
99+
ASSERT_TRUE(ret == 0, "regex match");
100+
101+
fwrite(buf, 1, len, stdout);
102+
}
103+
104+
stream__destroy(skel);
105+
}
106+
107+
void test_stream_syscall(void)
108+
{
109+
LIBBPF_OPTS(bpf_test_run_opts, opts);
110+
LIBBPF_OPTS(bpf_prog_stream_read_opts, ropts);
111+
struct stream *skel;
112+
int ret, prog_fd;
113+
char buf[64];
114+
115+
skel = stream__open_and_load();
116+
if (!ASSERT_OK_PTR(skel, "stream__open_and_load"))
117+
return;
118+
119+
prog_fd = bpf_program__fd(skel->progs.stream_syscall);
120+
ret = bpf_prog_test_run_opts(prog_fd, &opts);
121+
ASSERT_OK(ret, "ret");
122+
ASSERT_OK(opts.retval, "retval");
123+
124+
ASSERT_LT(bpf_prog_stream_read(0, BPF_STREAM_STDOUT, buf, sizeof(buf), &ropts), 0, "error");
125+
ret = -errno;
126+
ASSERT_EQ(ret, -EINVAL, "bad prog_fd");
127+
128+
ASSERT_LT(bpf_prog_stream_read(prog_fd, 0, buf, sizeof(buf), &ropts), 0, "error");
129+
ret = -errno;
130+
ASSERT_EQ(ret, -ENOENT, "bad stream id");
131+
132+
ASSERT_LT(bpf_prog_stream_read(prog_fd, BPF_STREAM_STDOUT, NULL, sizeof(buf), NULL), 0, "error");
133+
ret = -errno;
134+
ASSERT_EQ(ret, -EFAULT, "bad stream buf");
135+
136+
ret = bpf_prog_stream_read(prog_fd, BPF_STREAM_STDOUT, buf, 2, NULL);
137+
ASSERT_EQ(ret, 2, "bytes");
138+
ret = bpf_prog_stream_read(prog_fd, BPF_STREAM_STDOUT, buf, 2, NULL);
139+
ASSERT_EQ(ret, 2, "bytes");
140+
ret = bpf_prog_stream_read(prog_fd, BPF_STREAM_STDOUT, buf, 1, &ropts);
141+
ASSERT_EQ(ret, 0, "no bytes stdout");
142+
ret = bpf_prog_stream_read(prog_fd, BPF_STREAM_STDERR, buf, 1, &ropts);
143+
ASSERT_EQ(ret, 0, "no bytes stderr");
144+
145+
stream__destroy(skel);
146+
}

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

Lines changed: 75 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,75 @@
1+
// SPDX-License-Identifier: GPL-2.0
2+
/* Copyright (c) 2025 Meta Platforms, Inc. and affiliates. */
3+
#include <vmlinux.h>
4+
#include <bpf/bpf_tracing.h>
5+
#include <bpf/bpf_helpers.h>
6+
#include "bpf_misc.h"
7+
#include "bpf_experimental.h"
8+
9+
struct arr_elem {
10+
struct bpf_res_spin_lock lock;
11+
};
12+
13+
struct {
14+
__uint(type, BPF_MAP_TYPE_ARRAY);
15+
__uint(max_entries, 1);
16+
__type(key, int);
17+
__type(value, struct arr_elem);
18+
} arrmap SEC(".maps");
19+
20+
#define ENOSPC 28
21+
#define _STR "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
22+
23+
#define STREAM_STR (u64)(_STR _STR _STR _STR)
24+
25+
SEC("syscall")
26+
__success __retval(0)
27+
int stream_exhaust(void *ctx)
28+
{
29+
bpf_repeat(BPF_MAX_LOOPS)
30+
if (bpf_stream_printk(BPF_STDOUT, _STR) == -ENOSPC)
31+
return 0;
32+
return 1;
33+
}
34+
35+
SEC("syscall")
36+
__success __retval(0)
37+
int stream_cond_break(void *ctx)
38+
{
39+
while (can_loop)
40+
;
41+
return 0;
42+
}
43+
44+
SEC("syscall")
45+
__success __retval(0)
46+
int stream_deadlock(void *ctx)
47+
{
48+
struct bpf_res_spin_lock *lock, *nlock;
49+
50+
lock = bpf_map_lookup_elem(&arrmap, &(int){0});
51+
if (!lock)
52+
return 0;
53+
nlock = bpf_map_lookup_elem(&arrmap, &(int){0});
54+
if (!nlock)
55+
return 0;
56+
if (bpf_res_spin_lock(lock))
57+
return 0;
58+
if (bpf_res_spin_lock(nlock)) {
59+
bpf_res_spin_unlock(lock);
60+
return 0;
61+
}
62+
bpf_res_spin_unlock(nlock);
63+
bpf_res_spin_unlock(lock);
64+
return 0;
65+
}
66+
67+
SEC("syscall")
68+
__success __retval(0)
69+
int stream_syscall(void *ctx)
70+
{
71+
bpf_stream_printk(BPF_STDOUT, "foo");
72+
return 0;
73+
}
74+
75+
char _license[] SEC("license") = "GPL";

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

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
// SPDX-License-Identifier: GPL-2.0
2+
/* Copyright (c) 2025 Meta Platforms, Inc. and affiliates. */
3+
#include <vmlinux.h>
4+
#include <bpf/bpf_tracing.h>
5+
#include <bpf/bpf_helpers.h>
6+
#include <bpf/bpf_core_read.h>
7+
#include "bpf_misc.h"
8+
9+
SEC("syscall")
10+
__failure __msg("Possibly NULL pointer passed")
11+
int stream_vprintk_null_arg(void *ctx)
12+
{
13+
bpf_stream_vprintk(BPF_STDOUT, "", NULL, 0, NULL);
14+
return 0;
15+
}
16+
17+
char _license[] SEC("license") = "GPL";

0 commit comments

Comments
 (0)