mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
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


      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®