windows: deal with removal of XDP_TEST from efW

The upstream efW removed the XDP_TEST program type from the repository.
We rely on this type for our unit tests. Switch tests to the SAMPLE
program type, which is a separate driver but also distributed as part
of the efW runtime.

On Windows, running a SAMPLE program requires providing a (possibly
empty) context. To avoid having to change a lot of tests over and over
we introduce a new mustRun helper.

See: microsoft/ebpf-for-windows#4662
Signed-off-by: Lorenz Bauer <[email protected]>

Author: lmb

collection_test.go

@@ -13,7 +13,6 @@ import (
 
 	"github.com/cilium/ebpf/asm"
 	"github.com/cilium/ebpf/btf"
-	"github.com/cilium/ebpf/internal"
 	"github.com/cilium/ebpf/internal/testutils"
 	"github.com/cilium/ebpf/internal/testutils/testmain"
 )
@@ -161,11 +160,7 @@ func TestCollectionSpecRewriteMaps(t *testing.T) {
 
 	coll := mustNewCollection(t, cs, nil)
 
-	ret, _, err := coll.Programs["test-prog"].Test(internal.EmptyBPFContext)
-	testutils.SkipIfNotSupported(t, err)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ret := mustRun(t, coll.Programs["test-prog"], nil)
 
 	if ret != 2 {
 		t.Fatal("new / override map not used")
@@ -201,11 +196,7 @@ func TestCollectionSpecMapReplacements(t *testing.T) {
 		},
 	})
 
-	ret, _, err := coll.Programs["test-prog"].Test(internal.EmptyBPFContext)
-	testutils.SkipIfNotSupported(t, err)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ret := mustRun(t, coll.Programs["test-prog"], nil)
 
 	if ret != 2 {
 		t.Fatal("new / override map not used")

elf_reader_test.go

@@ -287,14 +287,8 @@ func TestLoadCollectionSpec(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		ret, _, err := coll.Programs["xdp_prog"].Test(internal.EmptyBPFContext)
-		if err != nil {
-			t.Fatal("Can't run program:", err)
-		}
-
-		if ret != 7 {
-			t.Error("Unexpected return value:", ret)
-		}
+		ret := mustRun(t, coll.Programs["xdp_prog"], nil)
+		qt.Assert(t, qt.Equals(ret, 7))
 	})
 }
 
@@ -322,11 +316,7 @@ func TestDataSections(t *testing.T) {
 	mustLoadAndAssign(t, coll, &obj, nil)
 	defer obj.Program.Close()
 
-	ret, _, err := obj.Program.Test(internal.EmptyBPFContext)
-	if err != nil {
-		t.Fatal(err)
-	}
-
+	ret := mustRun(t, obj.Program, nil)
 	if ret != 0 {
 		t.Error("BPF assertion failed on line", ret)
 	}
@@ -636,11 +626,7 @@ func TestTailCall(t *testing.T) {
 	defer obj.Tail.Close()
 	defer obj.ProgArray.Close()
 
-	ret, _, err := obj.TailMain.Test(internal.EmptyBPFContext)
-	testutils.SkipIfNotSupported(t, err)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ret := mustRun(t, obj.Tail, nil)
 
 	// Expect the tail_1 tail call to be taken, returning value 42.
 	if ret != 42 {
@@ -666,12 +652,7 @@ func TestKconfig(t *testing.T) {
 	}
 	defer obj.Main.Close()
 
-	ret, _, err := obj.Main.Test(internal.EmptyBPFContext)
-	testutils.SkipIfNotSupported(t, err)
-	if err != nil {
-		t.Fatal(err)
-	}
-
+	ret := mustRun(t, obj.Main, nil)
 	qt.Assert(t, qt.Equals(ret, 0), qt.Commentf("Failed assertion at line %d in testdata/kconfig.c", ret))
 }
 
@@ -691,9 +672,7 @@ func TestKsym(t *testing.T) {
 	defer obj.Main.Close()
 	defer obj.ArrayMap.Close()
 
-	_, _, err = obj.Main.Test(internal.EmptyBPFContext)
-	testutils.SkipIfNotSupported(t, err)
-	qt.Assert(t, qt.IsNil(err))
+	mustRun(t, obj.Main, nil)
 
 	ksyms := map[string]uint64{
 		"bpf_init":       0,
@@ -726,10 +705,8 @@ func TestKsymWeakMissing(t *testing.T) {
 	qt.Assert(t, qt.IsNil(err))
 	defer obj.Main.Close()
 
-	res, _, err := obj.Main.Test(internal.EmptyBPFContext)
-	testutils.SkipIfNotSupported(t, err)
-	qt.Assert(t, qt.IsNil(err))
-	qt.Assert(t, qt.Equals(res, 1))
+	ret := mustRun(t, obj.Main, nil)
+	qt.Assert(t, qt.Equals(ret, 1))
 }
 
 func TestKfunc(t *testing.T) {
@@ -751,11 +728,7 @@ func TestKfunc(t *testing.T) {
 	}
 	defer obj.Main.Close()
 
-	ret, _, err := obj.Main.Test(internal.EmptyBPFContext)
-	testutils.SkipIfNotSupported(t, err)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ret := mustRun(t, obj.Main, nil)
 
 	if ret != 1 {
 		t.Fatalf("Expected kfunc to return value 1, got %d", ret)
@@ -822,11 +795,7 @@ func TestKfuncKmod(t *testing.T) {
 	}
 	defer obj.Main.Close()
 
-	ret, _, err := obj.Main.Test(internal.EmptyBPFContext)
-	testutils.SkipIfNotSupported(t, err)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ret := mustRun(t, obj.Main, nil)
 
 	if ret != 1 {
 		t.Fatalf("Expected kfunc to return value 1, got %d", ret)
@@ -855,11 +824,7 @@ func TestSubprogRelocation(t *testing.T) {
 	defer obj.Main.Close()
 	defer obj.HashMap.Close()
 
-	ret, _, err := obj.Main.Test(internal.EmptyBPFContext)
-	testutils.SkipIfNotSupported(t, err)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ret := mustRun(t, obj.Main, nil)
 
 	if ret != 42 {
 		t.Fatalf("Expected subprog reloc to return value 42, got %d", ret)

helpers_test.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/cilium/ebpf/asm"
 	"github.com/cilium/ebpf/btf"
+	"github.com/cilium/ebpf/internal"
 	"github.com/cilium/ebpf/internal/platform"
 	"github.com/cilium/ebpf/internal/testutils"
 )
@@ -195,6 +196,33 @@ func mustLoadAndAssign(tb testing.TB, spec *CollectionSpec, to any, opts *Collec
 	qt.Assert(tb, qt.IsNil(loadAndAssign(tb, spec, to, opts)))
 }
 
+func mustRun(tb testing.TB, prog *Program, opts *RunOptions) (retval uint32) {
+	tb.Helper()
+
+	if opts == nil {
+		opts = &RunOptions{}
+	}
+	if platform.IsLinux && opts.Data == nil {
+		opts.Data = internal.EmptyBPFContext
+	}
+	if platform.IsWindows {
+		switch prog.Type() {
+		case WindowsSample:
+			const minSampleContextLen = 32
+
+			if opts.Context == nil {
+				opts.Context = make([]byte, minSampleContextLen)
+			}
+		}
+	}
+
+	ret, err := prog.Run(opts)
+	testutils.SkipIfNotSupported(tb, err)
+	qt.Assert(tb, qt.IsNil(err))
+
+	return ret
+}
+
 // The functions below translate Linux types to their Windows equivalents, if
 // possible. This allows running most tests on Windows without modification.
 
@@ -256,9 +284,9 @@ func fixupProgramType(typ ProgramType) ProgramType {
 
 	switch typ {
 	case SocketFilter:
-		return WindowsXDPTest
+		return WindowsSample
 	case XDP:
-		return WindowsXDPTest
+		return WindowsSample
 	default:
 		return typ
 	}

info_test.go

@@ -461,9 +461,7 @@ func testStats(tb testing.TB, prog *Program) error {
 
 	// Program execution with runtime statistics enabled.
 	// Should increase both runtime and run counter.
-	if _, _, err := prog.Test(in); err != nil {
-		return fmt.Errorf("failed to trigger program: %w", err)
-	}
+	mustRun(tb, prog, &RunOptions{Data: in})
 
 	s1, err := prog.Stats()
 	qt.Assert(tb, qt.IsNil(err))
@@ -475,9 +473,7 @@ func testStats(tb testing.TB, prog *Program) error {
 
 	// Second program execution, with runtime statistics gathering disabled.
 	// Total runtime and run counters are not expected to increase.
-	if _, _, err := prog.Test(in); err != nil {
-		return fmt.Errorf("failed to trigger program: %w", err)
-	}
+	mustRun(tb, prog, &RunOptions{Data: in})
 
 	s2, err := prog.Stats()
 	qt.Assert(tb, qt.IsNil(err))

internal/efw/proc_test.go

@@ -16,7 +16,7 @@ func TestNewProc(t *testing.T) {
 func TestCall(t *testing.T) {
 	var err error
 	allocs := testing.AllocsPerRun(10, func() {
-		_, err = EbpfGetEbpfAttachType(1)
+		_, err = EbpfGetEbpfAttachType(2)
 	})
 	qt.Assert(t, qt.IsNil(err))
 	qt.Assert(t, qt.Equals(allocs, 0))

internal/testutils/bpffs_windows_test.go

@@ -30,7 +30,7 @@ func TestTempBPFFS(t *testing.T) {
 		qt.Assert(t, qt.IsNil(err))
 
 		progFd, err := sys.ProgLoad(&sys.ProgLoadAttr{
-			ProgType: 998, // XDP_TEST
+			ProgType: 999, // SAMPLE
 			License:  sys.NewStringPointer(""),
 			InsnCnt:  uint32(buffer.Len() / asm.InstructionSize),
 			Insns:    sys.SlicePointer(buffer.Bytes()),

linker_test.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/cilium/ebpf/asm"
 	"github.com/cilium/ebpf/btf"
-	"github.com/cilium/ebpf/internal"
 	"github.com/cilium/ebpf/internal/testutils"
 
 	"github.com/go-quicktest/qt"
@@ -45,10 +44,7 @@ func TestFindReferences(t *testing.T) {
 	testutils.SkipIfNotSupported(t, err)
 	qt.Assert(t, qt.IsNil(err))
 
-	ret, _, err := prog.Test(internal.EmptyBPFContext)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ret := mustRun(t, prog, nil)
 
 	if ret != 1337 {
 		t.Errorf("Expected return code 1337, got %d", ret)
@@ -91,10 +87,8 @@ func TestForwardFunctionDeclaration(t *testing.T) {
 	testutils.SkipIfNotSupported(t, err)
 	qt.Assert(t, qt.IsNil(err))
 
-	ret, _, err := prog.Test(internal.EmptyBPFContext)
-	if err != nil {
-		t.Fatal("Running program:", err)
-	}
+	ret := mustRun(t, prog, nil)
+
 	if ret != 23 {
 		t.Fatalf("Expected 23, got %d", ret)
 	}

pin/load_test.go

@@ -18,7 +18,7 @@ func mustPinnedProgram(t *testing.T, path string) *ebpf.Program {
 
 	typ := ebpf.SocketFilter
 	if platform.IsWindows {
-		typ = ebpf.WindowsXDPTest
+		typ = ebpf.WindowsSample
 	}
 
 	spec := &ebpf.ProgramSpec{

prog_test.go

@@ -79,36 +79,33 @@ func TestProgramRun(t *testing.T) {
 	prog.Close()
 	prog = p2
 
-	ret, out, err := prog.Test(buf)
-	testutils.SkipIfNotSupported(t, err)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if ret != 42 {
-		t.Error("Expected return value to be 42, got", ret)
-	}
-
-	if !bytes.Equal(out[:len(pat)], pat) {
-		t.Errorf("Expected %v, got %v", pat, out)
-	}
+	out := make([]byte, len(buf))
+	ret := mustRun(t, prog, &RunOptions{Data: buf, DataOut: out})
+	qt.Assert(t, qt.Equals(ret, 42))
+	qt.Assert(t, qt.DeepEquals(out[:len(pat)], pat))
 }
 
 func TestProgramRunWithOptions(t *testing.T) {
 	testutils.SkipOnOldKernel(t, "5.15", "XDP ctx_in/ctx_out")
 
-	prog := createProgram(t, XDP, int64(sys.XDP_ABORTED))
-
 	buf := internal.EmptyBPFContext
+	var prog *Program
 	var in, out any
 	if platform.IsWindows {
-		type winXdpMd struct {
-			Data, DataEnd, DataMeta uint64
-			Ifindex                 uint32
+		type winSampleProgramContext struct {
+			_           uint64 // data_start (currently leaks kernel pointer)
+			_           uint64 // data_end (currently leaks kernel pointer)
+			Uint32Data  uint32
+			Uint16Data  uint16
+			_           uint16
+			HelperData1 uint32
+			HelperData2 uint32
 		}
-		in = &winXdpMd{Data: 0, DataEnd: uint64(len(buf))}
-		out = &winXdpMd{}
+		prog = createProgram(t, WindowsSample, 0)
+		in = &winSampleProgramContext{Uint32Data: 23, HelperData2: 42}
+		out = &winSampleProgramContext{Uint32Data: 23, HelperData2: 42}
 	} else {
+		prog = createProgram(t, XDP, int64(sys.XDP_ABORTED))
 		in = &sys.XdpMd{Data: 0, DataEnd: uint32(len(buf))}
 		out = &sys.XdpMd{}
 	}
@@ -155,6 +152,10 @@ func TestProgramRunEmptyData(t *testing.T) {
 }
 
 func TestProgramBenchmark(t *testing.T) {
+	if platform.IsWindows {
+		t.Skip("BPF_PROG_TEST_RUN requires providing context on Windows")
+	}
+
 	prog := createBasicProgram(t)
 
 	ret, duration, err := prog.Benchmark(internal.EmptyBPFContext, 1, nil)

ringbuf/helper_test.go

@@ -0,0 +1,29 @@
+package ringbuf
+
+import (
+	"testing"
+
+	"github.com/go-quicktest/qt"
+
+	"github.com/cilium/ebpf"
+	"github.com/cilium/ebpf/internal"
+	"github.com/cilium/ebpf/internal/platform"
+	"github.com/cilium/ebpf/internal/testutils"
+)
+
+func mustRun(tb testing.TB, prog *ebpf.Program) {
+	tb.Helper()
+
+	opts := &ebpf.RunOptions{
+		Data: internal.EmptyBPFContext,
+	}
+	if platform.IsWindows {
+		opts.Context = make([]byte, 32)
+	}
+
+	ret, err := prog.Run(opts)
+	testutils.SkipIfNotSupported(tb, err)
+	qt.Assert(tb, qt.IsNil(err))
+
+	qt.Assert(tb, qt.Equals(ret, uint32(0)))
+}