Skip to content

Commit 6f02786

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 89eb5e5 commit 6f02786

File tree

3 files changed

+232
-0
lines changed

3 files changed

+232
-0
lines changed

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

Lines changed: 140 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,140 @@
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\0"
28+
"CPU: [0-9]+ UID: 0 PID: [0-9]+ Comm: test_progs\n\0"
29+
"Call trace:\n\0"
30+
"([a-zA-Z_][a-zA-Z0-9_]*\\+0x[0-9a-fA-F]+/0x[0-9a-fA-F]+\n\0"
31+
"|[ \t]+[^\n]+\n\0)*",
32+
},
33+
{
34+
offsetof(struct stream, progs.stream_deadlock),
35+
"ERROR: AA or ABBA deadlock detected for bpf_res_spin_lock\n\0"
36+
"Attempted lock = (0x[0-9a-fA-F]+)\n\0"
37+
"Total held locks = 1\n\0"
38+
"Held lock\\[ 0\\] = \\1\n\0" // Lock address must match
39+
"CPU: [0-9]+ UID: 0 PID: [0-9]+ Comm: test_progs\n\0"
40+
"Call trace:\n\0"
41+
"([a-zA-Z_][a-zA-Z0-9_]*\\+0x[0-9a-fA-F]+/0x[0-9a-fA-F]+\n\0"
42+
"|[ \t]+[^\n]+\n\0)*",
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+
return -1;
54+
rc = regexec(&re, string, 0, NULL, 0);
55+
regfree(&re);
56+
return rc == 0 ? 1 : 0;
57+
}
58+
59+
void test_stream_errors(void)
60+
{
61+
LIBBPF_OPTS(bpf_test_run_opts, opts);
62+
LIBBPF_OPTS(bpf_prog_stream_read_opts, ropts);
63+
char buf[1024] = {};
64+
struct stream *skel;
65+
int ret, prog_fd;
66+
67+
skel = stream__open_and_load();
68+
if (!ASSERT_OK_PTR(skel, "stream__open_and_load"))
69+
return;
70+
71+
for (int i = 0; i < ARRAY_SIZE(stream_error_arr); i++) {
72+
struct bpf_program **prog;
73+
74+
prog = (struct bpf_program **)(((char *)skel) + stream_error_arr[i].prog_off);
75+
prog_fd = bpf_program__fd(*prog);
76+
ret = bpf_prog_test_run_opts(prog_fd, &opts);
77+
ASSERT_OK(ret, "ret");
78+
ASSERT_OK(opts.retval, "retval");
79+
80+
#if !defined(__x86_64__)
81+
ASSERT_TRUE(1, "Timed may_goto unsupported, skip.");
82+
if (i == 0) {
83+
ret = bpf_prog_stream_read(prog_fd, 2, buf, sizeof(buf), &ropts);
84+
ASSERT_EQ(ret, 0, "stream read");
85+
continue;
86+
}
87+
#endif
88+
89+
ret = bpf_prog_stream_read(prog_fd, BPF_STREAM_STDERR, buf, sizeof(buf), &ropts);
90+
ASSERT_GT(ret, 0, "stream read");
91+
ASSERT_LE(ret, 1023, "len for buf");
92+
buf[ret] = '\0';
93+
94+
ret = match_regex(stream_error_arr[i].errstr, buf);
95+
ASSERT_TRUE(ret == 1, "regex match");
96+
}
97+
98+
stream__destroy(skel);
99+
}
100+
101+
void test_stream_syscall(void)
102+
{
103+
LIBBPF_OPTS(bpf_test_run_opts, opts);
104+
LIBBPF_OPTS(bpf_prog_stream_read_opts, ropts);
105+
struct stream *skel;
106+
int ret, prog_fd;
107+
char buf[64];
108+
109+
skel = stream__open_and_load();
110+
if (!ASSERT_OK_PTR(skel, "stream__open_and_load"))
111+
return;
112+
113+
prog_fd = bpf_program__fd(skel->progs.stream_syscall);
114+
ret = bpf_prog_test_run_opts(prog_fd, &opts);
115+
ASSERT_OK(ret, "ret");
116+
ASSERT_OK(opts.retval, "retval");
117+
118+
ASSERT_LT(bpf_prog_stream_read(0, BPF_STREAM_STDOUT, buf, sizeof(buf), &ropts), 0, "error");
119+
ret = -errno;
120+
ASSERT_EQ(ret, -EINVAL, "bad prog_fd");
121+
122+
ASSERT_LT(bpf_prog_stream_read(prog_fd, 0, buf, sizeof(buf), &ropts), 0, "error");
123+
ret = -errno;
124+
ASSERT_EQ(ret, -ENOENT, "bad stream id");
125+
126+
ASSERT_LT(bpf_prog_stream_read(prog_fd, BPF_STREAM_STDOUT, NULL, sizeof(buf), NULL), 0, "error");
127+
ret = -errno;
128+
ASSERT_EQ(ret, -EFAULT, "bad stream buf");
129+
130+
ret = bpf_prog_stream_read(prog_fd, BPF_STREAM_STDOUT, buf, 2, NULL);
131+
ASSERT_EQ(ret, 2, "bytes");
132+
ret = bpf_prog_stream_read(prog_fd, BPF_STREAM_STDOUT, buf, 2, NULL);
133+
ASSERT_EQ(ret, 2, "bytes");
134+
ret = bpf_prog_stream_read(prog_fd, BPF_STREAM_STDOUT, buf, 1, &ropts);
135+
ASSERT_EQ(ret, 0, "no bytes stdout");
136+
ret = bpf_prog_stream_read(prog_fd, BPF_STREAM_STDERR, buf, 1, &ropts);
137+
ASSERT_EQ(ret, 0, "no bytes stderr");
138+
139+
stream__destroy(skel);
140+
}

‎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)