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: 16+ 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 21:34 ` bot+bpf-ci
2026-11-20 22:38 ` 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 21:34 ` bot+bpf-ci
2026-11-20 22:38 ` Tamir Duberstein
2026-11-21 10:01 ` Andrea Righi
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 21:34 ` bot+bpf-ci
2026-11-20 22:38 ` 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 an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.