[bpf-ci-bot] sock_iter_batch/udp test flakes on s390x cpuv4

[kernel-patches-review-bot]

The sock_iter_batch/udp test flakes on s390x cpuv4 (and potentially other architectures) because the kernel's UDP auto-port assignment can assign the same port to both SO_REUSEPORT socket groups. When ports[0] == ports[1], the BPF program assigns idx=0 to all sockets, causing the second_idx assertion to fail in the second read loop.

Failure Details

• Test / Component: sock_iter_batch/udp (prog_tests/sock_iter_batch.c do_test())
• Frequency: Observed in baseline CI (not PR-specific); likely rare but reproducible when port auto-assignment collides
• Failure mode: Wrong result (flaky) — second_idx: actual 0 != expected 1
• Affected architectures: s390x cpuv4 observed; any architecture possible depending on port randomization
• CI runs observed:
  • https://github.com/kernel-patches/bpf/actions/runs/22360861889 (for-next_test BASELINE, s390x cpuv4)

Root Cause Analysis

The test creates two groups of 4 SO_REUSEPORT UDP sockets (do_test at prog_tests/sock_iter_batch.c:866), each binding to auto-assigned port 0 via start_reuseport_server(). The auto-assigned ports are stored in skel->rodata->ports[0] and skel->rodata->ports[1] (line 890).

The kernel's udp_lib_lport_inuse() (net/ipv4/udp.c:141) builds a bitmap of "in use" ports for auto-assignment. However, when both the existing and new sockets have SO_REUSEPORT set and share the same UID, the existing port's bit is not set in the bitmap (lines 158-163):

if (sk2->sk_reuseport && sk->sk_reuseport &&
    !rcu_access_pointer(sk->sk_reuseport_cb) &&
    uid_eq(uid, sk_uid(sk2))) {
    if (!bitmap)
        return 0;
    /* bit NOT set — port appears available */
}

This allows the second group's bind(port=0) to receive the same port as the first group.

When ports[0] == ports[1], the BPF program iter_udp_soreuse (progs/sock_iter_batch.c:115-118) always takes the idx=0 branch (since sk->sk_num == ports[0] is checked first and is true for ALL sockets). The test then:

1. Reads 3 sockets with idx=0 in the first loop → first_idx=0
2. Closes fds[first_idx] (first group)
3. Sets second_idx = !first_idx = 1
4. Reads remaining sockets — still idx=0 (since ports[0]==ports[1])
5. Assertion ASSERT_EQ(outputs[i].idx, second_idx) fails: 0 != 1

The existing bucket collision guard at line 957 only protects the total_read assertion, not the second_idx assertion at line 947.

Proposed Fix

Add an assertion that the two auto-assigned ports are distinct, immediately after socket creation (prog_tests/sock_iter_batch.c:891). See attached patch: 0001-selftests-bpf-fix-sock_iter_batch-flake-due-to-SO_RE.patch.

This converts the cryptic second_idx failure into a clear distinct_ports assertion, making the root cause immediately obvious. The collision is inherent to SO_REUSEPORT + auto-port-assignment and cannot be prevented at the test level without using explicit ports.

Impact

Without the fix, the sock_iter_batch/udp subtest intermittently fails in CI with a misleading second_idx error that looks like a BPF iterator bug. This creates noise in CI results and wastes developer time investigating iterator logic when the actual issue is port auto-assignment behavior.

References

• net/ipv4/udp.c:141 — udp_lib_lport_inuse() SO_REUSEPORT bitmap skip
• tools/testing/selftests/bpf/prog_tests/sock_iter_batch.c:866 — do_test()
• tools/testing/selftests/bpf/progs/sock_iter_batch.c:115 — BPF program port comparison
• Commit dbd7db7787ba ("selftests/bpf: Test udp and tcp iter batching") — original test

[kernel-patches-review-bot]

0001-selftests-bpf-fix-sock_iter_batch-flake-due-to-SO_RE.patch

From: BPF CI Bot <bot+bpf-ci@kernel.org>
Subject: [PATCH] selftests/bpf: fix sock_iter_batch flake due to SO_REUSEPORT port collision

The sock_iter_batch test creates two groups of SO_REUSEPORT sockets,
each bound to an auto-assigned port (bind with port 0). The test then
iterates over the sockets using a BPF iterator and validates that
sockets from each group are reported with the correct index based on
their port number.

However, the kernel's UDP auto-port assignment does not consider
SO_REUSEPORT ports as "in use" when building the port availability
bitmap in udp_lib_lport_inuse(). When both the existing and new socket
have SO_REUSEPORT set with the same UID, the existing port's bit is
not set in the bitmap, allowing the auto-assignment to pick the same
port for the second group.

When both groups receive the same port, ports[0] == ports[1], and the
BPF program assigns idx=0 to ALL sockets (since sk->sk_num == ports[0]
is checked first). After the first loop reads 3 sockets and closes the
first group, the second loop expects idx=1 (second_idx = !first_idx)
but sees idx=0, causing:

  do_test:FAIL:second_idx unexpected second_idx: actual 0 != expected 1

This was observed on s390x cpuv4 in baseline CI runs, but can occur on
any architecture depending on port randomization.

Fix by asserting that the two auto-assigned ports are distinct before
proceeding with the test.

Fixes: dbd7db7787ba ("selftests/bpf: Test udp and tcp iter batching")
Generated-by: BPF CI Bot (claude-opus-4-6) <bot+bpf-ci@kernel.org>
---
 .../selftests/bpf/prog_tests/sock_iter_batch.c         | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/tools/testing/selftests/bpf/prog_tests/sock_iter_batch.c b/tools/testing/selftests/bpf/prog_tests/sock_iter_batch.c
index 27781df8f2fb..6fda1dd99846 100644
--- a/tools/testing/selftests/bpf/prog_tests/sock_iter_batch.c
+++ b/tools/testing/selftests/bpf/prog_tests/sock_iter_batch.c
@@ -889,6 +889,15 @@ static void do_test(int sock_type, bool onebyone)
 			goto done;
 		skel->rodata->ports[i] = ntohs(local_port);
 	}
+	/* With SO_REUSEPORT, the kernel's auto-port assignment may
+	 * assign the same port to both groups since reuseport ports
+	 * are not considered "in use" during auto-assignment. Bail
+	 * out if this happens since the test relies on distinct ports.
+	 */
+	if (!ASSERT_NEQ(skel->rodata->ports[0], skel->rodata->ports[1],
+			"distinct_ports"))
+		goto done;
+
 	skel->rodata->sf = AF_INET6;
 	if (sock_type == SOCK_STREAM)
 		skel->rodata->ss = TCP_LISTEN;
--
2.43.0