From: Tamir Duberstein <tamird@kernel.org>
To: Alexei Starovoitov <ast@kernel.org>,
Daniel Borkmann <daniel@iogearbox.net>,
Andrii Nakryiko <andrii@kernel.org>,
Eduard Zingerman <eddyz87@gmail.com>,
Kumar Kartikeya Dwivedi <memxor@gmail.com>,
Martin KaFai Lau <martin.lau@linux.dev>,
Song Liu <song@kernel.org>,
Yonghong Song <yonghong.song@linux.dev>,
Jiri Olsa <jolsa@kernel.org>,
Emil Tsalapatis <emil@etsalapatis.com>,
Shuah Khan <shuah@kernel.org>, Andrea Righi <arighi@nvidia.com>,
Xu Kuohai <xukuohai@huawei.com>,
Andrea Righi <andrea.righi@canonical.com>,
Bing-Jhong Billy Jheng <billy@starlabs.sg>,
David Vernet <void@manifault.com>,
Ihor Solodrai <ihor.solodrai@linux.dev>
Cc: bpf@vger.kernel.org, linux-kselftest@vger.kernel.org,
linux-kernel@vger.kernel.org,
Andrew Werner <awerner32@gmail.com>,
Zvi Effron <zeffron@riotgames.com>,
Andrii Nakryiko <andriin@fb.com>,
Tamir Duberstein <tamird@kernel.org>
Subject: [PATCH bpf-next v3 8/8] selftests/bpf: Test caller-owned ring iterators
Date: Fri, 20 Nov 2026 15:33:21 -0500 [thread overview]
Message-ID: <20261120-bpf-ringbuf-fixes-v3-8-ff7ca15d6c37@kernel.org> (raw)
In-Reply-To: <20261120-bpf-ringbuf-fixes-v3-0-ff7ca15d6c37@kernel.org>
Verify borrowed-record lifetime, exhaustion, destruction, discard
handling, batched publication, and callback-free iteration. Exercise
edge-triggered epoll while draining through one iterator and while
destroying and recreating the iterator after each record. Observe
exhaustion before waiting for another notification.
Allow the BPF producer to discard a record between returned records, so
the batching test also checks deferred publication across discards.
Signed-off-by: Tamir Duberstein <tamird@kernel.org>
---
tools/testing/selftests/bpf/prog_tests/ringbuf.c | 167 +++++++++++++++++++++
tools/testing/selftests/bpf/progs/test_ringbuf_n.c | 7 +-
2 files changed, 173 insertions(+), 1 deletion(-)
diff --git a/tools/testing/selftests/bpf/prog_tests/ringbuf.c b/tools/testing/selftests/bpf/prog_tests/ringbuf.c
index cfc357dfd1e9..3e5bb241e799 100644
--- a/tools/testing/selftests/bpf/prog_tests/ringbuf.c
+++ b/tools/testing/selftests/bpf/prog_tests/ringbuf.c
@@ -635,6 +635,10 @@ static void ringbuf_wakeup_subtest(void)
process_noop_sample, NULL, NULL);
if (!ASSERT_OK_PTR(ringbuf, "ring_buffer__new"))
return;
+ struct ring *ring = ring_buffer__ring(ringbuf, 0);
+
+ if (!ASSERT_OK_PTR(ring, "ring_buffer__ring"))
+ return;
struct epoll_event event = {
.events = EPOLLIN | EPOLLET,
@@ -673,6 +677,41 @@ static void ringbuf_wakeup_subtest(void)
if (!ASSERT_OK(err, "ring_buffer__consume_n"))
return;
}
+
+ total = 0;
+ while (total < N_WAKEUP_SAMPLES) {
+ err = epoll_wait(epoll_fd, &event, 1, 1000);
+ if (!ASSERT_EQ(err, 1, "iterator_epoll_wait"))
+ return;
+
+ struct ring_buffer_iter iter
+ __attribute__((cleanup(ring_buffer_iter_destroy))) = {};
+ err = ring_buffer_iter_new(&iter, ring);
+ if (!ASSERT_OK(err, "ring_buffer_iter_new"))
+ return;
+ while (ring_buffer_iter_next(&iter, NULL, false))
+ total++;
+ }
+
+ /* Release each record through destruction before creating a new iterator. */
+ total = 0;
+ while (total < N_WAKEUP_SAMPLES) {
+ err = epoll_wait(epoll_fd, &event, 1, 1000);
+ if (!ASSERT_EQ(err, 1, "iterator_release_epoll_wait"))
+ return;
+
+ for (;;) {
+ struct ring_buffer_iter iter __attribute__((
+ cleanup(ring_buffer_iter_destroy))) = {};
+
+ err = ring_buffer_iter_new(&iter, ring);
+ if (!ASSERT_OK(err, "ring_buffer_iter_new"))
+ return;
+ if (!ring_buffer_iter_next(&iter, NULL, false))
+ break;
+ total++;
+ }
+ }
}
static void ringbuf_n_subtest(void)
@@ -733,6 +772,127 @@ static void ringbuf_n_subtest(void)
"positive_callback");
}
+static void ringbuf_iterator_subtest(void)
+{
+ struct test_ringbuf_n_lskel *skel_n
+ __attribute__((cleanup(cleanup_test_ringbuf_n_lskel))) =
+ test_ringbuf_n_lskel__open();
+ const struct sample_n *sample;
+ size_t sample_size;
+ int err, i;
+
+ if (!ASSERT_OK_PTR(skel_n, "test_ringbuf_n_lskel__open"))
+ return;
+
+ skel_n->maps.ringbuf.max_entries = getpagesize();
+ skel_n->bss->pid = getpid();
+ skel_n->bss->value = SAMPLE_VALUE;
+
+ err = test_ringbuf_n_lskel__load(skel_n);
+ if (!ASSERT_OK(err, "test_ringbuf_n_lskel__load"))
+ return;
+
+ err = test_ringbuf_n_lskel__attach(skel_n);
+ if (!ASSERT_OK(err, "test_ringbuf_n_lskel__attach"))
+ return;
+
+ struct ring_buffer *ringbuf
+ __attribute__((cleanup(cleanup_ring_buffer))) =
+ ring_buffer__new(skel_n->maps.ringbuf.map_fd, NULL,
+ NULL, NULL);
+ if (!ASSERT_OK_PTR(ringbuf, "ring_buffer__new"))
+ return;
+
+ struct ring *ring = ring_buffer__ring(ringbuf, 0);
+
+ if (!ASSERT_OK_PTR(ring, "ring_buffer__ring"))
+ return;
+
+ struct ring_buffer_iter iter
+ __attribute__((cleanup(ring_buffer_iter_destroy))) = {};
+
+ for (i = 0; i < 3; i++)
+ syscall(__NR_getpgid);
+
+ unsigned long consumer_pos = ring__consumer_pos(ring);
+
+ err = ring_buffer_iter_new(&iter, ring);
+ if (!ASSERT_OK(err, "ring_buffer_iter_new"))
+ return;
+ sample = ring_buffer_iter_next(&iter, &sample_size, true);
+ if (!ASSERT_OK_PTR(sample, "ring_buffer_iter_next"))
+ return;
+ ASSERT_EQ(sample_size, sizeof(*sample), "sample_size");
+ ASSERT_EQ(sample->value, SAMPLE_VALUE, "sample_value");
+ ASSERT_EQ(ring__consumer_pos(ring), consumer_pos,
+ "consumer_pos_iter_held");
+
+ ring_buffer_iter_destroy(&iter);
+ ASSERT_GT(ring__consumer_pos(ring), consumer_pos,
+ "consumer_pos_released");
+
+ err = ring_buffer_iter_new(&iter, ring);
+ if (!ASSERT_OK(err, "ring_buffer_iter_new_remaining"))
+ return;
+ consumer_pos = ring__consumer_pos(ring);
+ for (i = 0; (sample = ring_buffer_iter_next(&iter, &sample_size, true));
+ i++) {
+ ASSERT_EQ(sample_size, sizeof(*sample),
+ "remaining_sample_size");
+ ASSERT_EQ(sample->value, SAMPLE_VALUE,
+ "remaining_sample_value");
+ if (i)
+ ASSERT_GT(ring__consumer_pos(ring), consumer_pos,
+ "consumer_pos_released_next");
+ consumer_pos = ring__consumer_pos(ring);
+ }
+ ASSERT_EQ(i, 2, "remaining_samples");
+ ASSERT_GT(ring__consumer_pos(ring), consumer_pos,
+ "consumer_pos_released_null");
+
+ syscall(__NR_getpgid);
+ sample = ring_buffer_iter_next(&iter, &sample_size, true);
+ ASSERT_NULL(sample, "exhausted_iterator");
+ ring_buffer_iter_destroy(&iter);
+
+ err = ring_buffer_iter_new(&iter, ring);
+ if (!ASSERT_OK(err, "ring_buffer_iter_new_again"))
+ return;
+ sample = ring_buffer_iter_next(&iter, &sample_size, true);
+ if (!ASSERT_OK_PTR(sample, "ring_buffer_iter_next_again"))
+ return;
+ ASSERT_EQ(sample->value, SAMPLE_VALUE, "new_sample_value");
+ ring_buffer_iter_destroy(&iter);
+
+ for (i = 0; i < 4; i++) {
+ skel_n->bss->discard = i == 1;
+ syscall(__NR_getpgid);
+ }
+ skel_n->bss->discard = false;
+ consumer_pos = ring__consumer_pos(ring);
+ err = ring_buffer_iter_new(&iter, ring);
+ if (!ASSERT_OK(err, "ring_buffer_iter_new_batch"))
+ return;
+ for (i = 0; i < 2; i++) {
+ sample = ring_buffer_iter_next(&iter, &sample_size, false);
+ if (!ASSERT_OK_PTR(sample, "batch_sample"))
+ return;
+ ASSERT_EQ(ring__consumer_pos(ring), consumer_pos,
+ "consumer_pos_deferred");
+ }
+ sample = ring_buffer_iter_next(&iter, &sample_size, true);
+ if (!ASSERT_OK_PTR(sample, "batch_sync_sample"))
+ return;
+ ASSERT_EQ(ring__consumer_pos(ring),
+ ring__producer_pos(ring) - sizeof(*sample) -
+ BPF_RINGBUF_HDR_SZ,
+ "consumer_pos_batch_published");
+ sample = ring_buffer_iter_next(&iter, &sample_size, false);
+ ASSERT_NULL(sample, "batch_exhausted");
+ ASSERT_EQ(ring__consumer_pos(ring), ring__producer_pos(ring),
+ "consumer_pos_batch_exhausted");
+}
+
static int process_map_key_sample(void *ctx, void *data, size_t len)
{
struct test_ringbuf_map_key_lskel *skel_map_key = ctx;
@@ -809,6 +969,9 @@ static void ringbuf_overwrite_callback_subtest(void)
if (!ASSERT_OK_PTR(ring, "ring_buffer__ring"))
return;
+ struct ring_buffer_iter iter
+ __attribute__((cleanup(ring_buffer_iter_destroy))) = {};
+
err = ring_buffer__consume_n(ringbuf, 0);
ASSERT_EQ(err, -EOPNOTSUPP, "ringbuf_consume_zero");
err = ring_buffer__consume(ringbuf);
@@ -819,6 +982,8 @@ static void ringbuf_overwrite_callback_subtest(void)
ASSERT_EQ(err, -EOPNOTSUPP, "ring_consume_zero");
err = ring__consume(ring);
ASSERT_EQ(err, -EOPNOTSUPP, "ring_consume");
+ err = ring_buffer_iter_new(&iter, ring);
+ ASSERT_EQ(err, -EOPNOTSUPP, "ring_buffer_iter_new");
}
static void ringbuf_overwrite_mode_subtest(void)
@@ -886,6 +1051,8 @@ void test_ringbuf(void)
ringbuf_subtest();
if (test__start_subtest("ringbuf_n"))
ringbuf_n_subtest();
+ if (test__start_subtest("ringbuf_iterator"))
+ ringbuf_iterator_subtest();
if (test__start_subtest("ringbuf_null_cb"))
ringbuf_null_cb_subtest();
if (test__start_subtest("ringbuf_wakeup"))
diff --git a/tools/testing/selftests/bpf/progs/test_ringbuf_n.c b/tools/testing/selftests/bpf/progs/test_ringbuf_n.c
index a95d4f597175..1727a2c32812 100644
--- a/tools/testing/selftests/bpf/progs/test_ringbuf_n.c
+++ b/tools/testing/selftests/bpf/progs/test_ringbuf_n.c
@@ -3,6 +3,7 @@
#include <linux/bpf.h>
#include <sched.h>
+#include <stdbool.h>
#include <unistd.h>
#include <bpf/bpf_helpers.h>
#include "bpf_misc.h"
@@ -23,6 +24,7 @@ struct {
int pid = 0;
__s64 value = 0;
+bool discard = false;
SEC("fentry/" SYS_PREFIX "sys_getpgid")
int test_ringbuf_n(void *ctx)
@@ -41,7 +43,10 @@ int test_ringbuf_n(void *ctx)
sample->value = value;
bpf_get_current_comm(sample->comm, sizeof(sample->comm));
- bpf_ringbuf_submit(sample, 0);
+ if (discard)
+ bpf_ringbuf_discard(sample, 0);
+ else
+ bpf_ringbuf_submit(sample, 0);
return 0;
}
--
2.56.1
prev parent reply other threads:[~2026-11-20 20:34 UTC|newest]
Thread overview: 9+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-20 20:33 [PATCH bpf-next v3 0/8] bpf: Fix ring buffers and add a libbpf iterator Tamir Duberstein
2026-11-20 20:33 ` [PATCH bpf-next v3 1/8] bpf: user_ringbuf: Handle position wrap Tamir Duberstein
2026-11-20 20:33 ` [PATCH bpf-next v3 2/8] libbpf: ringbuf: Use compiler atomics Tamir Duberstein
2026-11-20 20:33 ` [PATCH bpf-next v3 3/8] libbpf: ringbuf: Prevent missed wakeups Tamir Duberstein
2026-11-20 20:33 ` [PATCH bpf-next v3 4/8] libbpf: ringbuf: Add a caller-owned iterator Tamir Duberstein
2026-11-20 20:33 ` [PATCH bpf-next v3 5/8] libbpf: ringbuf: Simplify iterator implementation Tamir Duberstein
2026-11-20 20:33 ` [PATCH bpf-next v3 6/8] selftests/bpf: Refactor lifetimes and test wakeups Tamir Duberstein
2026-11-20 20:33 ` [PATCH bpf-next v3 7/8] selftests/bpf: Verify ringbuf callback semantics Tamir Duberstein
2026-11-20 20:33 ` Tamir Duberstein [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261120-bpf-ringbuf-fixes-v3-8-ff7ca15d6c37@kernel.org \
--to=tamird@kernel.org \
--cc=andrea.righi@canonical.com \
--cc=andrii@kernel.org \
--cc=andriin@fb.com \
--cc=arighi@nvidia.com \
--cc=ast@kernel.org \
--cc=awerner32@gmail.com \
--cc=billy@starlabs.sg \
--cc=bpf@vger.kernel.org \
--cc=daniel@iogearbox.net \
--cc=eddyz87@gmail.com \
--cc=emil@etsalapatis.com \
--cc=ihor.solodrai@linux.dev \
--cc=jolsa@kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-kselftest@vger.kernel.org \
--cc=martin.lau@linux.dev \
--cc=memxor@gmail.com \
--cc=shuah@kernel.org \
--cc=song@kernel.org \
--cc=void@manifault.com \
--cc=xukuohai@huawei.com \
--cc=yonghong.song@linux.dev \
--cc=zeffron@riotgames.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®