elf_reader: add tests for ELF objects without BTF

Adds infrastructure to test loading of ELF objects compiled without BTF information.

Signed-off-by: Pavan More <pavansmore05@gmail.com>
Co-authored-by: Timo Beckers <timo@isovalent.com>

Author: puwun

Makefile

@@ -45,6 +45,7 @@ TARGETS := \
 	testdata/loader-clang-14 \
 	testdata/loader-clang-17 \
 	testdata/loader-$(CLANG) \
+	testdata/loader_nobtf \
 	testdata/manyprogs \
 	testdata/btf_map_init \
 	testdata/invalid_map \
@@ -126,6 +127,12 @@ testdata/loader-%-eb.elf: testdata/loader.c
 	$(CLANG) $(CFLAGS) -target bpfeb -c $< -o $@
 	$(STRIP) -g $@
 
+testdata/loader_nobtf-el.elf: testdata/loader.c
+	$(CLANG) $(CFLAGS) -D__NOBTF__ -target bpfel -c $< -o $@
+
+testdata/loader_nobtf-eb.elf: testdata/loader.c
+	$(CLANG) $(CFLAGS) -D__NOBTF__ -target bpfeb -c $< -o $@
+
 testdata/linked-el.elf: testdata/linked1-el.elf testdata/linked2-el.elf
 	bpftool gen object $@ $^
 

btf/testdata/tags-eb.elf

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"flag"
 	"fmt"
+	"maps"
 	"os"
 	"path/filepath"
 	"strings"
@@ -59,76 +60,11 @@ func TestLoadCollectionSpec(t *testing.T) {
 				ValueSize:  8,
 				MaxEntries: 2,
 			},
-			"array_of_hash_map": {
-				Name:       "array_of_hash_map",
-				Type:       ArrayOfMaps,
-				KeySize:    4,
-				MaxEntries: 2,
-			},
 			"perf_event_array": {
 				Name:       "perf_event_array",
 				Type:       PerfEventArray,
 				MaxEntries: 4096,
 			},
-			"btf_pin": {
-				Name:       "btf_pin",
-				Type:       Hash,
-				KeySize:    4,
-				ValueSize:  8,
-				MaxEntries: 1,
-				Pinning:    PinByName,
-			},
-			"bpf_decl_map": {
-				Name:       "bpf_decl_map",
-				Type:       Array,
-				KeySize:    4,
-				ValueSize:  8,
-				MaxEntries: 1,
-				Tags:       []string{"a", "b"},
-			},
-			"btf_decl_map": {
-				Name:       "btf_decl_map",
-				Type:       Array,
-				KeySize:    4,
-				ValueSize:  8,
-				MaxEntries: 1,
-				Tags:       []string{"a", "b"},
-			},
-			"btf_outer_map": {
-				Name:       "btf_outer_map",
-				Type:       ArrayOfMaps,
-				KeySize:    4,
-				ValueSize:  4,
-				MaxEntries: 1,
-				InnerMap: &MapSpec{
-					Name:       "btf_outer_map_inner",
-					Type:       Hash,
-					KeySize:    4,
-					ValueSize:  4,
-					MaxEntries: 1,
-				},
-			},
-			"btf_outer_map_anon": {
-				Name:       "btf_outer_map_anon",
-				Type:       ArrayOfMaps,
-				KeySize:    4,
-				ValueSize:  4,
-				MaxEntries: 1,
-				InnerMap: &MapSpec{
-					Name:       "btf_outer_map_anon_inner",
-					Type:       Hash,
-					KeySize:    4,
-					ValueSize:  4,
-					MaxEntries: 1,
-				},
-			},
-			"btf_typedef_map": {
-				Name:       "btf_typedef_map",
-				Type:       Array,
-				KeySize:    4,
-				ValueSize:  8,
-				MaxEntries: 1,
-			},
 			".bss": {
 				Name:       ".bss",
 				Type:       Array,
@@ -232,38 +168,107 @@ func TestLoadCollectionSpec(t *testing.T) {
 		},
 	}
 
+	// BTF-only maps.
+	btfOnly := map[string]*MapSpec{
+		"btf_pin": {
+			Name:       "btf_pin",
+			Type:       Hash,
+			KeySize:    4,
+			ValueSize:  8,
+			MaxEntries: 1,
+			Pinning:    PinByName,
+		},
+		"bpf_decl_map": {
+			Name:       "bpf_decl_map",
+			Type:       Array,
+			KeySize:    4,
+			ValueSize:  8,
+			MaxEntries: 1,
+			Tags:       []string{"a", "b"},
+		},
+		"btf_decl_map": {
+			Name:       "btf_decl_map",
+			Type:       Array,
+			KeySize:    4,
+			ValueSize:  8,
+			MaxEntries: 1,
+			Tags:       []string{"a", "b"},
+		},
+		"btf_outer_map": {
+			Name:       "btf_outer_map",
+			Type:       ArrayOfMaps,
+			KeySize:    4,
+			ValueSize:  4,
+			MaxEntries: 1,
+			InnerMap: &MapSpec{
+				Name:       "btf_outer_map_inner",
+				Type:       Hash,
+				KeySize:    4,
+				ValueSize:  4,
+				MaxEntries: 1,
+			},
+		},
+		"btf_outer_map_anon": {
+			Name:       "btf_outer_map_anon",
+			Type:       ArrayOfMaps,
+			KeySize:    4,
+			ValueSize:  4,
+			MaxEntries: 1,
+			InnerMap: &MapSpec{
+				Name:       "btf_outer_map_anon_inner",
+				Type:       Hash,
+				KeySize:    4,
+				ValueSize:  4,
+				MaxEntries: 1,
+			},
+		},
+		"btf_typedef_map": {
+			Name:       "btf_typedef_map",
+			Type:       Array,
+			KeySize:    4,
+			ValueSize:  8,
+			MaxEntries: 1,
+		},
+	}
+
 	testutils.Files(t, testutils.Glob(t, "testdata/loader-*.elf"), func(t *testing.T, file string) {
-		have, err := LoadCollectionSpec(file)
-		if err != nil {
-			t.Fatal("Can't parse ELF:", err)
-		}
+		got, err := LoadCollectionSpec(file)
+		qt.Assert(t, qt.IsNil(err))
 
-		qt.Assert(t, qt.Equals(have.Maps["perf_event_array"].ValueSize, 0))
-		qt.Assert(t, qt.IsNotNil(have.Maps["perf_event_array"].Value))
+		// BTF map definition contains a value type, but the size should remain 0.
+		// The value type needs to be reflected in the MapSpec.
+		qt.Assert(t, qt.Equals(got.Maps["perf_event_array"].ValueSize, 0))
+		qt.Assert(t, qt.IsNotNil(got.Maps["perf_event_array"].Value))
 
-		qt.Assert(t, qt.CmpEquals(have, coll, csCmpOpts))
+		// Copy and extend the CollectionSpec with BTF-only objects.
+		want := coll.Copy()
+		maps.Copy(want.Maps, btfOnly)
 
-		qt.Assert(t, qt.IsNil(have.Variables["arg"].Set(uint32(1))))
-		qt.Assert(t, qt.IsNil(have.Variables["arg2"].Set(uint32(2))))
+		testLoadCollectionSpec(t, got, want)
+	})
 
-		have.Maps["array_of_hash_map"].InnerMap = have.Maps["hash_map"]
-		coll, err := newCollection(t, have, &CollectionOptions{
-			Maps: MapOptions{
-				PinPath: testutils.TempBPFFS(t),
-			},
-			Programs: ProgramOptions{
-				LogLevel: LogLevelBranch,
-			},
-		})
+	testutils.Files(t, testutils.Glob(t, "testdata/loader_nobtf-*.elf"), func(t *testing.T, file string) {
+		got, err := LoadCollectionSpec(file)
+		qt.Assert(t, qt.IsNil(err))
 
-		testutils.SkipIfNotSupported(t, err)
-		if err != nil {
-			t.Fatal(err)
-		}
+		testLoadCollectionSpec(t, got, coll.Copy())
+	})
+}
+
+func testLoadCollectionSpec(t *testing.T, got, want *CollectionSpec) {
+	t.Helper()
 
-		ret := mustRun(t, coll.Programs["xdp_prog"], nil)
-		qt.Assert(t, qt.Equals(ret, 7))
+	qt.Assert(t, qt.CmpEquals(got, want, csCmpOpts))
+
+	coll, err := newCollection(t, got, &CollectionOptions{
+		Maps:     MapOptions{PinPath: testutils.TempBPFFS(t)},
+		Programs: ProgramOptions{LogLevel: LogLevelBranch},
 	})
+	testutils.SkipIfNotSupported(t, err)
+	qt.Assert(t, qt.IsNil(err))
+
+	ret := mustRun(t, coll.Programs["xdp_prog"], nil)
+	qt.Assert(t, qt.Equals(ret, 7))
 }
 
 func BenchmarkELFLoader(b *testing.B) {

elf_reader_test.go

@@ -5,103 +5,11 @@
 
 char __license[] __section("license") = "MIT";
 
-struct {
-	__uint(type, BPF_MAP_TYPE_HASH);
-	__type(key, uint32_t);
-	__type(value, uint64_t);
-	__uint(max_entries, 1);
-	__uint(map_flags, BPF_F_NO_PREALLOC);
-} hash_map __section(".maps");
-
-struct {
-	__uint(type, BPF_MAP_TYPE_HASH);
-	__uint(key_size, sizeof(uint32_t));
-	__uint(value_size, sizeof(uint64_t));
-	__uint(max_entries, 2);
-} hash_map2 __section(".maps");
-
-struct {
-	__uint(type, BPF_MAP_TYPE_HASH);
-	__type(key, uint32_t);
-	__type(value, uint64_t);
-	__uint(max_entries, 1);
-	__uint(pinning, 1 /* LIBBPF_PIN_BY_NAME */);
-} btf_pin __section(".maps");
-
-// Named map type definition, without structure variable declaration.
-struct inner_map_t {
-	__uint(type, BPF_MAP_TYPE_HASH);
-	__type(key, uint32_t);
-	__type(value, int);
-	__uint(max_entries, 1);
-};
-
-// Anonymous map type definition with structure variable declaration.
-struct {
-	__uint(type, BPF_MAP_TYPE_ARRAY_OF_MAPS);
-	__uint(key_size, sizeof(uint32_t));
-	__uint(max_entries, 1);
-	__array(values, struct inner_map_t);
-} btf_outer_map __section(".maps");
-
-// Array of maps with anonymous inner struct.
-struct {
-	__uint(type, BPF_MAP_TYPE_ARRAY_OF_MAPS);
-	__uint(key_size, sizeof(uint32_t));
-	__uint(max_entries, 1);
-	__array(
-		values, struct {
-			__uint(type, BPF_MAP_TYPE_HASH);
-			__uint(max_entries, 1);
-			__type(key, uint32_t);
-			__type(value, uint32_t);
-		});
-} btf_outer_map_anon __section(".maps");
-
-struct perf_event {
-	uint64_t foo;
-	uint64_t bar;
-};
-
-struct {
-	__uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY);
-	__uint(max_entries, 4096);
-	__type(value, struct perf_event);
-} perf_event_array __section(".maps");
-
-struct bpf_map_def array_of_hash_map __section("maps") = {
-	.type        = BPF_MAP_TYPE_ARRAY_OF_MAPS,
-	.key_size    = sizeof(uint32_t),
-	.max_entries = 2,
-};
-
-typedef struct {
-	__uint(type, BPF_MAP_TYPE_ARRAY);
-	__uint(key_size, sizeof(uint32_t));
-	__uint(value_size, sizeof(uint64_t));
-	__uint(max_entries, 1);
-} array_map_t;
-
-// Map definition behind a typedef.
-array_map_t btf_typedef_map __section(".maps");
-
-#define __decl_tags __attribute__((btf_decl_tag("a"), btf_decl_tag("b")))
-
-// Legacy map definition decorated with decl tags.
-struct bpf_map_def bpf_decl_map __decl_tags __section("maps") = {
-	.type        = BPF_MAP_TYPE_ARRAY,
-	.key_size    = sizeof(uint32_t),
-	.value_size  = sizeof(uint64_t),
-	.max_entries = 1,
-};
-
-// BTF map definition decorated with decl tags.
-struct {
-	__uint(type, BPF_MAP_TYPE_ARRAY);
-	__uint(key_size, sizeof(uint32_t));
-	__uint(value_size, sizeof(uint64_t));
-	__uint(max_entries, 1);
-} btf_decl_map __decl_tags __section(".maps");
+#ifdef __NOBTF__
+#include "loader_nobtf.h"
+#else
+#include "loader.h"
+#endif
 
 static int __attribute__((noinline)) __section("static") static_fn(uint32_t arg) {
 	return arg - 1;
@@ -123,10 +31,10 @@ volatile unsigned int key1       = 0; // .bss
 volatile unsigned int key2       = 1; // .data
 volatile const unsigned int key3 = 2; // .rodata
 
-// .rodata, populated by loader
-volatile const uint32_t arg;
-// custom .rodata section, populated by loader
-volatile const uint32_t arg2 __section(".rodata.test");
+// .rodata
+volatile const uint32_t arg = 1;
+// custom .rodata section
+volatile const uint32_t arg2 __section(".rodata.test") = 2;
 // custom .data section
 volatile uint32_t arg3 __section(".data.test");