Add tests for BPF Streams

Add tests for BPF Streams. The tests access both the stdout
and stderr streams, and ensure the code works regardless of
whether there is ready data.

Signed-off-by: Emil Tsalapatis <[email protected]>

Author: etsal

libbpf-rs/tests/bin/src/stream.bpf.c

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2025 Meta Platforms, Inc. and affiliates. */
+
+#include "vmlinux.h"
+#include <bpf/bpf_helpers.h>
+
+/* Definition of can_loop taken from bpf_experimental.h. */
+#ifdef __BPF_FEATURE_MAY_GOTO
+#define can_loop                                                               \
+    ({                                                                         \
+        __label__ l_break, l_continue;                                         \
+        bool ret = true;                                                       \
+        asm volatile goto("may_goto %l[l_break]" :: ::l_break);                \
+        goto l_continue;                                                       \
+    l_break:                                                                   \
+        ret = false;                                                           \
+    l_continue:;                                                               \
+        ret;                                                                   \
+    })
+#else
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#define can_loop                                                               \
+    ({                                                                         \
+        __label__ l_break, l_continue;                                         \
+        bool ret = true;                                                       \
+        asm volatile goto("1:.byte 0xe5;		\
+		      .byte 0;				\
+		      .long ((%l[l_break] - 1b - 8) / 8) & 0xffff;	\
+		      .short 0" :: ::l_break);                                 \
+        goto l_continue;                                                       \
+    l_break:                                                                   \
+        ret = false;                                                           \
+    l_continue:;                                                               \
+        ret;                                                                   \
+    })
+#else
+#define can_loop                                                               \
+    ({                                                                         \
+        __label__ l_break, l_continue;                                         \
+        bool ret = true;                                                       \
+        asm volatile goto("1:.byte 0xe5;		\
+		      .byte 0;				\
+		      .long (((%l[l_break] - 1b - 8) / 8) & 0xffff) << 16;	\
+		      .short 0" :: ::l_break);                                 \
+        goto l_continue;                                                       \
+    l_break:                                                                   \
+        ret = false;                                                           \
+    l_continue:;                                                               \
+        ret;                                                                   \
+    })
+#endif
+#endif
+
+volatile u64 i;
+
+/*
+ * Trigger a may_goto timeout to emit a streams error. As of 6.19 the only way
+ * to trigger streams output is by causing an error condition in the program.
+ * One of these is a loop timeout: The may_goto macro allows for loops that
+ * cannot be verified by embedding a timer that is guaranteed to expire in the
+ * condition, simplifying verification. When the timer expires, the kernel
+ * writes an error message to the stderr stream of the BPF program. This is the
+ * case below.
+ */
+SEC("syscall")
+int trigger_streams(void *ctx)
+{
+    while (i == 0 && can_loop)
+        ;
+    return 0;
+}
+
+char LICENSE[] SEC("license") = "GPL";

libbpf-rs/tests/common/mod.rs

@@ -15,7 +15,6 @@ use libbpf_rs::ObjectBuilder;
 use libbpf_rs::OpenObject;
 use libbpf_rs::ProgramMut;
 
-
 pub fn get_test_object_path(filename: &str) -> PathBuf {
     let mut path = PathBuf::new();
     // env!() macro fails at compile time if var not found

libbpf-rs/tests/test_streams.rs

@@ -0,0 +1,68 @@
+//! Tests for BPF program streams (stdout/stderr).
+
+mod common;
+
+use std::io::Read;
+
+use libbpf_rs::ProgramInput;
+use test_tag::tag;
+
+use crate::common::get_prog_mut;
+use crate::common::get_test_object;
+
+/// Test that we can read from a BPF program's stdout stream.
+///
+/// This test loads a BPF program that triggers the streams mechanism,
+/// runs it, and then attempts to read from the stdout stream.
+#[tag(root)]
+#[test]
+#[ignore]
+fn test_stream_stdout_read() {
+    let mut obj = get_test_object("stream.bpf.o");
+    let prog = get_prog_mut(&mut obj, "trigger_streams");
+
+    let input = ProgramInput::default();
+    let _output = prog.test_run(input).unwrap();
+
+    let mut stdout = prog.stdout();
+    let mut buf = [0u8; 1024];
+
+    // The read itself should succeed and return 0 bytes
+    let result = stdout.read(&mut buf);
+    assert!(
+        result.is_ok(),
+        "Failed to read from stdout stream: {:?}",
+        result.err()
+    );
+
+    let len = result.unwrap();
+    assert!(
+        len == 0,
+        "Unexpectedly read {} characters from stderr stream",
+        len
+    );
+}
+
+#[tag(root)]
+#[test]
+#[ignore]
+fn test_stream_stderr_read() {
+    let mut obj = get_test_object("stream.bpf.o");
+    let prog = get_prog_mut(&mut obj, "trigger_streams");
+
+    let input = ProgramInput::default();
+    let _output = prog.test_run(input).unwrap();
+
+    let mut stderr = prog.stderr();
+    let mut buf = [0u8; 1024];
+
+    // The read should successfully read a non-zero amount of bytes
+    let result = stderr.read(&mut buf);
+    assert!(
+        result.is_ok(),
+        "Failed to read from stderr stream: {:?}",
+        result.err()
+    );
+
+    assert!(result.unwrap() != 0, "No output from stderr stream");
+}